From 674bd98c52541a969a62c84e4a47f9f453d6aa75 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Tue, 20 Aug 2024 14:41:16 -0400
Subject: [PATCH 01/13] chore: enable eslint-plugin-perfectionist on
 eslint-plugin package

---
 eslint.config.mjs                             |   15 +-
 .../src/rules/adjacent-overload-signatures.ts |   47 +-
 .../eslint-plugin/src/rules/array-type.ts     |  125 +-
 .../eslint-plugin/src/rules/await-thenable.ts |   37 +-
 .../eslint-plugin/src/rules/ban-ts-comment.ts |  179 +-
 .../src/rules/ban-tslint-comment.ts           |   32 +-
 .../src/rules/class-literal-property-style.ts |   61 +-
 .../src/rules/class-methods-use-this.ts       |  147 +-
 .../rules/consistent-generic-constructors.ts  |   57 +-
 .../rules/consistent-indexed-object-style.ts  |   57 +-
 .../src/rules/consistent-return.ts            |   44 +-
 .../src/rules/consistent-type-assertions.ts   |  137 +-
 .../src/rules/consistent-type-definitions.ts  |   49 +-
 .../src/rules/consistent-type-exports.ts      |   93 +-
 .../src/rules/consistent-type-imports.ts      |  153 +-
 .../src/rules/default-param-last.ts           |   29 +-
 .../eslint-plugin/src/rules/dot-notation.ts   |  102 +-
 .../rules/explicit-function-return-type.ts    |  168 +-
 .../rules/explicit-member-accessibility.ts    |  187 +-
 .../rules/explicit-module-boundary-types.ts   |  176 +-
 .../src/rules/init-declarations.ts            |   30 +-
 .../eslint-plugin/src/rules/max-params.ts     |   68 +-
 .../src/rules/member-ordering.ts              |  253 +-
 .../src/rules/method-signature-style.ts       |   61 +-
 .../rules/naming-convention-utils/enums.ts    |   48 +-
 .../rules/naming-convention-utils/format.ts   |    6 +-
 .../rules/naming-convention-utils/index.ts    |    4 +-
 .../naming-convention-utils/parse-options.ts  |   45 +-
 .../rules/naming-convention-utils/schema.ts   |  111 +-
 .../rules/naming-convention-utils/shared.ts   |    3 +-
 .../rules/naming-convention-utils/types.ts    |   28 +-
 .../naming-convention-utils/validator.ts      |   72 +-
 .../src/rules/naming-convention.ts            |  486 +-
 .../src/rules/no-array-constructor.ts         |   35 +-
 .../src/rules/no-array-delete.ts              |   41 +-
 .../src/rules/no-base-to-string.ts            |   67 +-
 .../rules/no-confusing-non-null-assertion.ts  |   59 +-
 .../src/rules/no-confusing-void-expression.ts |  128 +-
 .../src/rules/no-dupe-class-members.ts        |   26 +-
 .../src/rules/no-duplicate-enum-values.ts     |   33 +-
 .../rules/no-duplicate-type-constituents.ts   |   85 +-
 .../src/rules/no-dynamic-delete.ts            |   33 +-
 .../src/rules/no-empty-function.ts            |   40 +-
 .../src/rules/no-empty-interface.ts           |   73 +-
 .../src/rules/no-empty-object-type.ts         |   99 +-
 .../src/rules/no-explicit-any.ts              |   97 +-
 .../src/rules/no-extra-non-null-assertion.ts  |   38 +-
 .../src/rules/no-extraneous-class.ts          |  105 +-
 .../src/rules/no-floating-promises.ts         |  134 +-
 .../src/rules/no-for-in-array.ts              |   30 +-
 .../src/rules/no-implied-eval.ts              |   43 +-
 .../src/rules/no-import-type-side-effects.ts  |   35 +-
 .../src/rules/no-inferrable-types.ts          |   81 +-
 .../src/rules/no-invalid-this.ts              |   40 +-
 .../src/rules/no-invalid-void-type.ts         |   97 +-
 .../eslint-plugin/src/rules/no-loop-func.ts   |   34 +-
 .../src/rules/no-loss-of-precision.ts         |   15 +-
 .../src/rules/no-magic-numbers.ts             |   56 +-
 .../src/rules/no-meaningless-void-operator.ts |   73 +-
 .../eslint-plugin/src/rules/no-misused-new.ts |   59 +-
 .../src/rules/no-misused-promises.ts          |  137 +-
 .../eslint-plugin/src/rules/no-mixed-enums.ts |   31 +-
 .../eslint-plugin/src/rules/no-namespace.ts   |   75 +-
 ...no-non-null-asserted-nullish-coalescing.ts |   41 +-
 .../no-non-null-asserted-optional-chain.ts    |   42 +-
 .../src/rules/no-non-null-assertion.ts        |   49 +-
 .../eslint-plugin/src/rules/no-redeclare.ts   |  113 +-
 .../rules/no-redundant-type-constituents.ts   |   40 +-
 .../src/rules/no-require-imports.ts           |   63 +-
 .../src/rules/no-restricted-imports.ts        |  114 +-
 .../src/rules/no-restricted-types.ts          |  147 +-
 packages/eslint-plugin/src/rules/no-shadow.ts |  133 +-
 .../eslint-plugin/src/rules/no-this-alias.ts  |   83 +-
 .../eslint-plugin/src/rules/no-type-alias.ts  |  185 +-
 .../no-unnecessary-boolean-literal-compare.ts |  115 +-
 .../src/rules/no-unnecessary-condition.ts     |  141 +-
 ...necessary-parameter-property-assignment.ts |   99 +-
 .../src/rules/no-unnecessary-qualifier.ts     |   67 +-
 .../no-unnecessary-template-expression.ts     |   47 +-
 .../rules/no-unnecessary-type-arguments.ts    |   37 +-
 .../rules/no-unnecessary-type-assertion.ts    |  231 +-
 .../rules/no-unnecessary-type-constraint.ts   |   45 +-
 .../rules/no-unnecessary-type-parameters.ts   |   38 +-
 .../src/rules/no-unsafe-argument.ts           |  103 +-
 .../src/rules/no-unsafe-assignment.ts         |  123 +-
 .../eslint-plugin/src/rules/no-unsafe-call.ts |   45 +-
 .../rules/no-unsafe-declaration-merging.ts    |   33 +-
 .../src/rules/no-unsafe-enum-comparison.ts    |   41 +-
 .../src/rules/no-unsafe-function-type.ts      |   37 +-
 .../src/rules/no-unsafe-member-access.ts      |   57 +-
 .../src/rules/no-unsafe-return.ts             |   55 +-
 .../src/rules/no-unsafe-unary-minus.ts        |   32 +-
 .../src/rules/no-unused-expressions.ts        |   39 +-
 .../eslint-plugin/src/rules/no-unused-vars.ts |  193 +-
 .../src/rules/no-use-before-define.ts         |  115 +-
 .../src/rules/no-useless-constructor.ts       |   28 +-
 .../src/rules/no-useless-empty-export.ts      |   31 +-
 .../src/rules/no-var-requires.ts              |   55 +-
 .../src/rules/no-wrapper-object-types.ts      |   33 +-
 .../non-nullable-type-assertion-style.ts      |   35 +-
 .../src/rules/only-throw-error.ts             |   73 +-
 .../src/rules/parameter-properties.ts         |  117 +-
 .../src/rules/prefer-as-const.ts              |   57 +-
 .../src/rules/prefer-destructuring.ts         |   98 +-
 .../src/rules/prefer-enum-initializers.ts     |   44 +-
 .../eslint-plugin/src/rules/prefer-find.ts    |   55 +-
 .../eslint-plugin/src/rules/prefer-for-of.ts  |   33 +-
 .../src/rules/prefer-function-type.ts         |   47 +-
 .../src/rules/prefer-includes.ts              |   59 +-
 .../src/rules/prefer-literal-enum-member.ts   |   65 +-
 .../src/rules/prefer-namespace-keyword.ts     |   36 +-
 .../src/rules/prefer-nullish-coalescing.ts    |  155 +-
 .../PreferOptionalChainOptions.ts             |   14 +-
 .../analyzeChain.ts                           |   26 +-
 .../checkNullishAndReport.ts                  |    3 +-
 .../compareNodes.ts                           |    1 +
 .../gatherLogicalOperands.ts                  |   34 +-
 .../src/rules/prefer-optional-chain.ts        |  264 +-
 .../src/rules/prefer-promise-reject-errors.ts |   61 +-
 .../rules/prefer-readonly-parameter-types.ts  |   82 +-
 .../src/rules/prefer-readonly.ts              |  209 +-
 .../src/rules/prefer-reduce-type-parameter.ts |   45 +-
 .../src/rules/prefer-regexp-exec.ts           |   67 +-
 .../src/rules/prefer-return-this-type.ts      |   41 +-
 .../rules/prefer-string-starts-ends-with.ts   |   95 +-
 .../src/rules/prefer-ts-expect-error.ts       |   39 +-
 .../src/rules/promise-function-async.ts       |  121 +-
 .../src/rules/require-array-sort-compare.ts   |   66 +-
 .../eslint-plugin/src/rules/require-await.ts  |   73 +-
 .../src/rules/restrict-plus-operands.ts       |  149 +-
 .../rules/restrict-template-expressions.ts    |  107 +-
 .../eslint-plugin/src/rules/return-await.ts   |  139 +-
 .../src/rules/sort-type-constituents.ts       |  153 +-
 .../src/rules/strict-boolean-expressions.ts   |  433 +-
 .../src/rules/switch-exhaustiveness-check.ts  |  111 +-
 .../src/rules/triple-slash-reference.ts       |  107 +-
 packages/eslint-plugin/src/rules/typedef.ts   |   83 +-
 .../eslint-plugin/src/rules/unbound-method.ts |   73 +-
 .../src/rules/unified-signatures.ts           |  120 +-
 .../use-unknown-in-catch-callback-variable.ts |  101 +-
 packages/eslint-plugin/src/util/astUtils.ts   |    5 +-
 .../src/util/collectUnusedVariables.ts        |  249 +-
 .../src/util/explicitReturnTypeUtils.ts       |    7 +-
 .../src/util/getESLintCoreRule.ts             |    2 +-
 .../eslint-plugin/src/util/getFixOrSuggest.ts |    4 +-
 .../src/util/getForStatementHeadLoc.ts        |    3 +-
 .../src/util/getFunctionHeadLoc.ts            |    3 +-
 .../src/util/getMemberHeadLoc.ts              |    7 +-
 .../src/util/getOperatorPrecedence.ts         |  131 +-
 .../src/util/getStaticStringValue.ts          |    1 +
 .../src/util/getThisExpression.ts             |    1 +
 .../src/util/getWrappingFixer.ts              |   17 +-
 packages/eslint-plugin/src/util/index.ts      |   10 +-
 packages/eslint-plugin/src/util/isAssignee.ts |    1 +
 .../eslint-plugin/src/util/isNodeEqual.ts     |    1 +
 .../eslint-plugin/src/util/isNullLiteral.ts   |    1 +
 .../src/util/isStartOfExpressionStatement.ts  |    1 +
 .../eslint-plugin/src/util/isTypeImport.ts    |    1 +
 .../src/util/isUndefinedIdentifier.ts         |    1 +
 packages/eslint-plugin/src/util/misc.ts       |   29 +-
 .../src/util/needsPrecedingSemiColon.ts       |    3 +-
 .../src/util/referenceContainsTypeQuery.ts    |    1 +
 packages/eslint-plugin/src/util/types.ts      |    4 +-
 packages/eslint-plugin/tests/RuleTester.ts    |    8 +-
 .../tests/areOptionsValid.test.ts             |   14 +-
 .../eslint-plugin/tests/areOptionsValid.ts    |   13 +-
 packages/eslint-plugin/tests/configs.test.ts  |   30 +-
 packages/eslint-plugin/tests/docs.test.ts     |   31 +-
 .../tests/eslint-rules/arrow-parens.test.ts   |    2 +-
 .../tests/eslint-rules/no-dupe-args.test.ts   |    2 +-
 .../eslint-rules/no-implicit-globals.test.ts  |    2 +-
 .../no-restricted-globals.test.ts             |   92 +-
 .../tests/eslint-rules/no-undef.test.ts       |  354 +-
 .../tests/eslint-rules/prefer-const.test.ts   |    2 +-
 .../tests/eslint-rules/strict.test.ts         |   34 +-
 .../adjacent-overload-signatures.test.ts      | 1234 +--
 .../tests/rules/array-type.test.ts            | 2629 +++----
 .../tests/rules/await-thenable.test.ts        |  362 +-
 .../tests/rules/ban-ts-comment.test.ts        | 1054 +--
 .../tests/rules/ban-tslint-comment.test.ts    |   34 +-
 .../class-literal-property-style.test.ts      |  936 +--
 .../class-methods-use-this-core.test.ts       |  400 +-
 .../class-methods-use-this.test.ts            |  716 +-
 .../consistent-generic-constructors.test.ts   |  288 +-
 .../consistent-indexed-object-style.test.ts   |  330 +-
 .../tests/rules/consistent-return.test.ts     |  490 +-
 .../rules/consistent-type-assertions.test.ts  |  371 +-
 .../rules/consistent-type-definitions.test.ts |  298 +-
 .../rules/consistent-type-exports.test.ts     |  302 +-
 .../rules/consistent-type-imports.test.ts     | 2618 +++----
 .../tests/rules/default-param-last.test.ts    |  428 +-
 .../tests/rules/dot-notation.test.ts          |  344 +-
 .../explicit-function-return-type.test.ts     | 2340 +++---
 .../explicit-member-accessibility.test.ts     | 2786 +++----
 .../explicit-module-boundary-types.test.ts    | 2680 +++----
 .../tests/rules/init-declarations.test.ts     | 1128 +--
 .../tests/rules/max-params.test.ts            |   84 +-
 .../tests/rules/member-ordering.test.ts       | 6630 ++++++++--------
 ...habetically-case-insensitive-order.test.ts |  564 +-
 ...mber-ordering-alphabetically-order.test.ts | 1738 ++---
 ...ing-natural-case-insensitive-order.test.ts |   98 +-
 .../member-ordering-natural-order.test.ts     |   98 +-
 .../member-ordering-optionalMembers.test.ts   |  202 +-
 .../rules/method-signature-style.test.ts      |  458 +-
 .../cases/createTestCases.ts                  |   84 +-
 .../naming-convention/cases/default.test.ts   |    2 +-
 .../cases/parameterProperty.test.ts           |    2 +-
 .../naming-convention.test.ts                 | 2348 +++---
 .../tests/rules/no-array-constructor.test.ts  |   76 +-
 .../tests/rules/no-array-delete.test.ts       |  154 +-
 .../tests/rules/no-base-to-string.test.ts     |  162 +-
 .../no-confusing-non-null-assertion.test.ts   |   50 +-
 .../no-confusing-void-expression.test.ts      |  312 +-
 .../tests/rules/no-dupe-class-members.test.ts |  172 +-
 .../rules/no-duplicate-enum-values.test.ts    |  116 +-
 .../no-duplicate-type-constituents.test.ts    |  588 +-
 .../tests/rules/no-dynamic-delete.test.ts     |  102 +-
 .../tests/rules/no-empty-function.test.ts     |  180 +-
 .../tests/rules/no-empty-interface.test.ts    |  204 +-
 .../tests/rules/no-empty-object-type.test.ts  |  212 +-
 .../tests/rules/no-explicit-any.test.ts       | 1990 ++---
 .../rules/no-extra-non-null-assertion.test.ts |  182 +-
 .../tests/rules/no-extraneous-class.test.ts   |  172 +-
 .../tests/rules/no-floating-promises.test.ts  | 6830 ++++++++---------
 .../tests/rules/no-for-in-array.test.ts       |   70 +-
 .../tests/rules/no-implied-eval.test.ts       | 1106 +--
 .../rules/no-import-type-side-effects.test.ts |   36 +-
 .../tests/rules/no-inferrable-types.test.ts   |  280 +-
 .../tests/rules/no-invalid-this.test.ts       | 1186 +--
 .../tests/rules/no-invalid-void-type.test.ts  |  352 +-
 .../tests/rules/no-loop-func.test.ts          |  524 +-
 .../tests/rules/no-loss-of-precision.test.ts  |   16 +-
 .../tests/rules/no-magic-numbers.test.ts      |  758 +-
 .../no-meaningless-void-operator.test.ts      |   66 +-
 .../tests/rules/no-misused-new.test.ts        |  164 +-
 .../tests/rules/no-misused-promises.test.ts   | 2904 +++----
 .../tests/rules/no-mixed-enums.test.ts        |  526 +-
 .../tests/rules/no-namespace.test.ts          |  322 +-
 ...n-null-asserted-nullish-coalescing.test.ts |  110 +-
 ...o-non-null-asserted-optional-chain.test.ts |   30 +-
 .../tests/rules/no-non-null-assertion.test.ts |  118 +-
 .../tests/rules/no-redeclare.test.ts          |  406 +-
 .../no-redundant-type-constituents.test.ts    |  308 +-
 .../tests/rules/no-require-imports.test.ts    |  322 +-
 .../tests/rules/no-restricted-imports.test.ts |  626 +-
 .../tests/rules/no-restricted-types.test.ts   |  320 +-
 .../rules/no-shadow/no-shadow-eslint.test.ts  | 1488 ++--
 .../tests/rules/no-shadow/no-shadow.test.ts   | 1216 +--
 .../tests/rules/no-this-alias.test.ts         |   78 +-
 .../tests/rules/no-type-alias.test.ts         | 3926 +++++-----
 ...nnecessary-boolean-literal-compare.test.ts |  138 +-
 .../rules/no-unnecessary-condition.test.ts    | 3637 ++++-----
 ...sary-parameter-property-assignment.test.ts |  362 +-
 .../rules/no-unnecessary-qualifier.test.ts    |  136 +-
 ...no-unnecessary-template-expression.test.ts |  559 +-
 .../no-unnecessary-type-arguments.test.ts     |  288 +-
 .../no-unnecessary-type-assertion.test.ts     | 1377 ++--
 .../no-unnecessary-type-constraint.test.ts    |  172 +-
 .../no-unnecessary-type-parameters.test.ts    | 1040 +--
 .../tests/rules/no-unsafe-argument.test.ts    |  376 +-
 .../tests/rules/no-unsafe-assignment.test.ts  |  282 +-
 .../tests/rules/no-unsafe-call.test.ts        |  118 +-
 .../no-unsafe-declaration-merging.test.ts     |  118 +-
 .../rules/no-unsafe-enum-comparison.test.ts   |  644 +-
 .../rules/no-unsafe-function-type.test.ts     |   46 +-
 .../rules/no-unsafe-member-access.test.ts     |  218 +-
 .../tests/rules/no-unsafe-return.test.ts      |  430 +-
 .../tests/rules/no-unsafe-unary-minus.test.ts |   30 +-
 .../tests/rules/no-unused-expressions.test.ts |  197 +-
 .../no-unused-vars-eslint.test.ts             | 4532 +++++------
 .../no-unused-vars/no-unused-vars.test.ts     | 3820 ++++-----
 .../tests/rules/no-use-before-define.test.ts  | 1926 ++---
 .../rules/no-useless-constructor.test.ts      |  176 +-
 .../rules/no-useless-empty-export.test.ts     |   96 +-
 .../tests/rules/no-var-requires.test.ts       |  138 +-
 .../rules/no-wrapper-object-types.test.ts     |  218 +-
 .../non-nullable-type-assertion-style.test.ts |  144 +-
 .../tests/rules/only-throw-error.test.ts      |  262 +-
 .../tests/rules/parameter-properties.test.ts  | 1204 +--
 .../tests/rules/prefer-as-const.test.ts       |  280 +-
 .../tests/rules/prefer-destructuring.test.ts  | 1342 ++--
 .../rules/prefer-enum-initializers.test.ts    |   10 +-
 .../tests/rules/prefer-find.test.ts           |  130 +-
 .../tests/rules/prefer-for-of.test.ts         |  370 +-
 .../tests/rules/prefer-function-type.test.ts  |  148 +-
 .../tests/rules/prefer-includes.test.ts       |  226 +-
 .../rules/prefer-literal-enum-member.test.ts  |  350 +-
 .../rules/prefer-namespace-keyword.test.ts    |   44 +-
 .../rules/prefer-nullish-coalescing.test.ts   | 2087 ++---
 .../rules/prefer-optional-chain/base-cases.ts |  116 +-
 .../prefer-optional-chain.test.ts             |  954 +--
 .../prefer-promise-reject-errors.test.ts      | 1298 ++--
 .../prefer-readonly-parameter-types.test.ts   | 1296 ++--
 .../tests/rules/prefer-readonly.test.ts       | 3352 ++++----
 .../prefer-reduce-type-parameter.test.ts      |  198 +-
 .../tests/rules/prefer-regexp-exec.test.ts    |  228 +-
 .../rules/prefer-return-this-type.test.ts     |  172 +-
 .../prefer-string-starts-ends-with.test.ts    |  764 +-
 .../rules/prefer-ts-expect-error.test.ts      |  128 +-
 .../rules/promise-function-async.test.ts      |  466 +-
 .../rules/require-array-sort-compare.test.ts  |  242 +-
 .../tests/rules/require-await.test.ts         |  750 +-
 .../rules/restrict-plus-operands.test.ts      | 1768 ++---
 .../restrict-template-expressions.test.ts     |  714 +-
 .../tests/rules/return-await.test.ts          | 2163 +++---
 .../rules/sort-type-constituents.test.ts      |  222 +-
 .../rules/strict-boolean-expressions.test.ts  | 4086 +++++-----
 .../rules/switch-exhaustiveness-check.test.ts | 2965 ++++---
 .../rules/triple-slash-reference.test.ts      |  140 +-
 .../eslint-plugin/tests/rules/typedef.test.ts | 1112 +--
 .../tests/rules/unbound-method.test.ts        | 2020 ++---
 .../tests/rules/unified-signatures.test.ts    |  532 +-
 ...unknown-in-catch-callback-variable.test.ts |  302 +-
 packages/eslint-plugin/tests/schemas.test.ts  |    6 +-
 .../tests/util/getWrappedCode.test.ts         |   41 +-
 .../tests/util/getWrappingFixer.test.ts       |   87 +-
 .../tests/util/isNodeEqual.test.ts            |   49 +-
 .../eslint-plugin/typings/eslint-rules.d.ts   |   80 +-
 .../eslint-plugin/typings/typescript.d.ts     |   16 +-
 319 files changed, 64801 insertions(+), 64590 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 60b302d8cb50..052489694f75 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -578,8 +578,13 @@ export default tseslint.config(
   },
   {
     extends: [perfectionistPlugin.configs['recommended-alphabetical']],
-    files: ['packages/utils/src/**/*.ts'],
+    ignores: ['packages/eslint-plugin/src/configs/*'],
+    files: [
+      'packages/eslint-plugin/{src,tests,tools,typings}/**/*.ts',
+      'packages/utils/src/**/*.ts',
+    ],
     rules: {
+      '@typescript-eslint/sort-type-constituents': 'off',
       'perfectionist/sort-classes': [
         'error',
         {
@@ -588,6 +593,14 @@ export default tseslint.config(
           type: 'natural',
         },
       ],
+      'perfectionist/sort-enums': [
+        'error',
+        {
+          order: 'asc',
+          partitionByComment: true,
+          type: 'natural',
+        },
+      ],
       'perfectionist/sort-objects': [
         'error',
         {
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index f28472e73a7b..5d8e094fe761 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, getNameFromMember, MemberNameType } from '../util';
@@ -21,24 +22,11 @@ type MemberDeclaration =
   | TSESTree.NamedExportDeclarations;
 
 export default createRule({
-  name: 'adjacent-overload-signatures',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require that function overload signatures be consecutive',
-      recommended: 'stylistic',
-    },
-    schema: [],
-    messages: {
-      adjacentSignature: 'All {{name}} signatures should be adjacent.',
-    },
-  },
-  defaultOptions: [],
   create(context) {
     interface Method {
+      callSignature: boolean;
       name: string;
       static?: boolean;
-      callSignature: boolean;
       type: MemberNameType;
     }
 
@@ -68,34 +56,34 @@ export default createRule({
             return null;
           }
           return {
-            name,
             callSignature: false,
+            name,
             type: MemberNameType.Normal,
           };
         }
         case AST_NODE_TYPES.TSMethodSignature:
           return {
             ...getNameFromMember(member, context.sourceCode),
-            static: !!member.static,
             callSignature: false,
+            static: !!member.static,
           };
         case AST_NODE_TYPES.TSCallSignatureDeclaration:
           return {
-            name: 'call',
             callSignature: true,
+            name: 'call',
             type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.TSConstructSignatureDeclaration:
           return {
-            name: 'new',
             callSignature: false,
+            name: 'new',
             type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.MethodDefinition:
           return {
             ...getNameFromMember(member, context.sourceCode),
-            static: !!member.static,
             callSignature: false,
+            static: !!member.static,
           };
       }
 
@@ -144,11 +132,11 @@ export default createRule({
         );
         if (index > -1 && !isSameMethod(method, lastMethod)) {
           context.report({
-            node: member,
-            messageId: 'adjacentSignature',
             data: {
               name: `${method.static ? 'static ' : ''}${method.name}`,
             },
+            messageId: 'adjacentSignature',
+            node: member,
           });
         } else if (index === -1) {
           seenMethods.push(method);
@@ -159,12 +147,25 @@ export default createRule({
     }
 
     return {
+      BlockStatement: checkBodyForOverloadMethods,
       ClassBody: checkBodyForOverloadMethods,
       Program: checkBodyForOverloadMethods,
+      TSInterfaceBody: checkBodyForOverloadMethods,
       TSModuleBlock: checkBodyForOverloadMethods,
       TSTypeLiteral: checkBodyForOverloadMethods,
-      TSInterfaceBody: checkBodyForOverloadMethods,
-      BlockStatement: checkBodyForOverloadMethods,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Require that function overload signatures be consecutive',
+      recommended: 'stylistic',
+    },
+    messages: {
+      adjacentSignature: 'All {{name}} signatures should be adjacent.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'adjacent-overload-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 742507ada730..92b53a9c7898 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isParenthesized } from '../util';
@@ -71,7 +72,7 @@ function typeNeedsParentheses(node: TSESTree.Node): boolean {
   }
 }
 
-export type OptionString = 'array-simple' | 'array' | 'generic';
+export type OptionString = 'array' | 'array-simple' | 'generic';
 type Options = [
   {
     default: OptionString;
@@ -80,65 +81,13 @@ type Options = [
 ];
 type MessageIds =
   | 'errorStringArray'
+  | 'errorStringArrayReadonly'
   | 'errorStringArraySimple'
+  | 'errorStringArraySimpleReadonly'
   | 'errorStringGeneric'
-  | 'errorStringGenericSimple'
-  | 'errorStringArrayReadonly'
-  | 'errorStringArraySimpleReadonly';
+  | 'errorStringGenericSimple';
 
 export default createRule<Options, MessageIds>({
-  name: 'array-type',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require consistently using either `T[]` or `Array<T>` for arrays',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      errorStringGeneric:
-        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden. Use '{{className}}<{{type}}>' instead.",
-      errorStringArray:
-        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}[]' instead.",
-      errorStringArrayReadonly:
-        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}' instead.",
-      errorStringArraySimple:
-        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}[]' instead.",
-      errorStringGenericSimple:
-        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.",
-      errorStringArraySimpleReadonly:
-        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.",
-    },
-    schema: [
-      {
-        $defs: {
-          arrayOption: {
-            type: 'string',
-            enum: ['array', 'generic', 'array-simple'],
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          default: {
-            $ref: '#/items/0/$defs/arrayOption',
-            description: 'The array type expected for mutable cases.',
-          },
-          readonly: {
-            $ref: '#/items/0/$defs/arrayOption',
-            description:
-              'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
-          },
-        },
-        type: 'object',
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      default: 'array',
-    },
-  ],
   create(context, [options]) {
     const defaultOption = options.default;
     const readonlyOption = options.readonly ?? defaultOption;
@@ -175,8 +124,6 @@ export default createRule<Options, MessageIds>({
         const errorNode = isReadonly ? node.parent : node;
 
         context.report({
-          node: errorNode,
-          messageId,
           data: {
             className: isReadonly ? 'ReadonlyArray' : 'Array',
             readonlyPrefix: isReadonly ? 'readonly ' : '',
@@ -197,6 +144,8 @@ export default createRule<Options, MessageIds>({
               ),
             ];
           },
+          messageId,
+          node: errorNode,
         });
       },
 
@@ -243,8 +192,6 @@ export default createRule<Options, MessageIds>({
         if (!typeParams || typeParams.length === 0) {
           // Create an 'any' array
           context.report({
-            node,
-            messageId,
             data: {
               className: isReadonlyArrayType ? 'ReadonlyArray' : 'Array',
               readonlyPrefix,
@@ -253,6 +200,8 @@ export default createRule<Options, MessageIds>({
             fix(fixer) {
               return fixer.replaceText(node, `${readonlyPrefix}any[]`);
             },
+            messageId,
+            node,
           });
 
           return;
@@ -277,8 +226,6 @@ export default createRule<Options, MessageIds>({
         }`;
         const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`;
         context.report({
-          node,
-          messageId,
           data: {
             className: isReadonlyArrayType ? node.typeName.name : 'Array',
             readonlyPrefix,
@@ -290,8 +237,62 @@ export default createRule<Options, MessageIds>({
               fixer.replaceTextRange([type.range[1], node.range[1]], end),
             ];
           },
+          messageId,
+          node,
         });
       },
     };
   },
+  defaultOptions: [
+    {
+      default: 'array',
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require consistently using either `T[]` or `Array<T>` for arrays',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      errorStringArray:
+        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}[]' instead.",
+      errorStringArrayReadonly:
+        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}' instead.",
+      errorStringArraySimple:
+        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}[]' instead.",
+      errorStringArraySimpleReadonly:
+        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.",
+      errorStringGeneric:
+        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden. Use '{{className}}<{{type}}>' instead.",
+      errorStringGenericSimple:
+        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.",
+    },
+    schema: [
+      {
+        $defs: {
+          arrayOption: {
+            enum: ['array', 'generic', 'array-simple'],
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          default: {
+            $ref: '#/items/0/$defs/arrayOption',
+            description: 'The array type expected for mutable cases.',
+          },
+          readonly: {
+            $ref: '#/items/0/$defs/arrayOption',
+            description:
+              'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'array-type',
 });
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index 084ea2447e89..71c13ee2e2cc 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -1,4 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 
 import {
@@ -12,23 +13,6 @@ import {
 } from '../util';
 
 export default createRule({
-  name: 'await-thenable',
-  meta: {
-    docs: {
-      description: 'Disallow awaiting a value that is not a Thenable',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
-      removeAwait: 'Remove unnecessary `await`.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  defaultOptions: [],
-
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -48,7 +32,6 @@ export default createRule({
             node,
             suggest: [
               {
-                messageId: 'removeAwait',
                 fix(fixer): TSESLint.RuleFix {
                   const awaitKeyword = nullThrows(
                     context.sourceCode.getFirstToken(node, isAwaitKeyword),
@@ -57,6 +40,7 @@ export default createRule({
 
                   return fixer.remove(awaitKeyword);
                 },
+                messageId: 'removeAwait',
               },
             ],
           });
@@ -64,4 +48,21 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow awaiting a value that is not a Thenable',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
+      removeAwait: 'Remove unnecessary `await`.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+
+  name: 'await-thenable',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index b554510f57d3..f00c6846f85c 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -1,107 +1,37 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, getStringLength, nullThrows } from '../util';
 
 type DirectiveConfig =
-  | boolean
   | 'allow-with-description'
-  | { descriptionFormat: string };
+  | { descriptionFormat: string }
+  | boolean;
 
 interface Options {
+  minimumDescriptionLength?: number;
+  'ts-check'?: DirectiveConfig;
   'ts-expect-error'?: DirectiveConfig;
   'ts-ignore'?: DirectiveConfig;
   'ts-nocheck'?: DirectiveConfig;
-  'ts-check'?: DirectiveConfig;
-  minimumDescriptionLength?: number;
 }
 
 const defaultMinimumDescriptionLength = 3;
 
 type MessageIds =
+  | 'replaceTsIgnoreWithTsExpectError'
   | 'tsDirectiveComment'
-  | 'tsIgnoreInsteadOfExpectError'
   | 'tsDirectiveCommentDescriptionNotMatchPattern'
   | 'tsDirectiveCommentRequiresDescription'
-  | 'replaceTsIgnoreWithTsExpectError';
+  | 'tsIgnoreInsteadOfExpectError';
 
 interface MatchedTSDirective {
-  directive: string;
   description: string;
+  directive: string;
 }
 
 export default createRule<[Options], MessageIds>({
-  name: 'ban-ts-comment',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow `@ts-<directive>` comments or require descriptions after directives',
-      recommended: {
-        recommended: true,
-        strict: [{ minimumDescriptionLength: 10 }],
-      },
-    },
-    messages: {
-      tsDirectiveComment:
-        'Do not use "@ts-{{directive}}" because it alters compilation errors.',
-      tsIgnoreInsteadOfExpectError:
-        'Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free.',
-      tsDirectiveCommentRequiresDescription:
-        'Include a description after the "@ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.',
-      tsDirectiveCommentDescriptionNotMatchPattern:
-        'The description for the "@ts-{{directive}}" directive must match the {{format}} format.',
-      replaceTsIgnoreWithTsExpectError:
-        'Replace "@ts-ignore" with "@ts-expect-error".',
-    },
-    hasSuggestions: true,
-    schema: [
-      {
-        $defs: {
-          directiveConfigSchema: {
-            oneOf: [
-              {
-                type: 'boolean',
-                default: true,
-              },
-              {
-                type: 'string',
-                enum: ['allow-with-description'],
-              },
-              {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                  descriptionFormat: { type: 'string' },
-                },
-              },
-            ],
-          },
-        },
-        properties: {
-          'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          minimumDescriptionLength: {
-            type: 'number',
-            default: defaultMinimumDescriptionLength,
-          },
-        },
-        type: 'object',
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      'ts-expect-error': 'allow-with-description',
-      'ts-ignore': true,
-      'ts-nocheck': true,
-      'ts-check': false,
-      minimumDescriptionLength: defaultMinimumDescriptionLength,
-    },
-  ],
   create(context, [options]) {
     // https://github.com/microsoft/TypeScript/blob/6f1ad5ad8bec5671f7e951a3524b62d82ec4be68/src/compiler/parser.ts#L10591
     const singleLinePragmaRegEx =
@@ -138,19 +68,19 @@ export default createRule<[Options], MessageIds>({
         return null;
       }
 
-      const { directive, description } = nullThrows(
+      const { description, directive } = nullThrows(
         match.groups,
         'RegExp should contain groups',
       );
       return {
-        directive: nullThrows(
-          directive,
-          'RegExp should contain "directive" group',
-        ),
         description: nullThrows(
           description,
           'RegExp should contain "description" group',
         ),
+        directive: nullThrows(
+          directive,
+          'RegExp should contain "directive" group',
+        ),
       };
     }
 
@@ -188,7 +118,7 @@ export default createRule<[Options], MessageIds>({
           if (!match) {
             return;
           }
-          const { directive, description } = match;
+          const { description, directive } = match;
 
           const fullDirective = `ts-${directive}` as keyof Options;
 
@@ -197,11 +127,10 @@ export default createRule<[Options], MessageIds>({
             if (directive === 'ignore') {
               // Special case to suggest @ts-expect-error instead of @ts-ignore
               context.report({
-                node: comment,
                 messageId: 'tsIgnoreInsteadOfExpectError',
+                node: comment,
                 suggest: [
                   {
-                    messageId: 'replaceTsIgnoreWithTsExpectError',
                     fix(fixer): TSESLint.RuleFix {
                       const commentText = comment.value.replace(
                         /@ts-ignore/,
@@ -214,14 +143,15 @@ export default createRule<[Options], MessageIds>({
                           : `/*${commentText}*/`,
                       );
                     },
+                    messageId: 'replaceTsIgnoreWithTsExpectError',
                   },
                 ],
               });
             } else {
               context.report({
                 data: { directive },
-                node: comment,
                 messageId: 'tsDirectiveComment',
+                node: comment,
               });
             }
           }
@@ -241,14 +171,14 @@ export default createRule<[Options], MessageIds>({
             ) {
               context.report({
                 data: { directive, minimumDescriptionLength },
-                node: comment,
                 messageId: 'tsDirectiveCommentRequiresDescription',
+                node: comment,
               });
             } else if (format && !format.test(description)) {
               context.report({
                 data: { directive, format: format.source },
-                node: comment,
                 messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+                node: comment,
               });
             }
           }
@@ -256,4 +186,75 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      minimumDescriptionLength: defaultMinimumDescriptionLength,
+      'ts-check': false,
+      'ts-expect-error': 'allow-with-description',
+      'ts-ignore': true,
+      'ts-nocheck': true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow `@ts-<directive>` comments or require descriptions after directives',
+      recommended: {
+        recommended: true,
+        strict: [{ minimumDescriptionLength: 10 }],
+      },
+    },
+    hasSuggestions: true,
+    messages: {
+      replaceTsIgnoreWithTsExpectError:
+        'Replace "@ts-ignore" with "@ts-expect-error".',
+      tsDirectiveComment:
+        'Do not use "@ts-{{directive}}" because it alters compilation errors.',
+      tsDirectiveCommentDescriptionNotMatchPattern:
+        'The description for the "@ts-{{directive}}" directive must match the {{format}} format.',
+      tsDirectiveCommentRequiresDescription:
+        'Include a description after the "@ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.',
+      tsIgnoreInsteadOfExpectError:
+        'Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free.',
+    },
+    schema: [
+      {
+        $defs: {
+          directiveConfigSchema: {
+            oneOf: [
+              {
+                default: true,
+                type: 'boolean',
+              },
+              {
+                enum: ['allow-with-description'],
+                type: 'string',
+              },
+              {
+                additionalProperties: false,
+                properties: {
+                  descriptionFormat: { type: 'string' },
+                },
+                type: 'object',
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          minimumDescriptionLength: {
+            default: defaultMinimumDescriptionLength,
+            type: 'number',
+          },
+          'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'ban-ts-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 4c84981a9fa3..95ed5d959788 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -16,20 +16,6 @@ const toText = (
     : ['/*', text.trim(), '*/'].join(' ');
 
 export default createRule({
-  name: 'ban-tslint-comment',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow `// tslint:<rule-flag>` comments',
-      recommended: 'stylistic',
-    },
-    messages: {
-      commentDetected: 'tslint comment detected: "{{ text }}"',
-    },
-    schema: [],
-    fixable: 'code',
-  },
-  defaultOptions: [],
   create: context => {
     return {
       Program(): void {
@@ -38,8 +24,6 @@ export default createRule({
           if (ENABLE_DISABLE_REGEX.test(c.value)) {
             context.report({
               data: { text: toText(c.value, c.type) },
-              node: c,
-              messageId: 'commentDetected',
               fix(fixer) {
                 const rangeStart = context.sourceCode.getIndexFromLoc({
                   column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0,
@@ -51,10 +35,26 @@ export default createRule({
                 });
                 return fixer.removeRange([rangeStart, rangeEnd + 1]);
               },
+              messageId: 'commentDetected',
+              node: c,
             });
           }
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow `// tslint:<rule-flag>` comments',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      commentDetected: 'tslint comment detected: "{{ text }}"',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'ban-tslint-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index 816c7803604a..13109cb32e28 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -22,8 +23,8 @@ interface NodeWithModifiers {
 }
 
 interface PropertiesInfo {
-  properties: TSESTree.PropertyDefinition[];
   excludeSet: Set<string>;
+  properties: TSESTree.PropertyDefinition[];
 }
 
 const printNodeModifiers = (
@@ -53,29 +54,6 @@ const isSupportedLiteral = (
 };
 
 export default createRule<Options, MessageIds>({
-  name: 'class-literal-property-style',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce that literals on classes are exposed in a consistent style',
-      recommended: 'stylistic',
-    },
-    hasSuggestions: true,
-    messages: {
-      preferFieldStyle: 'Literals should be exposed using readonly fields.',
-      preferFieldStyleSuggestion: 'Replace the literals with readonly fields.',
-      preferGetterStyle: 'Literals should be exposed using getters.',
-      preferGetterStyleSuggestion: 'Replace the literals with getters.',
-    },
-    schema: [
-      {
-        type: 'string',
-        enum: ['fields', 'getters'],
-      },
-    ],
-  },
-  defaultOptions: ['fields'],
   create(context, [style]) {
     const propertiesInfoStack: PropertiesInfo[] = [];
 
@@ -85,13 +63,13 @@ export default createRule<Options, MessageIds>({
 
     function enterClassBody(): void {
       propertiesInfoStack.push({
-        properties: [],
         excludeSet: new Set(),
+        properties: [],
       });
     }
 
     function exitClassBody(): void {
-      const { properties, excludeSet } = nullThrows(
+      const { excludeSet, properties } = nullThrows(
         propertiesInfoStack.pop(),
         'Stack should exist on class exit',
       );
@@ -108,11 +86,10 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node: node.key,
           messageId: 'preferGetterStyle',
+          node: node.key,
           suggest: [
             {
-              messageId: 'preferGetterStyleSuggestion',
               fix(fixer): TSESLint.RuleFix {
                 const name = context.sourceCode.getText(node.key);
 
@@ -123,6 +100,7 @@ export default createRule<Options, MessageIds>({
 
                 return fixer.replaceText(node, text);
               },
+              messageId: 'preferGetterStyleSuggestion',
             },
           ],
         });
@@ -181,11 +159,10 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node: node.key,
             messageId: 'preferFieldStyle',
+            node: node.key,
             suggest: [
               {
-                messageId: 'preferFieldStyleSuggestion',
                 fix(fixer): TSESLint.RuleFix {
                   const name = context.sourceCode.getText(node.key);
 
@@ -197,6 +174,7 @@ export default createRule<Options, MessageIds>({
 
                   return fixer.replaceText(node, text);
                 },
+                messageId: 'preferFieldStyleSuggestion',
               },
             ],
           });
@@ -234,4 +212,27 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
+  defaultOptions: ['fields'],
+  meta: {
+    docs: {
+      description:
+        'Enforce that literals on classes are exposed in a consistent style',
+      recommended: 'stylistic',
+    },
+    hasSuggestions: true,
+    messages: {
+      preferFieldStyle: 'Literals should be exposed using readonly fields.',
+      preferFieldStyleSuggestion: 'Replace the literals with readonly fields.',
+      preferGetterStyle: 'Literals should be exposed using getters.',
+      preferGetterStyleSuggestion: 'Replace the literals with getters.',
+    },
+    schema: [
+      {
+        enum: ['fields', 'getters'],
+        type: 'string',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'class-literal-property-style',
 });
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index 4f574471e03b..f0142a26010c 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -10,77 +11,15 @@ import {
 
 type Options = [
   {
-    exceptMethods?: string[];
     enforceForClassFields?: boolean;
+    exceptMethods?: string[];
+    ignoreClassesThatImplementAnInterface?: 'public-fields' | boolean;
     ignoreOverrideMethods?: boolean;
-    ignoreClassesThatImplementAnInterface?: boolean | 'public-fields';
   },
 ];
 type MessageIds = 'missingThis';
 
 export default createRule<Options, MessageIds>({
-  name: 'class-methods-use-this',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce that class methods utilize `this`',
-      extendsBaseRule: true,
-      requiresTypeChecking: false,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          exceptMethods: {
-            type: 'array',
-            description:
-              'Allows specified method names to be ignored with this rule',
-            items: {
-              type: 'string',
-            },
-          },
-          enforceForClassFields: {
-            type: 'boolean',
-            description:
-              'Enforces that functions used as instance field initializers utilize `this`',
-            default: true,
-          },
-          ignoreOverrideMethods: {
-            type: 'boolean',
-            description: 'Ignore members marked with the `override` modifier',
-          },
-          ignoreClassesThatImplementAnInterface: {
-            oneOf: [
-              {
-                type: 'boolean',
-                description: 'Ignore all classes that implement an interface',
-              },
-              {
-                type: 'string',
-                enum: ['public-fields'],
-                description:
-                  'Ignore only the public fields of classes that implement an interface',
-              },
-            ],
-            description:
-              'Ignore classes that specifically implement some interface',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      missingThis: "Expected 'this' to be used by class {{name}}.",
-    },
-  },
-  defaultOptions: [
-    {
-      enforceForClassFields: true,
-      exceptMethods: [],
-      ignoreClassesThatImplementAnInterface: false,
-      ignoreOverrideMethods: false,
-    },
-  ],
   create(
     context,
     [
@@ -95,14 +34,14 @@ export default createRule<Options, MessageIds>({
     const exceptMethods = new Set(exceptMethodsRaw);
     type Stack =
       | {
-          member: null;
           class: null;
+          member: null;
           parent: Stack | undefined;
           usesThis: boolean;
         }
       | {
-          member: TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
           class: TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+          member: TSESTree.MethodDefinition | TSESTree.PropertyDefinition;
           parent: Stack | undefined;
           usesThis: boolean;
         };
@@ -113,17 +52,17 @@ export default createRule<Options, MessageIds>({
     ): void {
       if (member?.parent.type === AST_NODE_TYPES.ClassBody) {
         stack = {
-          member,
           class: member.parent.parent,
-          usesThis: false,
+          member,
           parent: stack,
+          usesThis: false,
         };
       } else {
         stack = {
-          member: null,
           class: null,
-          usesThis: false,
+          member: null,
           parent: stack,
+          usesThis: false,
         };
       }
     }
@@ -214,12 +153,12 @@ export default createRule<Options, MessageIds>({
 
       if (isIncludedInstanceMethod(stackContext.member)) {
         context.report({
-          node,
-          loc: getFunctionHeadLoc(node, context.sourceCode),
-          messageId: 'missingThis',
           data: {
             name: getFunctionNameWithKind(node),
           },
+          loc: getFunctionHeadLoc(node, context.sourceCode),
+          messageId: 'missingThis',
+          node,
         });
       }
     }
@@ -284,4 +223,66 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      enforceForClassFields: true,
+      exceptMethods: [],
+      ignoreClassesThatImplementAnInterface: false,
+      ignoreOverrideMethods: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Enforce that class methods utilize `this`',
+      extendsBaseRule: true,
+      requiresTypeChecking: false,
+    },
+    messages: {
+      missingThis: "Expected 'this' to be used by class {{name}}.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          enforceForClassFields: {
+            default: true,
+            description:
+              'Enforces that functions used as instance field initializers utilize `this`',
+            type: 'boolean',
+          },
+          exceptMethods: {
+            description:
+              'Allows specified method names to be ignored with this rule',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          ignoreClassesThatImplementAnInterface: {
+            description:
+              'Ignore classes that specifically implement some interface',
+            oneOf: [
+              {
+                description: 'Ignore all classes that implement an interface',
+                type: 'boolean',
+              },
+              {
+                description:
+                  'Ignore only the public fields of classes that implement an interface',
+                enum: ['public-fields'],
+                type: 'string',
+              },
+            ],
+          },
+          ignoreOverrideMethods: {
+            description: 'Ignore members marked with the `override` modifier',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'class-methods-use-this',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index c4a110c7aa86..06bddbfc6b52 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
@@ -7,29 +8,6 @@ type MessageIds = 'preferConstructor' | 'preferTypeAnnotation';
 type Options = ['constructor' | 'type-annotation'];
 
 export default createRule<Options, MessageIds>({
-  name: 'consistent-generic-constructors',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
-      recommended: 'stylistic',
-    },
-    messages: {
-      preferTypeAnnotation:
-        'The generic type arguments should be specified as part of the type annotation.',
-      preferConstructor:
-        'The generic type arguments should be specified as part of the constructor type arguments.',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'string',
-        enum: ['type-annotation', 'constructor'],
-      },
-    ],
-  },
-  defaultOptions: ['constructor'],
   create(context, [mode]) {
     return {
       'VariableDeclarator,PropertyDefinition,:matches(FunctionDeclaration,FunctionExpression) > AssignmentPattern'(
@@ -75,13 +53,11 @@ export default createRule<Options, MessageIds>({
         }
         if (mode === 'type-annotation') {
           if (!lhs && rhs.typeArguments) {
-            const { typeArguments, callee } = rhs;
+            const { callee, typeArguments } = rhs;
             const typeAnnotation =
               context.sourceCode.getText(callee) +
               context.sourceCode.getText(typeArguments);
             context.report({
-              node,
-              messageId: 'preferTypeAnnotation',
               fix(fixer) {
                 function getIDToAttachAnnotation():
                   | TSESTree.Node
@@ -107,6 +83,8 @@ export default createRule<Options, MessageIds>({
                   ),
                 ];
               },
+              messageId: 'preferTypeAnnotation',
+              node,
             });
           }
           return;
@@ -122,8 +100,6 @@ export default createRule<Options, MessageIds>({
             .getCommentsInside(lhs.typeArguments)
             .forEach(c => extraComments.delete(c));
           context.report({
-            node,
-            messageId: 'preferConstructor',
             *fix(fixer) {
               yield fixer.remove(lhs.parent);
               for (const comment of extraComments) {
@@ -140,9 +116,34 @@ export default createRule<Options, MessageIds>({
                 yield fixer.insertTextAfter(rhs.callee, '()');
               }
             },
+            messageId: 'preferConstructor',
+            node,
           });
         }
       },
     };
   },
+  defaultOptions: ['constructor'],
+  meta: {
+    docs: {
+      description:
+        'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      preferConstructor:
+        'The generic type arguments should be specified as part of the constructor type arguments.',
+      preferTypeAnnotation:
+        'The generic type arguments should be specified as part of the type annotation.',
+    },
+    schema: [
+      {
+        enum: ['type-annotation', 'constructor'],
+        type: 'string',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'consistent-generic-constructors',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index f0f91cc32b8e..88c55a7eec75 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -7,26 +8,6 @@ type MessageIds = 'preferIndexSignature' | 'preferRecord';
 type Options = ['index-signature' | 'record'];
 
 export default createRule<Options, MessageIds>({
-  name: 'consistent-indexed-object-style',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require or disallow the `Record` type',
-      recommended: 'stylistic',
-    },
-    messages: {
-      preferRecord: 'A record is preferred over an index signature.',
-      preferIndexSignature: 'An index signature is preferred over a record.',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'string',
-        enum: ['record', 'index-signature'],
-      },
-    ],
-  },
-  defaultOptions: ['record'],
   create(context, [mode]) {
     function checkMembers(
       members: TSESTree.TypeElement[],
@@ -77,8 +58,6 @@ export default createRule<Options, MessageIds>({
       }
 
       context.report({
-        node,
-        messageId: 'preferRecord',
         fix: safeFix
           ? (fixer): TSESLint.RuleFix => {
               const key = context.sourceCode.getText(keyType.typeAnnotation);
@@ -91,6 +70,8 @@ export default createRule<Options, MessageIds>({
               return fixer.replaceText(node, `${prefix}${record}${postfix}`);
             }
           : null,
+        messageId: 'preferRecord',
+        node,
       });
     }
 
@@ -111,21 +92,17 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node,
-            messageId: 'preferIndexSignature',
             fix(fixer) {
               const key = context.sourceCode.getText(params[0]);
               const type = context.sourceCode.getText(params[1]);
               return fixer.replaceText(node, `{ [key: ${key}]: ${type} }`);
             },
+            messageId: 'preferIndexSignature',
+            node,
           });
         },
       }),
       ...(mode === 'record' && {
-        TSTypeLiteral(node): void {
-          const parent = findParentDeclaration(node);
-          checkMembers(node.members, node, parent?.id, '', '');
-        },
         TSInterfaceDeclaration(node): void {
           let genericTypes = '';
 
@@ -144,9 +121,33 @@ export default createRule<Options, MessageIds>({
             !node.extends.length,
           );
         },
+        TSTypeLiteral(node): void {
+          const parent = findParentDeclaration(node);
+          checkMembers(node.members, node, parent?.id, '', '');
+        },
       }),
     };
   },
+  defaultOptions: ['record'],
+  meta: {
+    docs: {
+      description: 'Require or disallow the `Record` type',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      preferIndexSignature: 'An index signature is preferred over a record.',
+      preferRecord: 'A record is preferred over an index signature.',
+    },
+    schema: [
+      {
+        enum: ['record', 'index-signature'],
+        type: 'string',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'consistent-indexed-object-style',
 });
 
 function findParentDeclaration(
diff --git a/packages/eslint-plugin/src/rules/consistent-return.ts b/packages/eslint-plugin/src/rules/consistent-return.ts
index 5d4cc3fb9256..2b62e7372e5a 100644
--- a/packages/eslint-plugin/src/rules/consistent-return.ts
+++ b/packages/eslint-plugin/src/rules/consistent-return.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -6,6 +7,7 @@ import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule, getParserServices, isTypeFlagSet } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -15,25 +17,11 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 type FunctionNode =
+  | TSESTree.ArrowFunctionExpression
   | TSESTree.FunctionDeclaration
-  | TSESTree.FunctionExpression
-  | TSESTree.ArrowFunctionExpression;
+  | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
-  name: 'consistent-return',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require `return` statements to either always or never specify values',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -86,6 +74,11 @@ export default createRule<Options, MessageIds>({
 
     return {
       ...rules,
+      ArrowFunctionExpression: enterFunction,
+      'ArrowFunctionExpression:exit'(node): void {
+        exitFunction();
+        rules['ArrowFunctionExpression:exit'](node);
+      },
       FunctionDeclaration: enterFunction,
       'FunctionDeclaration:exit'(node): void {
         exitFunction();
@@ -96,11 +89,6 @@ export default createRule<Options, MessageIds>({
         exitFunction();
         rules['FunctionExpression:exit'](node);
       },
-      ArrowFunctionExpression: enterFunction,
-      'ArrowFunctionExpression:exit'(node): void {
-        exitFunction();
-        rules['ArrowFunctionExpression:exit'](node);
-      },
       ReturnStatement(node): void {
         const functionNode = getCurrentFunction();
         if (
@@ -125,4 +113,18 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
+  meta: {
+    docs: {
+      description:
+        'Require `return` statements to either always or never specify values',
+      extendsBaseRule: true,
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'suggestion',
+  },
+  name: 'consistent-return',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index 4c45d12e5a74..ed7e641381e5 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -23,7 +24,7 @@ export type MessageIds =
 type OptUnion =
   | {
       assertionStyle: 'angle-bracket' | 'as';
-      objectLiteralTypeAssertions?: 'allow-as-parameter' | 'allow' | 'never';
+      objectLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never';
     }
   | {
       assertionStyle: 'never';
@@ -31,64 +32,6 @@ type OptUnion =
 export type Options = readonly [OptUnion];
 
 export default createRule<Options, MessageIds>({
-  name: 'consistent-type-assertions',
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    hasSuggestions: true,
-    docs: {
-      description: 'Enforce consistent usage of type assertions',
-      recommended: 'stylistic',
-    },
-    messages: {
-      as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
-      'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
-      never: 'Do not use any type assertions.',
-      unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
-      replaceObjectTypeAssertionWithAnnotation:
-        'Use const x: {{cast}} = { ... } instead.',
-      replaceObjectTypeAssertionWithSatisfies:
-        'Use const x = { ... } satisfies {{cast}} instead.',
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            type: 'object',
-            properties: {
-              assertionStyle: {
-                type: 'string',
-                enum: ['never'],
-              },
-            },
-            additionalProperties: false,
-            required: ['assertionStyle'],
-          },
-          {
-            type: 'object',
-            properties: {
-              assertionStyle: {
-                type: 'string',
-                enum: ['as', 'angle-bracket'],
-              },
-              objectLiteralTypeAssertions: {
-                type: 'string',
-                enum: ['allow', 'allow-as-parameter', 'never'],
-              },
-            },
-            additionalProperties: false,
-            required: ['assertionStyle'],
-          },
-        ],
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      assertionStyle: 'as',
-      objectLiteralTypeAssertions: 'allow',
-    },
-  ],
   create(context, [options]) {
     const parserServices = getParserServices(context, true);
 
@@ -113,8 +56,6 @@ export default createRule<Options, MessageIds>({
         return;
       }
       context.report({
-        node,
-        messageId,
         data:
           messageId !== 'never'
             ? { cast: context.sourceCode.getText(node.typeAnnotation) }
@@ -167,6 +108,8 @@ export default createRule<Options, MessageIds>({
                 );
               }
             : undefined,
+        messageId,
+        node,
       });
     }
 
@@ -221,7 +164,6 @@ export default createRule<Options, MessageIds>({
         ) {
           const { parent } = node;
           suggest.push({
-            messageId: 'replaceObjectTypeAssertionWithAnnotation',
             data: { cast: context.sourceCode.getText(node.typeAnnotation) },
             fix: fixer => [
               fixer.insertTextAfter(
@@ -233,10 +175,10 @@ export default createRule<Options, MessageIds>({
                 getTextWithParentheses(context.sourceCode, node.expression),
               ),
             ],
+            messageId: 'replaceObjectTypeAssertionWithAnnotation',
           });
         }
         suggest.push({
-          messageId: 'replaceObjectTypeAssertionWithSatisfies',
           data: { cast: context.sourceCode.getText(node.typeAnnotation) },
           fix: fixer => [
             fixer.replaceText(
@@ -248,27 +190,28 @@ export default createRule<Options, MessageIds>({
               ` satisfies ${context.sourceCode.getText(node.typeAnnotation)}`,
             ),
           ],
+          messageId: 'replaceObjectTypeAssertionWithSatisfies',
         });
 
         context.report({
-          node,
           messageId: 'unexpectedObjectTypeAssertion',
+          node,
           suggest,
         });
       }
     }
 
     return {
-      TSTypeAssertion(node): void {
-        if (options.assertionStyle !== 'angle-bracket') {
+      TSAsExpression(node): void {
+        if (options.assertionStyle !== 'as') {
           reportIncorrectAssertionType(node);
           return;
         }
 
         checkExpression(node);
       },
-      TSAsExpression(node): void {
-        if (options.assertionStyle !== 'as') {
+      TSTypeAssertion(node): void {
+        if (options.assertionStyle !== 'angle-bracket') {
           reportIncorrectAssertionType(node);
           return;
         }
@@ -277,4 +220,62 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      assertionStyle: 'as',
+      objectLiteralTypeAssertions: 'allow',
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Enforce consistent usage of type assertions',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
+      as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
+      never: 'Do not use any type assertions.',
+      replaceObjectTypeAssertionWithAnnotation:
+        'Use const x: {{cast}} = { ... } instead.',
+      replaceObjectTypeAssertionWithSatisfies:
+        'Use const x = { ... } satisfies {{cast}} instead.',
+      unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            additionalProperties: false,
+            properties: {
+              assertionStyle: {
+                enum: ['never'],
+                type: 'string',
+              },
+            },
+            required: ['assertionStyle'],
+            type: 'object',
+          },
+          {
+            additionalProperties: false,
+            properties: {
+              assertionStyle: {
+                enum: ['as', 'angle-bracket'],
+                type: 'string',
+              },
+              objectLiteralTypeAssertions: {
+                enum: ['allow', 'allow-as-parameter', 'never'],
+                type: 'string',
+              },
+            },
+            required: ['assertionStyle'],
+            type: 'object',
+          },
+        ],
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'consistent-type-assertions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 45b156fdf0ee..3cc36be45170 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -1,30 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'consistent-type-definitions',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce type definitions to consistently use either `interface` or `type`',
-      recommended: 'stylistic',
-    },
-    messages: {
-      interfaceOverType: 'Use an `interface` instead of a `type`.',
-      typeOverInterface: 'Use a `type` instead of an `interface`.',
-    },
-    schema: [
-      {
-        type: 'string',
-        enum: ['interface', 'type'],
-      },
-    ],
-    fixable: 'code',
-  },
-  defaultOptions: ['interface'],
   create(context, [option]) {
     /**
      * Iterates from the highest parent to the currently traversed node
@@ -49,8 +29,6 @@ export default createRule({
           node: TSESTree.TSTypeAliasDeclaration,
         ): void {
           context.report({
-            node: node.id,
-            messageId: 'interfaceOverType',
             fix(fixer) {
               const typeNode = node.typeParameters ?? node.id;
               const fixes: TSESLint.RuleFix[] = [];
@@ -79,6 +57,8 @@ export default createRule({
 
               return fixes;
             },
+            messageId: 'interfaceOverType',
+            node: node.id,
           });
         },
       }),
@@ -123,8 +103,8 @@ export default createRule({
                 return fixes;
               };
           context.report({
-            node: node.id,
             messageId: 'typeOverInterface',
+            node: node.id,
             /**
              * remove automatically fix when the interface is within a declare global
              * @see {@link https://github.com/typescript-eslint/typescript-eslint/issues/2707}
@@ -135,4 +115,25 @@ export default createRule({
       }),
     };
   },
+  defaultOptions: ['interface'],
+  meta: {
+    docs: {
+      description:
+        'Enforce type definitions to consistently use either `interface` or `type`',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      interfaceOverType: 'Use an `interface` instead of a `type`.',
+      typeOverInterface: 'Use a `type` instead of an `interface`.',
+    },
+    schema: [
+      {
+        enum: ['interface', 'type'],
+        type: 'string',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'consistent-type-definitions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index 236659d13adb..f64d82053648 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { SymbolFlags } from 'typescript';
 
@@ -19,17 +20,17 @@ type Options = [
 ];
 
 interface SourceExports {
-  source: string;
   reportValueExports: ReportValueExport[];
+  source: string;
   typeOnlyNamedExport: TSESTree.ExportNamedDeclaration | null;
   valueOnlyNamedExport: TSESTree.ExportNamedDeclaration | null;
 }
 
 interface ReportValueExport {
+  inlineTypeSpecifiers: TSESTree.ExportSpecifier[];
   node: TSESTree.ExportNamedDeclaration;
   typeBasedSpecifiers: TSESTree.ExportSpecifier[];
   valueSpecifiers: TSESTree.ExportSpecifier[];
-  inlineTypeSpecifiers: TSESTree.ExportSpecifier[];
 }
 
 type MessageIds =
@@ -38,41 +39,6 @@ type MessageIds =
   | 'typeOverValue';
 
 export default createRule<Options, MessageIds>({
-  name: 'consistent-type-exports',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce consistent usage of type exports',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      typeOverValue:
-        'All exports in the declaration are only used as types. Use `export type`.',
-
-      singleExportIsType:
-        'Type export {{exportNames}} is not a value and should be exported using `export type`.',
-      multipleExportsAreTypes:
-        'Type exports {{exportNames}} are not values and should be exported using `export type`.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          fixMixedExportsWithInlineTypeSpecifier: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    fixable: 'code',
-  },
-  defaultOptions: [
-    {
-      fixMixedExportsWithInlineTypeSpecifier: false,
-    },
-  ],
-
   create(context, [{ fixMixedExportsWithInlineTypeSpecifier }]) {
     const sourceExportsMap: Record<string, SourceExports> = {};
     const services = getParserServices(context);
@@ -109,8 +75,8 @@ export default createRule<Options, MessageIds>({
         const source = getSourceFromExport(node) ?? 'undefined';
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         const sourceExports = (sourceExportsMap[source] ||= {
-          source,
           reportValueExports: [],
+          source,
           typeOnlyNamedExport: null,
           valueOnlyNamedExport: null,
         });
@@ -157,10 +123,10 @@ export default createRule<Options, MessageIds>({
           (node.exportKind === 'type' && valueSpecifiers.length)
         ) {
           sourceExports.reportValueExports.push({
+            inlineTypeSpecifiers,
             node,
             typeBasedSpecifiers,
             valueSpecifiers,
-            inlineTypeSpecifiers,
           });
         }
       },
@@ -176,8 +142,6 @@ export default createRule<Options, MessageIds>({
             if (report.valueSpecifiers.length === 0) {
               // Export is all type-only with no type specifiers; convert the entire export to `export type`.
               context.report({
-                node: report.node,
-                messageId: 'typeOverValue',
                 *fix(fixer) {
                   yield* fixExportInsertType(
                     fixer,
@@ -185,6 +149,8 @@ export default createRule<Options, MessageIds>({
                     report.node,
                   );
                 },
+                messageId: 'typeOverValue',
+                node: report.node,
               });
               continue;
             }
@@ -198,8 +164,6 @@ export default createRule<Options, MessageIds>({
               const exportNames = allExportNames[0];
 
               context.report({
-                node: report.node,
-                messageId: 'singleExportIsType',
                 data: { exportNames },
                 *fix(fixer) {
                   if (fixMixedExportsWithInlineTypeSpecifier) {
@@ -212,13 +176,13 @@ export default createRule<Options, MessageIds>({
                     );
                   }
                 },
+                messageId: 'singleExportIsType',
+                node: report.node,
               });
             } else {
               const exportNames = formatWordList(allExportNames);
 
               context.report({
-                node: report.node,
-                messageId: 'multipleExportsAreTypes',
                 data: { exportNames },
                 *fix(fixer) {
                   if (fixMixedExportsWithInlineTypeSpecifier) {
@@ -231,6 +195,8 @@ export default createRule<Options, MessageIds>({
                     );
                   }
                 },
+                messageId: 'multipleExportsAreTypes',
+                node: report.node,
               });
             }
           }
@@ -238,6 +204,41 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      fixMixedExportsWithInlineTypeSpecifier: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Enforce consistent usage of type exports',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      multipleExportsAreTypes:
+        'Type exports {{exportNames}} are not values and should be exported using `export type`.',
+
+      singleExportIsType:
+        'Type export {{exportNames}} is not a value and should be exported using `export type`.',
+      typeOverValue:
+        'All exports in the declaration are only used as types. Use `export type`.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          fixMixedExportsWithInlineTypeSpecifier: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'consistent-type-exports',
 });
 
 /**
@@ -288,7 +289,7 @@ function* fixSeparateNamedExports(
   sourceCode: Readonly<TSESLint.SourceCode>,
   report: ReportValueExport,
 ): IterableIterator<TSESLint.RuleFix> {
-  const { node, typeBasedSpecifiers, inlineTypeSpecifiers, valueSpecifiers } =
+  const { inlineTypeSpecifiers, node, typeBasedSpecifiers, valueSpecifiers } =
     report;
   const typeSpecifiers = typeBasedSpecifiers.concat(inlineTypeSpecifiers);
   const source = getSourceFromExport(node);
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index b0428aa71645..a46548d36adf 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -1,7 +1,8 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { RuleListener } from '@typescript-eslint/utils/eslint-utils';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import {
   createRule,
   formatWordList,
@@ -20,80 +21,36 @@ type FixStyle = 'inline-type-imports' | 'separate-type-imports';
 
 type Options = [
   {
-    prefer?: Prefer;
     disallowTypeAnnotations?: boolean;
     fixStyle?: FixStyle;
+    prefer?: Prefer;
   },
 ];
 
 interface SourceImports {
-  source: string;
   reportValueImports: ReportValueImport[];
+  source: string;
   // ImportDeclaration for type-only import only with named imports.
   typeOnlyNamedImport: TSESTree.ImportDeclaration | null;
-  // ImportDeclaration for value-only import only with named imports.
-  valueOnlyNamedImport: TSESTree.ImportDeclaration | null;
   // ImportDeclaration for value-only import only with default imports and/or named imports.
   valueImport: TSESTree.ImportDeclaration | null;
+  // ImportDeclaration for value-only import only with named imports.
+  valueOnlyNamedImport: TSESTree.ImportDeclaration | null;
 }
 interface ReportValueImport {
+  inlineTypeSpecifiers: TSESTree.ImportSpecifier[];
   node: TSESTree.ImportDeclaration;
   typeSpecifiers: TSESTree.ImportClause[]; // It has at least one element.
-  valueSpecifiers: TSESTree.ImportClause[];
   unusedSpecifiers: TSESTree.ImportClause[];
-  inlineTypeSpecifiers: TSESTree.ImportSpecifier[];
+  valueSpecifiers: TSESTree.ImportClause[];
 }
 
 type MessageIds =
-  | 'typeOverValue'
-  | 'someImportsAreOnlyTypes'
   | 'avoidImportType'
-  | 'noImportTypeAnnotations';
+  | 'noImportTypeAnnotations'
+  | 'someImportsAreOnlyTypes'
+  | 'typeOverValue';
 export default createRule<Options, MessageIds>({
-  name: 'consistent-type-imports',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce consistent usage of type imports',
-    },
-    messages: {
-      typeOverValue:
-        'All imports in the declaration are only used as types. Use `import type`.',
-      someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as type.',
-
-      avoidImportType: 'Use an `import` instead of an `import type`.',
-      noImportTypeAnnotations: '`import()` type annotations are forbidden.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          disallowTypeAnnotations: {
-            type: 'boolean',
-          },
-          fixStyle: {
-            type: 'string',
-            enum: ['separate-type-imports', 'inline-type-imports'],
-          },
-          prefer: {
-            type: 'string',
-            enum: ['type-imports', 'no-type-imports'],
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    fixable: 'code',
-  },
-
-  defaultOptions: [
-    {
-      prefer: 'type-imports',
-      disallowTypeAnnotations: true,
-      fixStyle: 'separate-type-imports',
-    },
-  ],
-
   create(context, [option]) {
     const prefer = option.prefer ?? 'type-imports';
     const disallowTypeAnnotations = option.disallowTypeAnnotations !== false;
@@ -103,8 +60,8 @@ export default createRule<Options, MessageIds>({
     if (disallowTypeAnnotations) {
       selectors.TSImportType = (node): void => {
         context.report({
-          node,
           messageId: 'noImportTypeAnnotations',
+          node,
         });
       };
     }
@@ -116,22 +73,22 @@ export default createRule<Options, MessageIds>({
           node: TSESTree.ImportDeclaration,
         ): void {
           context.report({
-            node,
-            messageId: 'avoidImportType',
             fix(fixer) {
               return fixRemoveTypeSpecifierFromImportDeclaration(fixer, node);
             },
+            messageId: 'avoidImportType',
+            node,
           });
         },
         'ImportSpecifier[importKind = "type"]'(
           node: TSESTree.ImportSpecifier,
         ): void {
           context.report({
-            node,
-            messageId: 'avoidImportType',
             fix(fixer) {
               return fixRemoveTypeSpecifierFromImportSpecifier(fixer, node);
             },
+            messageId: 'avoidImportType',
+            node,
           });
         },
       };
@@ -160,11 +117,11 @@ export default createRule<Options, MessageIds>({
         const source = node.source.value;
         // sourceImports is the object containing all the specifics for a particular import source, type or value
         sourceImportsMap[source] ??= {
-          source,
           reportValueImports: [], // if there is a mismatch where type importKind but value specifiers
+          source,
           typeOnlyNamedImport: null, // if only type imports
-          valueOnlyNamedImport: null, // if only value imports with named specifiers
           valueImport: null, // if only value imports
+          valueOnlyNamedImport: null, // if only value imports with named specifiers
         };
         const sourceImports = sourceImportsMap[source];
         if (node.importKind === 'type') {
@@ -287,11 +244,11 @@ export default createRule<Options, MessageIds>({
 
         if (node.importKind === 'value' && typeSpecifiers.length) {
           sourceImports.reportValueImports.push({
+            inlineTypeSpecifiers,
             node,
             typeSpecifiers,
-            valueSpecifiers,
             unusedSpecifiers,
-            inlineTypeSpecifiers,
+            valueSpecifiers,
           });
         }
       },
@@ -355,8 +312,6 @@ export default createRule<Options, MessageIds>({
                */
               if (report.node.attributes.length === 0) {
                 context.report({
-                  node: report.node,
-                  messageId: 'typeOverValue',
                   *fix(fixer) {
                     yield* fixToTypeImportDeclaration(
                       fixer,
@@ -364,6 +319,8 @@ export default createRule<Options, MessageIds>({
                       sourceImports,
                     );
                   },
+                  messageId: 'typeOverValue',
+                  node: report.node,
                 });
               }
             } else {
@@ -373,24 +330,24 @@ export default createRule<Options, MessageIds>({
               );
 
               const message = ((): {
-                messageId: MessageIds;
                 data: Record<string, unknown>;
+                messageId: MessageIds;
               } => {
                 const typeImports = formatWordList(importNames);
 
                 if (importNames.length === 1) {
                   return {
-                    messageId: 'someImportsAreOnlyTypes',
                     data: {
                       typeImports,
                     },
+                    messageId: 'someImportsAreOnlyTypes',
                   };
                 }
                 return {
-                  messageId: 'someImportsAreOnlyTypes',
                   data: {
                     typeImports,
                   },
+                  messageId: 'someImportsAreOnlyTypes',
                 };
               })();
 
@@ -414,8 +371,8 @@ export default createRule<Options, MessageIds>({
 
     function classifySpecifier(node: TSESTree.ImportDeclaration): {
       defaultSpecifier: TSESTree.ImportDefaultSpecifier | null;
-      namespaceSpecifier: TSESTree.ImportNamespaceSpecifier | null;
       namedSpecifiers: TSESTree.ImportSpecifier[];
+      namespaceSpecifier: TSESTree.ImportNamespaceSpecifier | null;
     } {
       const defaultSpecifier =
         node.specifiers[0].type === AST_NODE_TYPES.ImportDefaultSpecifier
@@ -432,8 +389,8 @@ export default createRule<Options, MessageIds>({
       );
       return {
         defaultSpecifier,
-        namespaceSpecifier,
         namedSpecifiers,
+        namespaceSpecifier,
       };
     }
 
@@ -446,13 +403,13 @@ export default createRule<Options, MessageIds>({
       subsetNamedSpecifiers: TSESTree.ImportSpecifier[],
       allNamedSpecifiers: TSESTree.ImportSpecifier[],
     ): {
-      typeNamedSpecifiersText: string;
       removeTypeNamedSpecifiers: TSESLint.RuleFix[];
+      typeNamedSpecifiersText: string;
     } {
       if (allNamedSpecifiers.length === 0) {
         return {
-          typeNamedSpecifiersText: '',
           removeTypeNamedSpecifiers: [],
+          typeNamedSpecifiersText: '',
         };
       }
       const typeNamedSpecifiersTexts: string[] = [];
@@ -519,8 +476,8 @@ export default createRule<Options, MessageIds>({
         }
       }
       return {
-        typeNamedSpecifiersText: typeNamedSpecifiersTexts.join(','),
         removeTypeNamedSpecifiers,
+        typeNamedSpecifiersText: typeNamedSpecifiersTexts.join(','),
       };
     }
 
@@ -531,8 +488,8 @@ export default createRule<Options, MessageIds>({
       namedSpecifierGroup: TSESTree.ImportSpecifier[],
       allNamedSpecifiers: TSESTree.ImportSpecifier[],
     ): {
-      textRange: TSESTree.Range;
       removeRange: TSESTree.Range;
+      textRange: TSESTree.Range;
     } {
       const first = namedSpecifierGroup[0];
       const last = namedSpecifierGroup[namedSpecifierGroup.length - 1];
@@ -563,8 +520,8 @@ export default createRule<Options, MessageIds>({
       }
 
       return {
-        textRange,
         removeRange,
+        textRange,
       };
     }
 
@@ -653,7 +610,7 @@ export default createRule<Options, MessageIds>({
     ): IterableIterator<TSESLint.RuleFix> {
       const { node } = report;
 
-      const { defaultSpecifier, namespaceSpecifier, namedSpecifiers } =
+      const { defaultSpecifier, namedSpecifiers, namespaceSpecifier } =
         classifySpecifier(node);
 
       if (namespaceSpecifier && !defaultSpecifier) {
@@ -943,4 +900,48 @@ export default createRule<Options, MessageIds>({
       yield fixer.removeRange([typeToken.range[0], afterToken.range[0]]);
     }
   },
+  defaultOptions: [
+    {
+      disallowTypeAnnotations: true,
+      fixStyle: 'separate-type-imports',
+      prefer: 'type-imports',
+    },
+  ],
+
+  meta: {
+    docs: {
+      description: 'Enforce consistent usage of type imports',
+    },
+    fixable: 'code',
+    messages: {
+      avoidImportType: 'Use an `import` instead of an `import type`.',
+      noImportTypeAnnotations: '`import()` type annotations are forbidden.',
+
+      someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as type.',
+      typeOverValue:
+        'All imports in the declaration are only used as types. Use `import type`.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          disallowTypeAnnotations: {
+            type: 'boolean',
+          },
+          fixStyle: {
+            enum: ['separate-type-imports', 'inline-type-imports'],
+            type: 'string',
+          },
+          prefer: {
+            enum: ['type-imports', 'no-type-imports'],
+            type: 'string',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'consistent-type-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index 1340ecfa17b1..acccc135874d 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -1,22 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'default-param-last',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce default parameters to be last',
-      extendsBaseRule: true,
-    },
-    schema: [],
-    messages: {
-      shouldBeLast: 'Default parameters should be last.',
-    },
-  },
-  defaultOptions: [],
   create(context) {
     /**
      * checks if node is optional parameter
@@ -71,7 +59,7 @@ export default createRule({
           (isOptionalParam(param) ||
             param.type === AST_NODE_TYPES.AssignmentPattern)
         ) {
-          context.report({ node: current, messageId: 'shouldBeLast' });
+          context.report({ messageId: 'shouldBeLast', node: current });
         }
       }
     }
@@ -82,4 +70,17 @@ export default createRule({
       FunctionExpression: checkDefaultParamLast,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Enforce default parameters to be last',
+      extendsBaseRule: true,
+    },
+    messages: {
+      shouldBeLast: 'Default parameters should be last.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'default-param-last',
 });
diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
index 06b1c78c29d9..d9efb21a0336 100644
--- a/packages/eslint-plugin/src/rules/dot-notation.ts
+++ b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -7,6 +8,7 @@ import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule, getModifiers, getParserServices } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -16,56 +18,6 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'dot-notation',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce dot notation whenever possible',
-      recommended: 'stylistic',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowKeywords: {
-            type: 'boolean',
-            default: true,
-          },
-          allowPattern: {
-            type: 'string',
-            default: '',
-          },
-          allowPrivateClassPropertyAccess: {
-            type: 'boolean',
-            default: false,
-          },
-          allowProtectedClassPropertyAccess: {
-            type: 'boolean',
-            default: false,
-          },
-          allowIndexSignaturePropertyAccess: {
-            type: 'boolean',
-            default: false,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    fixable: baseRule.meta.fixable,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [
-    {
-      allowPrivateClassPropertyAccess: false,
-      allowProtectedClassPropertyAccess: false,
-      allowIndexSignaturePropertyAccess: false,
-      allowKeywords: true,
-      allowPattern: '',
-    },
-  ],
   create(context, [options]) {
     const rules = baseRule.create(context);
     const services = getParserServices(context);
@@ -129,4 +81,54 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowIndexSignaturePropertyAccess: false,
+      allowKeywords: true,
+      allowPattern: '',
+      allowPrivateClassPropertyAccess: false,
+      allowProtectedClassPropertyAccess: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Enforce dot notation whenever possible',
+      extendsBaseRule: true,
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: baseRule.meta.fixable,
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowIndexSignaturePropertyAccess: {
+            default: false,
+            type: 'boolean',
+          },
+          allowKeywords: {
+            default: true,
+            type: 'boolean',
+          },
+          allowPattern: {
+            default: '',
+            type: 'string',
+          },
+          allowPrivateClassPropertyAccess: {
+            default: false,
+            type: 'boolean',
+          },
+          allowProtectedClassPropertyAccess: {
+            default: false,
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'dot-notation',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index 9904dc2e5336..b8264cdec926 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -1,8 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-import { createRule, nullThrows } from '../util';
 import type { FunctionInfo } from '../util/explicitReturnTypeUtils';
+
+import { createRule, nullThrows } from '../util';
 import {
   ancestorHasReturnType,
   checkFunctionReturnType,
@@ -11,14 +13,14 @@ import {
 
 type Options = [
   {
-    allowExpressions?: boolean;
-    allowTypedFunctionExpressions?: boolean;
-    allowHigherOrderFunctions?: boolean;
-    allowDirectConstAssertionInArrowFunctions?: boolean;
     allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean;
-    allowFunctionsWithoutTypeParameters?: boolean;
+    allowDirectConstAssertionInArrowFunctions?: boolean;
     allowedNames?: string[];
+    allowExpressions?: boolean;
+    allowFunctionsWithoutTypeParameters?: boolean;
+    allowHigherOrderFunctions?: boolean;
     allowIIFEs?: boolean;
+    allowTypedFunctionExpressions?: boolean;
   },
 ];
 type MessageIds = 'missingReturnType';
@@ -29,80 +31,6 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
-  name: 'explicit-function-return-type',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Require explicit return types on functions and class methods',
-    },
-    messages: {
-      missingReturnType: 'Missing return type on function.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowConciseArrowFunctionExpressionsStartingWithVoid: {
-            description:
-              'Whether to allow arrow functions that start with the `void` keyword.',
-            type: 'boolean',
-          },
-          allowExpressions: {
-            description:
-              'Whether to ignore function expressions (functions which are not part of a declaration).',
-            type: 'boolean',
-          },
-          allowHigherOrderFunctions: {
-            description:
-              'Whether to ignore functions immediately returning another function expression.',
-            type: 'boolean',
-          },
-          allowTypedFunctionExpressions: {
-            description:
-              'Whether to ignore type annotations on the variable of function expressions.',
-            type: 'boolean',
-          },
-          allowDirectConstAssertionInArrowFunctions: {
-            description:
-              'Whether to ignore arrow functions immediately returning a `as const` value.',
-            type: 'boolean',
-          },
-          allowFunctionsWithoutTypeParameters: {
-            description:
-              "Whether to ignore functions that don't have generic type parameters.",
-            type: 'boolean',
-          },
-          allowedNames: {
-            description:
-              'An array of function/method names that will not have their arguments or return values checked.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          allowIIFEs: {
-            description:
-              'Whether to ignore immediately invoked function expressions (IIFEs).',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowExpressions: false,
-      allowTypedFunctionExpressions: true,
-      allowHigherOrderFunctions: true,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
-      allowFunctionsWithoutTypeParameters: false,
-      allowedNames: [],
-      allowIIFEs: false,
-    },
-  ],
   create(context, [options]) {
     const functionInfoStack: FunctionInfo<FunctionNode>[] = [];
 
@@ -219,9 +147,9 @@ export default createRule<Options, MessageIds>({
 
       checkFunctionReturnType(info, options, context.sourceCode, loc =>
         context.report({
-          node,
           loc,
           messageId: 'missingReturnType',
+          node,
         }),
       );
     }
@@ -230,7 +158,6 @@ export default createRule<Options, MessageIds>({
       'ArrowFunctionExpression, FunctionExpression, FunctionDeclaration':
         enterFunction,
       'ArrowFunctionExpression:exit': exitFunctionExpression,
-      'FunctionExpression:exit': exitFunctionExpression,
       'FunctionDeclaration:exit'(node): void {
         const info = popFunctionInfo('function declaration');
         if (isAllowedFunction(node)) {
@@ -242,15 +169,90 @@ export default createRule<Options, MessageIds>({
 
         checkFunctionReturnType(info, options, context.sourceCode, loc =>
           context.report({
-            node,
             loc,
             messageId: 'missingReturnType',
+            node,
           }),
         );
       },
+      'FunctionExpression:exit': exitFunctionExpression,
       ReturnStatement(node): void {
         functionInfoStack.at(-1)?.returns.push(node);
       },
     };
   },
+  defaultOptions: [
+    {
+      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowExpressions: false,
+      allowFunctionsWithoutTypeParameters: false,
+      allowHigherOrderFunctions: true,
+      allowIIFEs: false,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require explicit return types on functions and class methods',
+    },
+    messages: {
+      missingReturnType: 'Missing return type on function.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowConciseArrowFunctionExpressionsStartingWithVoid: {
+            description:
+              'Whether to allow arrow functions that start with the `void` keyword.',
+            type: 'boolean',
+          },
+          allowDirectConstAssertionInArrowFunctions: {
+            description:
+              'Whether to ignore arrow functions immediately returning a `as const` value.',
+            type: 'boolean',
+          },
+          allowedNames: {
+            description:
+              'An array of function/method names that will not have their arguments or return values checked.',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          allowExpressions: {
+            description:
+              'Whether to ignore function expressions (functions which are not part of a declaration).',
+            type: 'boolean',
+          },
+          allowFunctionsWithoutTypeParameters: {
+            description:
+              "Whether to ignore functions that don't have generic type parameters.",
+            type: 'boolean',
+          },
+          allowHigherOrderFunctions: {
+            description:
+              'Whether to ignore functions immediately returning another function expression.',
+            type: 'boolean',
+          },
+          allowIIFEs: {
+            description:
+              'Whether to ignore immediately invoked function expressions (IIFEs).',
+            type: 'boolean',
+          },
+          allowTypedFunctionExpressions: {
+            description:
+              'Whether to ignore type annotations on the variable of function expressions.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'explicit-function-return-type',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 5947d292f8bd..1f180ff4c5d8 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -24,8 +25,8 @@ interface Config {
     accessors?: AccessibilityLevel;
     constructors?: AccessibilityLevel;
     methods?: AccessibilityLevel;
-    properties?: AccessibilityLevel;
     parameterProperties?: AccessibilityLevel;
+    properties?: AccessibilityLevel;
   };
 }
 
@@ -37,75 +38,6 @@ type MessageIds =
   | 'unwantedPublicAccessibility';
 
 export default createRule<Options, MessageIds>({
-  name: 'explicit-member-accessibility',
-  meta: {
-    hasSuggestions: true,
-    type: 'problem',
-    docs: {
-      description:
-        'Require explicit accessibility modifiers on class properties and methods',
-      // too opinionated to be recommended
-    },
-    fixable: 'code',
-    messages: {
-      missingAccessibility:
-        'Missing accessibility modifier on {{type}} {{name}}.',
-      unwantedPublicAccessibility:
-        'Public accessibility modifier on {{type}} {{name}}.',
-      addExplicitAccessibility: "Add '{{ type }}' accessibility modifier",
-    },
-    schema: [
-      {
-        $defs: {
-          accessibilityLevel: {
-            oneOf: [
-              {
-                type: 'string',
-                enum: ['explicit'],
-                description: 'Always require an accessor.',
-              },
-              {
-                type: 'string',
-                enum: ['no-public'],
-                description: 'Require an accessor except when public.',
-              },
-              {
-                type: 'string',
-                enum: ['off'],
-                description: 'Never check whether there is an accessor.',
-              },
-            ],
-          },
-        },
-        type: 'object',
-        properties: {
-          accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
-          overrides: {
-            type: 'object',
-            properties: {
-              accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              parameterProperties: {
-                $ref: '#/items/0/$defs/accessibilityLevel',
-              },
-            },
-
-            additionalProperties: false,
-          },
-          ignoredMethodNames: {
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [{ accessibility: 'explicit' }],
   create(context, [option]) {
     const baseCheck: AccessibilityLevel = option.accessibility ?? 'explicit';
     const overrides = option.overrides ?? {};
@@ -160,22 +92,22 @@ export default createRule<Options, MessageIds>({
       ) {
         const publicKeyword = findPublicKeyword(methodDefinition);
         context.report({
-          loc: rangeToLoc(context.sourceCode, publicKeyword.range),
-          messageId: 'unwantedPublicAccessibility',
           data: {
-            type: nodeType,
             name: methodName,
+            type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
+          loc: rangeToLoc(context.sourceCode, publicKeyword.range),
+          messageId: 'unwantedPublicAccessibility',
         });
       } else if (check === 'explicit' && !methodDefinition.accessibility) {
         context.report({
-          loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
-          messageId: 'missingAccessibility',
           data: {
-            type: nodeType,
             name: methodName,
+            type: nodeType,
           },
+          loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
+          messageId: 'missingAccessibility',
           suggest: getMissingAccessibilitySuggestions(methodDefinition),
         });
       }
@@ -253,19 +185,19 @@ export default createRule<Options, MessageIds>({
 
       return [
         {
-          messageId: 'addExplicitAccessibility',
           data: { type: 'public' },
           fix: fixer => fix('public', fixer),
+          messageId: 'addExplicitAccessibility',
         },
         {
-          messageId: 'addExplicitAccessibility',
           data: { type: 'private' },
           fix: fixer => fix('private', fixer),
+          messageId: 'addExplicitAccessibility',
         },
         {
-          messageId: 'addExplicitAccessibility',
           data: { type: 'protected' },
           fix: fixer => fix('protected', fixer),
+          messageId: 'addExplicitAccessibility',
         },
       ];
     }
@@ -295,25 +227,25 @@ export default createRule<Options, MessageIds>({
       ) {
         const publicKeywordRange = findPublicKeyword(propertyDefinition);
         context.report({
-          loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
-          messageId: 'unwantedPublicAccessibility',
           data: {
-            type: nodeType,
             name: propertyName,
+            type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeywordRange.rangeToRemove),
+          loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
+          messageId: 'unwantedPublicAccessibility',
         });
       } else if (
         propCheck === 'explicit' &&
         !propertyDefinition.accessibility
       ) {
         context.report({
-          loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
-          messageId: 'missingAccessibility',
           data: {
-            type: nodeType,
             name: propertyName,
+            type: nodeType,
           },
+          loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
+          messageId: 'missingAccessibility',
           suggest: getMissingAccessibilitySuggestions(propertyDefinition),
         });
       }
@@ -345,16 +277,16 @@ export default createRule<Options, MessageIds>({
         case 'explicit': {
           if (!node.accessibility) {
             context.report({
+              data: {
+                name: nodeName,
+                type: nodeType,
+              },
               loc: getParameterPropertyHeadLoc(
                 context.sourceCode,
                 node,
                 nodeName,
               ),
               messageId: 'missingAccessibility',
-              data: {
-                type: nodeType,
-                name: nodeName,
-              },
               suggest: getMissingAccessibilitySuggestions(node),
             });
           }
@@ -364,13 +296,13 @@ export default createRule<Options, MessageIds>({
           if (node.accessibility === 'public' && node.readonly) {
             const publicKeyword = findPublicKeyword(node);
             context.report({
-              loc: rangeToLoc(context.sourceCode, publicKeyword.range),
-              messageId: 'unwantedPublicAccessibility',
               data: {
-                type: nodeType,
                 name: nodeName,
+                type: nodeType,
               },
               fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
+              loc: rangeToLoc(context.sourceCode, publicKeyword.range),
+              messageId: 'unwantedPublicAccessibility',
             });
           }
           break;
@@ -386,6 +318,75 @@ export default createRule<Options, MessageIds>({
       TSParameterProperty: checkParameterPropertyAccessibilityModifier,
     };
   },
+  defaultOptions: [{ accessibility: 'explicit' }],
+  meta: {
+    docs: {
+      description:
+        'Require explicit accessibility modifiers on class properties and methods',
+      // too opinionated to be recommended
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      addExplicitAccessibility: "Add '{{ type }}' accessibility modifier",
+      missingAccessibility:
+        'Missing accessibility modifier on {{type}} {{name}}.',
+      unwantedPublicAccessibility:
+        'Public accessibility modifier on {{type}} {{name}}.',
+    },
+    schema: [
+      {
+        $defs: {
+          accessibilityLevel: {
+            oneOf: [
+              {
+                description: 'Always require an accessor.',
+                enum: ['explicit'],
+                type: 'string',
+              },
+              {
+                description: 'Require an accessor except when public.',
+                enum: ['no-public'],
+                type: 'string',
+              },
+              {
+                description: 'Never check whether there is an accessor.',
+                enum: ['off'],
+                type: 'string',
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
+          ignoredMethodNames: {
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          overrides: {
+            additionalProperties: false,
+            properties: {
+              accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              parameterProperties: {
+                $ref: '#/items/0/$defs/accessibilityLevel',
+              },
+              properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
+            },
+
+            type: 'object',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'explicit-member-accessibility',
 });
 
 function rangeToLoc(
@@ -393,7 +394,7 @@ function rangeToLoc(
   range: TSESLint.AST.Range,
 ): TSESTree.SourceLocation {
   return {
-    start: sourceCode.getLocFromIndex(range[0]),
     end: sourceCode.getLocFromIndex(range[1]),
+    start: sourceCode.getLocFromIndex(range[0]),
   };
 }
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index c8981e403941..8673c647b6de 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -1,13 +1,15 @@
-import { DefinitionType } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-import { createRule, isFunction } from '../util';
 import type {
   FunctionExpression,
   FunctionInfo,
   FunctionNode,
 } from '../util/explicitReturnTypeUtils';
+
+import { createRule, isFunction } from '../util';
 import {
   ancestorHasReturnType,
   checkFunctionExpressionReturnType,
@@ -33,71 +35,6 @@ type MessageIds =
   | 'missingReturnType';
 
 export default createRule<Options, MessageIds>({
-  name: 'explicit-module-boundary-types',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        "Require explicit return and argument types on exported functions' and classes' public class methods",
-    },
-    messages: {
-      missingReturnType: 'Missing return type on function.',
-      missingArgType: "Argument '{{name}}' should be typed.",
-      missingArgTypeUnnamed: '{{type}} argument should be typed.',
-      anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
-      anyTypedArgUnnamed:
-        '{{type}} argument should be typed with a non-any type.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowArgumentsExplicitlyTypedAsAny: {
-            description:
-              'Whether to ignore arguments that are explicitly typed as `any`.',
-            type: 'boolean',
-          },
-          allowDirectConstAssertionInArrowFunctions: {
-            description: [
-              'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
-              'You must still type the parameters of the function.',
-            ].join('\n'),
-            type: 'boolean',
-          },
-          allowedNames: {
-            description:
-              'An array of function/method names that will not have their arguments or return values checked.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          allowHigherOrderFunctions: {
-            description: [
-              'Whether to ignore return type annotations on functions immediately returning another function expression.',
-              'You must still type the parameters of the function.',
-            ].join('\n'),
-            type: 'boolean',
-          },
-          allowTypedFunctionExpressions: {
-            description:
-              'Whether to ignore type annotations on the variable of a function expression.',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowArgumentsExplicitlyTypedAsAny: false,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowedNames: [],
-      allowHigherOrderFunctions: true,
-      allowTypedFunctionExpressions: true,
-    },
-  ],
   create(context, [options]) {
     // tracks all of the functions we've already checked
     const checkedFunctions = new Set<FunctionNode>();
@@ -139,6 +76,9 @@ export default createRule<Options, MessageIds>({
     */
 
     return {
+      'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression':
+        enterFunction,
+      'ArrowFunctionExpression:exit': exitFunction,
       'ExportDefaultDeclaration:exit'(node): void {
         checkNode(node.declaration);
       },
@@ -153,12 +93,6 @@ export default createRule<Options, MessageIds>({
           }
         }
       },
-      'TSExportAssignment:exit'(node): void {
-        checkNode(node.expression);
-      },
-      'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression':
-        enterFunction,
-      'ArrowFunctionExpression:exit': exitFunction,
       'FunctionDeclaration:exit': exitFunction,
       'FunctionExpression:exit': exitFunction,
       'Program:exit'(): void {
@@ -172,6 +106,9 @@ export default createRule<Options, MessageIds>({
         const current = functionStack[functionStack.length - 1];
         functionReturnsMap.get(current)?.push(node);
       },
+      'TSExportAssignment:exit'(node): void {
+        checkNode(node.expression);
+      },
     };
 
     function checkParameters(
@@ -184,34 +121,34 @@ export default createRule<Options, MessageIds>({
         ): void {
           if (param.type === AST_NODE_TYPES.Identifier) {
             context.report({
-              node: param,
-              messageId: namedMessageId,
               data: { name: param.name },
+              messageId: namedMessageId,
+              node: param,
             });
           } else if (param.type === AST_NODE_TYPES.ArrayPattern) {
             context.report({
-              node: param,
-              messageId: unnamedMessageId,
               data: { type: 'Array pattern' },
+              messageId: unnamedMessageId,
+              node: param,
             });
           } else if (param.type === AST_NODE_TYPES.ObjectPattern) {
             context.report({
-              node: param,
-              messageId: unnamedMessageId,
               data: { type: 'Object pattern' },
+              messageId: unnamedMessageId,
+              node: param,
             });
           } else if (param.type === AST_NODE_TYPES.RestElement) {
             if (param.argument.type === AST_NODE_TYPES.Identifier) {
               context.report({
-                node: param,
-                messageId: namedMessageId,
                 data: { name: param.argument.name },
+                messageId: namedMessageId,
+                node: param,
               });
             } else {
               context.report({
-                node: param,
-                messageId: unnamedMessageId,
                 data: { type: 'Rest' },
+                messageId: unnamedMessageId,
+                node: param,
               });
             }
           }
@@ -331,9 +268,9 @@ export default createRule<Options, MessageIds>({
         // cases we don't care about in this rule
         if (
           [
+            DefinitionType.CatchClause,
             DefinitionType.ImplicitGlobalVariable,
             DefinitionType.ImportBinding,
-            DefinitionType.CatchClause,
             DefinitionType.Parameter,
           ].includes(definition.type)
         ) {
@@ -443,8 +380,8 @@ export default createRule<Options, MessageIds>({
         node.parent.kind === 'set';
       if (!isConstructor && !isSetAccessor && !node.returnType) {
         context.report({
-          node,
           messageId: 'missingReturnType',
+          node,
         });
       }
 
@@ -474,9 +411,9 @@ export default createRule<Options, MessageIds>({
         context.sourceCode,
         loc => {
           context.report({
-            node,
             loc,
             messageId: 'missingReturnType',
+            node,
           });
         },
       );
@@ -503,9 +440,9 @@ export default createRule<Options, MessageIds>({
         context.sourceCode,
         loc => {
           context.report({
-            node,
             loc,
             messageId: 'missingReturnType',
+            node,
           });
         },
       );
@@ -513,4 +450,69 @@ export default createRule<Options, MessageIds>({
       checkParameters(node);
     }
   },
+  defaultOptions: [
+    {
+      allowArgumentsExplicitlyTypedAsAny: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowHigherOrderFunctions: true,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        "Require explicit return and argument types on exported functions' and classes' public class methods",
+    },
+    messages: {
+      anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
+      anyTypedArgUnnamed:
+        '{{type}} argument should be typed with a non-any type.',
+      missingArgType: "Argument '{{name}}' should be typed.",
+      missingArgTypeUnnamed: '{{type}} argument should be typed.',
+      missingReturnType: 'Missing return type on function.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowArgumentsExplicitlyTypedAsAny: {
+            description:
+              'Whether to ignore arguments that are explicitly typed as `any`.',
+            type: 'boolean',
+          },
+          allowDirectConstAssertionInArrowFunctions: {
+            description: [
+              'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
+              'You must still type the parameters of the function.',
+            ].join('\n'),
+            type: 'boolean',
+          },
+          allowedNames: {
+            description:
+              'An array of function/method names that will not have their arguments or return values checked.',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          allowHigherOrderFunctions: {
+            description: [
+              'Whether to ignore return type annotations on functions immediately returning another function expression.',
+              'You must still type the parameters of the function.',
+            ].join('\n'),
+            type: 'boolean',
+          },
+          allowTypedFunctionExpressions: {
+            description:
+              'Whether to ignore type annotations on the variable of a function expression.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'explicit-module-boundary-types',
 });
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 53ad84350e30..106587e8c47e 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -1,10 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -14,19 +16,6 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'init-declarations',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require or disallow initialization in variable declarations',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: ['always'],
   create(context, [mode]) {
     // Make a custom context to adjust the loc of reports where the base
     // rule's behavior is a bit too aggressive with TS-specific syntax (namely,
@@ -108,6 +97,19 @@ export default createRule<Options, MessageIds>({
       return false;
     }
   },
+  defaultOptions: ['always'],
+  meta: {
+    docs: {
+      description:
+        'Require or disallow initialization in variable declarations',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'suggestion',
+  },
+  name: 'init-declarations',
 });
 
 /**
@@ -128,7 +130,7 @@ function getReportLoc(
   };
 
   return {
-    start,
     end,
+    start,
   };
 }
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index 622848affce1..e72d88b75a31 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -1,17 +1,19 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
 type FunctionLike =
+  | TSESTree.ArrowFunctionExpression
   | TSESTree.FunctionDeclaration
-  | TSESTree.FunctionExpression
-  | TSESTree.ArrowFunctionExpression;
+  | TSESTree.FunctionExpression;
 
 type FunctionRuleListener<T extends FunctionLike> = (node: T) => void;
 
@@ -21,37 +23,6 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'max-params',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce a maximum number of parameters in function definitions',
-      extendsBaseRule: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          maximum: {
-            type: 'integer',
-            minimum: 0,
-          },
-          max: {
-            type: 'integer',
-            minimum: 0,
-          },
-          countVoidThis: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [{ max: 3, countVoidThis: false }],
-
   create(context, [{ countVoidThis }]) {
     const baseRules = baseRule.create(context);
 
@@ -90,4 +61,35 @@ export default createRule<Options, MessageIds>({
       FunctionExpression: wrapListener(baseRules.FunctionExpression),
     };
   },
+  defaultOptions: [{ countVoidThis: false, max: 3 }],
+  meta: {
+    docs: {
+      description:
+        'Enforce a maximum number of parameters in function definitions',
+      extendsBaseRule: true,
+    },
+    messages: baseRule.meta.messages,
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          countVoidThis: {
+            type: 'boolean',
+          },
+          max: {
+            minimum: 0,
+            type: 'integer',
+          },
+          maximum: {
+            minimum: 0,
+            type: 'integer',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'max-params',
 });
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index 93e5f45adcdc..64e2220c8eab 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -2,6 +2,7 @@
 /* eslint-disable eslint-plugin/no-property-in-node */
 
 import type { JSONSchema, TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import naturalCompare from 'natural-compare';
 
@@ -20,7 +21,6 @@ export type MessageIds =
 type ReadonlyType = 'readonly-field' | 'readonly-signature';
 
 type MemberKind =
-  | ReadonlyType
   | 'accessor'
   | 'call-signature'
   | 'constructor'
@@ -29,15 +29,16 @@ type MemberKind =
   | 'method'
   | 'set'
   | 'signature'
-  | 'static-initialization';
+  | 'static-initialization'
+  | ReadonlyType;
 
 type DecoratedMemberKind =
-  | Exclude<ReadonlyType, 'readonly-signature'>
   | 'accessor'
   | 'field'
   | 'get'
   | 'method'
-  | 'set';
+  | 'set'
+  | Exclude<ReadonlyType, 'readonly-signature'>;
 
 type NonCallableMemberKind = Exclude<
   MemberKind,
@@ -46,10 +47,9 @@ type NonCallableMemberKind = Exclude<
 
 type MemberScope = 'abstract' | 'instance' | 'static';
 
-type Accessibility = TSESTree.Accessibility | '#private';
+type Accessibility = '#private' | TSESTree.Accessibility;
 
 type BaseMemberType =
-  | MemberKind
   | `${Accessibility}-${Exclude<
       MemberKind,
       'readonly-signature' | 'signature' | 'static-initialization'
@@ -57,75 +57,76 @@ type BaseMemberType =
   | `${Accessibility}-${MemberScope}-${NonCallableMemberKind}`
   | `${Accessibility}-decorated-${DecoratedMemberKind}`
   | `${MemberScope}-${NonCallableMemberKind}`
-  | `decorated-${DecoratedMemberKind}`;
+  | `decorated-${DecoratedMemberKind}`
+  | MemberKind;
 
 type MemberType = BaseMemberType | BaseMemberType[];
 
 type AlphabeticalOrder =
-  | 'alphabetically-case-insensitive'
   | 'alphabetically'
-  | 'natural-case-insensitive'
-  | 'natural';
+  | 'alphabetically-case-insensitive'
+  | 'natural'
+  | 'natural-case-insensitive';
 
-type Order = AlphabeticalOrder | 'as-written';
+type Order = 'as-written' | AlphabeticalOrder;
 
 interface SortedOrderConfig {
-  memberTypes?: MemberType[] | 'never';
+  memberTypes?: 'never' | MemberType[];
   optionalityOrder?: OptionalityOrder;
   order?: Order;
 }
 
-type OrderConfig = MemberType[] | SortedOrderConfig | 'never';
+type OrderConfig = 'never' | MemberType[] | SortedOrderConfig;
 type Member = TSESTree.ClassElement | TSESTree.TypeElement;
 
 type OptionalityOrder = 'optional-first' | 'required-first';
 
 export type Options = [
   {
-    default?: OrderConfig;
     classes?: OrderConfig;
     classExpressions?: OrderConfig;
+    default?: OrderConfig;
     interfaces?: OrderConfig;
     typeLiterals?: OrderConfig;
   },
 ];
 
 const neverConfig: JSONSchema.JSONSchema4 = {
-  type: 'string',
   enum: ['never'],
+  type: 'string',
 };
 
 const arrayConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
-  type: 'array',
   items: {
     oneOf: [
       {
         $ref: memberTypes,
       },
       {
-        type: 'array',
         items: {
           $ref: memberTypes,
         },
+        type: 'array',
       },
     ],
   },
+  type: 'array',
 });
 
 const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
-  type: 'object',
+  additionalProperties: false,
   properties: {
     memberTypes: {
       oneOf: [arrayConfig(memberTypes), neverConfig],
     },
-    order: {
-      $ref: '#/items/0/$defs/orderOptions',
-    },
     optionalityOrder: {
       $ref: '#/items/0/$defs/optionalityOrderOptions',
     },
+    order: {
+      $ref: '#/items/0/$defs/orderOptions',
+    },
   },
-  additionalProperties: false,
+  type: 'object',
 });
 
 export const defaultOrder: MemberType[] = [
@@ -415,12 +416,12 @@ function getNodeType(node: Member): MemberKind | null {
  */
 function getMemberRawName(
   member:
-    | TSESTree.MethodDefinition
     | TSESTree.AccessorProperty
+    | TSESTree.MethodDefinition
     | TSESTree.Property
     | TSESTree.PropertyDefinition
-    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.TSAbstractAccessorProperty
+    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.TSAbstractPropertyDefinition
     | TSESTree.TSMethodSignature
     | TSESTree.TSPropertySignature,
@@ -717,96 +718,6 @@ function getLowestRank(
 }
 
 export default createRule<Options, MessageIds>({
-  name: 'member-ordering',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require a consistent member declaration order',
-    },
-    messages: {
-      incorrectOrder:
-        'Member {{member}} should be declared before member {{beforeMember}}.',
-      incorrectGroupOrder:
-        'Member {{name}} should be declared before all {{rank}} definitions.',
-      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
-    },
-    schema: [
-      {
-        $defs: {
-          orderOptions: {
-            type: 'string',
-            enum: [
-              'alphabetically',
-              'alphabetically-case-insensitive',
-              'as-written',
-              'natural',
-              'natural-case-insensitive',
-            ],
-          },
-          optionalityOrderOptions: {
-            type: 'string',
-            enum: ['optional-first', 'required-first'],
-          },
-          allItems: {
-            type: 'string',
-            enum: allMemberTypes as string[],
-          },
-          typeItems: {
-            type: 'string',
-            enum: [
-              'readonly-signature',
-              'signature',
-              'readonly-field',
-              'field',
-              'method',
-              'constructor',
-            ],
-          },
-
-          baseConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/allItems'),
-              objectConfig('#/items/0/$defs/allItems'),
-            ],
-          },
-          typesConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/typeItems'),
-              objectConfig('#/items/0/$defs/typeItems'),
-            ],
-          },
-        },
-        type: 'object',
-        properties: {
-          default: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          classes: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          classExpressions: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          interfaces: {
-            $ref: '#/items/0/$defs/typesConfig',
-          },
-          typeLiterals: {
-            $ref: '#/items/0/$defs/typesConfig',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      default: {
-        memberTypes: defaultOrder,
-      },
-    },
-  ],
   create(context, [options]) {
     /**
      * Checks if the member groups are correctly sorted.
@@ -839,12 +750,12 @@ export default createRule<Options, MessageIds>({
         // 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),
             },
+            messageId: 'incorrectGroupOrder',
+            node: member,
           });
 
           isCorrectlySorted = false;
@@ -884,12 +795,12 @@ export default createRule<Options, MessageIds>({
         if (name) {
           if (naturalOutOfOrder(name, previousName, order)) {
             context.report({
-              node: member,
-              messageId: 'incorrectOrder',
               data: {
-                member: name,
                 beforeMember: previousName,
+                member: name,
               },
+              messageId: 'incorrectOrder',
+              node: member,
             });
 
             isCorrectlySorted = false;
@@ -945,13 +856,13 @@ export default createRule<Options, MessageIds>({
 
       const report = (member: Member): void =>
         context.report({
-          messageId: 'incorrectRequiredMembersOrder',
-          loc: member.loc,
           data: {
             member: getMemberName(member, context.sourceCode),
             optionalOrRequired:
               optionalityOrder === 'required-first' ? 'required' : 'optional',
           },
+          loc: member.loc,
+          messageId: 'incorrectRequiredMembersOrder',
         });
 
       // if the optionality of the first item is correct (based on optionalityOrder)
@@ -1075,11 +986,6 @@ export default createRule<Options, MessageIds>({
     // https://github.com/typescript-eslint/typescript-eslint/issues/5439
     /* eslint-disable @typescript-eslint/no-non-null-assertion */
     return {
-      'ClassDeclaration, FunctionDeclaration'(node): void {
-        if ('superClass' in node) {
-          // ...
-        }
-      },
       ClassDeclaration(node): void {
         validateMembersOrder(
           node.body.body,
@@ -1087,6 +993,11 @@ export default createRule<Options, MessageIds>({
           true,
         );
       },
+      'ClassDeclaration, FunctionDeclaration'(node): void {
+        if ('superClass' in node) {
+          // ...
+        }
+      },
       ClassExpression(node): void {
         validateMembersOrder(
           node.body.body,
@@ -1111,4 +1022,94 @@ export default createRule<Options, MessageIds>({
     };
     /* eslint-enable @typescript-eslint/no-non-null-assertion */
   },
+  defaultOptions: [
+    {
+      default: {
+        memberTypes: defaultOrder,
+      },
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Require a consistent member declaration order',
+    },
+    messages: {
+      incorrectGroupOrder:
+        'Member {{name}} should be declared before all {{rank}} definitions.',
+      incorrectOrder:
+        'Member {{member}} should be declared before member {{beforeMember}}.',
+      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
+    },
+    schema: [
+      {
+        $defs: {
+          allItems: {
+            enum: allMemberTypes as string[],
+            type: 'string',
+          },
+          baseConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/allItems'),
+              objectConfig('#/items/0/$defs/allItems'),
+            ],
+          },
+          optionalityOrderOptions: {
+            enum: ['optional-first', 'required-first'],
+            type: 'string',
+          },
+          orderOptions: {
+            enum: [
+              'alphabetically',
+              'alphabetically-case-insensitive',
+              'as-written',
+              'natural',
+              'natural-case-insensitive',
+            ],
+            type: 'string',
+          },
+
+          typeItems: {
+            enum: [
+              'readonly-signature',
+              'signature',
+              'readonly-field',
+              'field',
+              'method',
+              'constructor',
+            ],
+            type: 'string',
+          },
+          typesConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/typeItems'),
+              objectConfig('#/items/0/$defs/typeItems'),
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          classes: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          classExpressions: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          default: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          interfaces: {
+            $ref: '#/items/0/$defs/typesConfig',
+          },
+          typeLiterals: {
+            $ref: '#/items/0/$defs/typesConfig',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'member-ordering',
 });
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index 48207e5cc91a..2939dd242182 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -14,28 +15,6 @@ export type Options = [('method' | 'property')?];
 export type MessageIds = 'errorMethod' | 'errorProperty';
 
 export default createRule<Options, MessageIds>({
-  name: 'method-signature-style',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce using a particular method signature syntax',
-    },
-    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: [
-      {
-        type: 'string',
-        enum: ['property', 'method'],
-      },
-    ],
-  },
-  defaultOptions: ['property'],
-
   create(context, [mode]) {
     function getMethodKey(
       node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature,
@@ -147,13 +126,11 @@ export default createRule<Options, MessageIds>({
           if (duplicatedKeyMethodNodes.length > 0) {
             if (isParentModule) {
               context.report({
-                node: methodNode,
                 messageId: 'errorMethod',
+                node: methodNode,
               });
             } else {
               context.report({
-                node: methodNode,
-                messageId: 'errorMethod',
                 *fix(fixer) {
                   const methodNodes = [
                     methodNode,
@@ -187,6 +164,8 @@ export default createRule<Options, MessageIds>({
                     }
                   }
                 },
+                messageId: 'errorMethod',
+                node: methodNode,
               });
             }
             return;
@@ -194,13 +173,11 @@ export default createRule<Options, MessageIds>({
 
           if (isParentModule) {
             context.report({
-              node: methodNode,
               messageId: 'errorMethod',
+              node: methodNode,
             });
           } else {
             context.report({
-              node: methodNode,
-              messageId: 'errorMethod',
               fix: fixer => {
                 const key = getMethodKey(methodNode);
                 const params = getMethodParams(methodNode);
@@ -211,6 +188,8 @@ export default createRule<Options, MessageIds>({
                   `${key}: ${params} => ${returnType}${delimiter}`,
                 );
               },
+              messageId: 'errorMethod',
+              node: methodNode,
             });
           }
         },
@@ -223,8 +202,6 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node: propertyNode,
-            messageId: 'errorProperty',
             fix: fixer => {
               const key = getMethodKey(propertyNode);
               const params = getMethodParams(typeNode);
@@ -235,9 +212,33 @@ export default createRule<Options, MessageIds>({
                 `${key}${params}: ${returnType}${delimiter}`,
               );
             },
+            messageId: 'errorProperty',
+            node: propertyNode,
           });
         },
       }),
     };
   },
+  defaultOptions: ['property'],
+  meta: {
+    docs: {
+      description: 'Enforce using a particular method signature syntax',
+    },
+    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'],
+        type: 'string',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'method-signature-style',
 });
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
index c30029882e16..7e26a97897ca 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
@@ -22,27 +22,27 @@ type UnderscoreOptionsString = keyof typeof UnderscoreOptions;
 
 enum Selectors {
   // variableLike
-  variable = 1 << 0,
   function = 1 << 1,
   parameter = 1 << 2,
+  variable = 1 << 0,
 
   // memberLike
-  parameterProperty = 1 << 3,
+  autoAccessor = 1 << 12,
   classicAccessor = 1 << 4,
-  enumMember = 1 << 5,
   classMethod = 1 << 6,
-  objectLiteralMethod = 1 << 7,
-  typeMethod = 1 << 8,
   classProperty = 1 << 9,
+  enumMember = 1 << 5,
+  objectLiteralMethod = 1 << 7,
   objectLiteralProperty = 1 << 10,
+  parameterProperty = 1 << 3,
+  typeMethod = 1 << 8,
   typeProperty = 1 << 11,
-  autoAccessor = 1 << 12,
 
   // typeLike
   class = 1 << 13,
+  enum = 1 << 16,
   interface = 1 << 14,
   typeAlias = 1 << 15,
-  enum = 1 << 16,
   typeParameter = 1 << 17,
 
   // other
@@ -52,11 +52,8 @@ type SelectorsString = keyof typeof Selectors;
 
 enum MetaSelectors {
   /* eslint-disable @typescript-eslint/prefer-literal-enum-member */
+  accessor = 0 | Selectors.classicAccessor | Selectors.autoAccessor,
   default = -1,
-  variableLike = 0 |
-    Selectors.variable |
-    Selectors.function |
-    Selectors.parameter,
   memberLike = 0 |
     Selectors.classProperty |
     Selectors.objectLiteralProperty |
@@ -68,12 +65,6 @@ enum MetaSelectors {
     Selectors.typeMethod |
     Selectors.classicAccessor |
     Selectors.autoAccessor,
-  typeLike = 0 |
-    Selectors.class |
-    Selectors.interface |
-    Selectors.typeAlias |
-    Selectors.enum |
-    Selectors.typeParameter,
   method = 0 |
     Selectors.classMethod |
     Selectors.objectLiteralMethod |
@@ -82,7 +73,16 @@ enum MetaSelectors {
     Selectors.classProperty |
     Selectors.objectLiteralProperty |
     Selectors.typeProperty,
-  accessor = 0 | Selectors.classicAccessor | Selectors.autoAccessor,
+  typeLike = 0 |
+    Selectors.class |
+    Selectors.interface |
+    Selectors.typeAlias |
+    Selectors.enum |
+    Selectors.typeParameter,
+  variableLike = 0 |
+    Selectors.variable |
+    Selectors.function |
+    Selectors.parameter,
   /* eslint-enable @typescript-eslint/prefer-literal-enum-member */
 }
 type MetaSelectorsString = keyof typeof MetaSelectors;
@@ -96,11 +96,11 @@ enum Modifiers {
   // static members
   static = 1 << 2,
   // member accessibility
-  public = 1 << 3,
-  protected = 1 << 4,
-  private = 1 << 5,
   '#private' = 1 << 6,
   abstract = 1 << 7,
+  private = 1 << 5,
+  protected = 1 << 4,
+  public = 1 << 3,
   // destructured variable
   destructured = 1 << 8,
   // variables declared in the top-level scope
@@ -125,11 +125,11 @@ enum Modifiers {
 type ModifiersString = keyof typeof Modifiers;
 
 enum TypeModifiers {
+  array = 1 << 21,
   boolean = 1 << 17,
-  string = 1 << 18,
-  number = 1 << 19,
   function = 1 << 20,
-  array = 1 << 21,
+  number = 1 << 19,
+  string = 1 << 18,
 }
 type TypeModifiersString = keyof typeof TypeModifiers;
 
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/format.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/format.ts
index d3db62399eaa..e8fdbdfd4f52 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/format.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/format.ts
@@ -99,12 +99,12 @@ function validateUnderscores(name: string): boolean {
 const PredefinedFormatToCheckFunction: Readonly<
   Record<PredefinedFormats, (name: string) => boolean>
 > = {
-  [PredefinedFormats.PascalCase]: isPascalCase,
-  [PredefinedFormats.StrictPascalCase]: isStrictPascalCase,
   [PredefinedFormats.camelCase]: isCamelCase,
+  [PredefinedFormats.PascalCase]: isPascalCase,
+  [PredefinedFormats.snake_case]: isSnakeCase,
   [PredefinedFormats.strictCamelCase]: isStrictCamelCase,
+  [PredefinedFormats.StrictPascalCase]: isStrictPascalCase,
   [PredefinedFormats.UPPER_CASE]: isUpperCase,
-  [PredefinedFormats.snake_case]: isSnakeCase,
 };
 
 export { PredefinedFormatToCheckFunction };
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/index.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/index.ts
index 56297213b66c..11d3953c76fa 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/index.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/index.ts
@@ -1,6 +1,6 @@
 export { Modifiers } from './enums';
 export type { PredefinedFormatsString } from './enums';
-export type { Context, Selector, ValidatorFunction } from './types';
+export { parseOptions } from './parse-options';
 export { SCHEMA } from './schema';
 export { selectorTypeToMessageString } from './shared';
-export { parseOptions } from './parse-options';
+export type { Context, Selector, ValidatorFunction } from './types';
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts
index 08ac8d41c8b0..199be4ccf7e9 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts
@@ -1,3 +1,10 @@
+import type {
+  Context,
+  NormalizedSelector,
+  ParsedOptions,
+  Selector,
+} from './types';
+
 import { getEnumNames } from '../../util';
 import {
   MetaSelectors,
@@ -8,12 +15,6 @@ import {
   UnderscoreOptions,
 } from './enums';
 import { isMetaSelector } from './shared';
-import type {
-  Context,
-  NormalizedSelector,
-  ParsedOptions,
-  Selector,
-} from './types';
 import { createValidator } from './validator';
 
 function normalizeOption(option: Selector): NormalizedSelector[] {
@@ -32,37 +33,37 @@ function normalizeOption(option: Selector): NormalizedSelector[] {
 
   const normalizedOption = {
     // format options
-    format: option.format ? option.format.map(f => PredefinedFormats[f]) : null,
     custom: option.custom
       ? {
-          regex: new RegExp(option.custom.regex, 'u'),
           match: option.custom.match,
+          regex: new RegExp(option.custom.regex, 'u'),
         }
       : null,
-    leadingUnderscore:
-      option.leadingUnderscore !== undefined
-        ? UnderscoreOptions[option.leadingUnderscore]
-        : null,
-    trailingUnderscore:
-      option.trailingUnderscore !== undefined
-        ? UnderscoreOptions[option.trailingUnderscore]
-        : null,
-    prefix: option.prefix && option.prefix.length > 0 ? option.prefix : null,
-    suffix: option.suffix && option.suffix.length > 0 ? option.suffix : null,
-    modifiers: option.modifiers?.map(m => Modifiers[m]) ?? null,
-    types: option.types?.map(m => TypeModifiers[m]) ?? null,
     filter:
       option.filter !== undefined
         ? typeof option.filter === 'string'
           ? {
-              regex: new RegExp(option.filter, 'u'),
               match: true,
+              regex: new RegExp(option.filter, 'u'),
             }
           : {
-              regex: new RegExp(option.filter.regex, 'u'),
               match: option.filter.match,
+              regex: new RegExp(option.filter.regex, 'u'),
             }
         : null,
+    format: option.format ? option.format.map(f => PredefinedFormats[f]) : null,
+    leadingUnderscore:
+      option.leadingUnderscore !== undefined
+        ? UnderscoreOptions[option.leadingUnderscore]
+        : null,
+    modifiers: option.modifiers?.map(m => Modifiers[m]) ?? null,
+    prefix: option.prefix && option.prefix.length > 0 ? option.prefix : null,
+    suffix: option.suffix && option.suffix.length > 0 ? option.suffix : null,
+    trailingUnderscore:
+      option.trailingUnderscore !== undefined
+        ? UnderscoreOptions[option.trailingUnderscore]
+        : null,
+    types: option.types?.map(m => TypeModifiers[m]) ?? null,
     // calculated ordering weight based on modifiers
     modifierWeight: weight,
   };
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
index d7016e217f2f..13e4f9a8b3cd 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
@@ -1,10 +1,11 @@
 import type { JSONSchema } from '@typescript-eslint/utils';
 
-import { getEnumNames } from '../../util';
 import type {
   IndividualAndMetaSelectorsString,
   ModifiersString,
 } from './enums';
+
+import { getEnumNames } from '../../util';
 import {
   MetaSelectors,
   Modifiers,
@@ -16,51 +17,51 @@ import {
 
 const $DEFS: Record<string, JSONSchema.JSONSchema4> = {
   // enums
-  underscoreOptions: {
-    type: 'string',
-    enum: getEnumNames(UnderscoreOptions),
-  },
   predefinedFormats: {
-    type: 'string',
     enum: getEnumNames(PredefinedFormats),
+    type: 'string',
   },
   typeModifiers: {
-    type: 'string',
     enum: getEnumNames(TypeModifiers),
+    type: 'string',
+  },
+  underscoreOptions: {
+    enum: getEnumNames(UnderscoreOptions),
+    type: 'string',
   },
 
   // repeated types
-  prefixSuffixConfig: {
-    type: 'array',
-    items: {
-      type: 'string',
-      minLength: 1,
-    },
-    additionalItems: false,
-  },
-  matchRegexConfig: {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-      match: { type: 'boolean' },
-      regex: { type: 'string' },
-    },
-    required: ['match', 'regex'],
-  },
   formatOptionsConfig: {
     oneOf: [
       {
-        type: 'array',
+        additionalItems: false,
         items: {
           $ref: '#/$defs/predefinedFormats',
         },
-        additionalItems: false,
+        type: 'array',
       },
       {
         type: 'null',
       },
     ],
   },
+  matchRegexConfig: {
+    additionalProperties: false,
+    properties: {
+      match: { type: 'boolean' },
+      regex: { type: 'string' },
+    },
+    required: ['match', 'regex'],
+    type: 'object',
+  },
+  prefixSuffixConfig: {
+    additionalItems: false,
+    items: {
+      minLength: 1,
+      type: 'string',
+    },
+    type: 'array',
+  },
 };
 
 const UNDERSCORE_SCHEMA: JSONSchema.JSONSchema4 = {
@@ -74,17 +75,17 @@ const MATCH_REGEX_SCHEMA: JSONSchema.JSONSchema4 = {
 };
 type JSONSchemaProperties = Record<string, JSONSchema.JSONSchema4>;
 const FORMAT_OPTIONS_PROPERTIES: JSONSchemaProperties = {
+  custom: MATCH_REGEX_SCHEMA,
+  failureMessage: {
+    type: 'string',
+  },
   format: {
     $ref: '#/$defs/formatOptionsConfig',
   },
-  custom: MATCH_REGEX_SCHEMA,
   leadingUnderscore: UNDERSCORE_SCHEMA,
-  trailingUnderscore: UNDERSCORE_SCHEMA,
   prefix: PREFIX_SUFFIX_SCHEMA,
   suffix: PREFIX_SUFFIX_SCHEMA,
-  failureMessage: {
-    type: 'string',
-  },
+  trailingUnderscore: UNDERSCORE_SCHEMA,
 };
 function selectorSchema(
   selectorString: IndividualAndMetaSelectorsString,
@@ -95,98 +96,98 @@ function selectorSchema(
     filter: {
       oneOf: [
         {
-          type: 'string',
           minLength: 1,
+          type: 'string',
         },
         MATCH_REGEX_SCHEMA,
       ],
     },
     selector: {
-      type: 'string',
       enum: [selectorString],
+      type: 'string',
     },
   };
   if (modifiers && modifiers.length > 0) {
     selector.modifiers = {
-      type: 'array',
+      additionalItems: false,
       items: {
-        type: 'string',
         enum: modifiers,
+        type: 'string',
       },
-      additionalItems: false,
+      type: 'array',
     };
   }
   if (allowType) {
     selector.types = {
-      type: 'array',
+      additionalItems: false,
       items: {
         $ref: '#/$defs/typeModifiers',
       },
-      additionalItems: false,
+      type: 'array',
     };
   }
 
   return [
     {
-      type: 'object',
+      additionalProperties: false,
       description: `Selector '${selectorString}'`,
       properties: {
         ...FORMAT_OPTIONS_PROPERTIES,
         ...selector,
       },
       required: ['selector', 'format'],
-      additionalProperties: false,
+      type: 'object',
     },
   ];
 }
 
 function selectorsSchema(): JSONSchema.JSONSchema4 {
   return {
-    type: 'object',
+    additionalProperties: false,
     description: 'Multiple selectors in one config',
     properties: {
       ...FORMAT_OPTIONS_PROPERTIES,
       filter: {
         oneOf: [
           {
-            type: 'string',
             minLength: 1,
+            type: 'string',
           },
           MATCH_REGEX_SCHEMA,
         ],
       },
-      selector: {
-        type: 'array',
+      modifiers: {
+        additionalItems: false,
         items: {
+          enum: getEnumNames(Modifiers),
           type: 'string',
-          enum: [...getEnumNames(MetaSelectors), ...getEnumNames(Selectors)],
         },
-        additionalItems: false,
-      },
-      modifiers: {
         type: 'array',
+      },
+      selector: {
+        additionalItems: false,
         items: {
+          enum: [...getEnumNames(MetaSelectors), ...getEnumNames(Selectors)],
           type: 'string',
-          enum: getEnumNames(Modifiers),
         },
-        additionalItems: false,
+        type: 'array',
       },
       types: {
-        type: 'array',
+        additionalItems: false,
         items: {
           $ref: '#/$defs/typeModifiers',
         },
-        additionalItems: false,
+        type: 'array',
       },
     },
     required: ['selector', 'format'],
-    additionalProperties: false,
+    type: 'object',
   };
 }
 
 const SCHEMA: JSONSchema.JSONSchema4 = {
   $defs: $DEFS,
-  type: 'array',
+  additionalItems: false,
   items: {
     oneOf: [
       selectorsSchema(),
@@ -326,7 +327,7 @@ const SCHEMA: JSONSchema.JSONSchema4 = {
       ...selectorSchema('import', false, ['default', 'namespace']),
     ],
   },
-  additionalItems: false,
+  type: 'array',
 };
 
 export { SCHEMA };
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/shared.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/shared.ts
index a7f3e7f6093e..c1c31b78ebe8 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/shared.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/shared.ts
@@ -4,6 +4,7 @@ import type {
   Selectors,
   SelectorsString,
 } from './enums';
+
 import { MetaSelectors } from './enums';
 
 function selectorTypeToMessageString(selectorType: SelectorsString): string {
@@ -26,7 +27,7 @@ function isMethodOrPropertySelector(
 }
 
 export {
-  selectorTypeToMessageString,
   isMetaSelector,
   isMethodOrPropertySelector,
+  selectorTypeToMessageString,
 };
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/types.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/types.ts
index fd0910050e00..41df37e8cb15 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/types.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/types.ts
@@ -17,47 +17,47 @@ import type {
 } from './enums';
 
 interface MatchRegex {
-  regex: string;
   match: boolean;
+  regex: string;
 }
 
 interface Selector {
+  custom?: MatchRegex;
+  filter?: MatchRegex | string;
   // format options
   format: PredefinedFormatsString[] | null;
-  custom?: MatchRegex;
   leadingUnderscore?: UnderscoreOptionsString;
-  trailingUnderscore?: UnderscoreOptionsString;
+  modifiers?: ModifiersString[];
   prefix?: string[];
-  suffix?: string[];
   // selector options
   selector:
     | IndividualAndMetaSelectorsString
     | IndividualAndMetaSelectorsString[];
-  modifiers?: ModifiersString[];
+  suffix?: string[];
+  trailingUnderscore?: UnderscoreOptionsString;
   types?: TypeModifiersString[];
-  filter?: MatchRegex | string;
 }
 
 interface NormalizedMatchRegex {
-  regex: RegExp;
   match: boolean;
+  regex: RegExp;
 }
 
 interface NormalizedSelector {
+  custom: NormalizedMatchRegex | null;
+  filter: NormalizedMatchRegex | null;
   // format options
   format: PredefinedFormats[] | null;
-  custom: NormalizedMatchRegex | null;
   leadingUnderscore: UnderscoreOptions | null;
-  trailingUnderscore: UnderscoreOptions | null;
+  modifiers: Modifiers[] | null;
+  // calculated ordering weight based on modifiers
+  modifierWeight: number;
   prefix: string[] | null;
-  suffix: string[] | null;
   // selector options
   selector: MetaSelectors | Selectors;
-  modifiers: Modifiers[] | null;
+  suffix: string[] | null;
+  trailingUnderscore: UnderscoreOptions | null;
   types: TypeModifiers[] | null;
-  filter: NormalizedMatchRegex | null;
-  // calculated ordering weight based on modifiers
-  modifierWeight: number;
 }
 
 type ValidatorFunction = (
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
index f656769b1b67..afae8bb029b9 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
@@ -1,9 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type * as ts from 'typescript';
 
-import { getParserServices } from '../../util';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import type { SelectorsString } from './enums';
+import type { Context, NormalizedSelector } from './types';
+
+import { getParserServices } from '../../util';
 import {
   MetaSelectors,
   Modifiers,
@@ -18,7 +21,6 @@ import {
   isMethodOrPropertySelector,
   selectorTypeToMessageString,
 } from './shared';
-import type { Context, NormalizedSelector } from './types';
 
 function createValidator(
   type: SelectorsString,
@@ -144,29 +146,28 @@ function createValidator(
   // centralizes the logic for formatting the report data
   function formatReportData({
     affixes,
+    count,
+    custom,
     formats,
     originalName,
-    processedName,
     position,
-    custom,
-    count,
+    processedName,
   }: {
     affixes?: string[];
+    count?: 'one' | 'two';
+    custom?: NonNullable<NormalizedSelector['custom']>;
     formats?: PredefinedFormats[];
     originalName: string;
-    processedName?: string;
     position?: 'leading' | 'prefix' | 'suffix' | 'trailing';
-    custom?: NonNullable<NormalizedSelector['custom']>;
-    count?: 'one' | 'two';
+    processedName?: string;
   }): Record<string, unknown> {
     return {
-      type: selectorTypeToMessageString(type),
-      name: originalName,
-      processedName,
-      position,
-      count,
       affixes: affixes?.join(', '),
+      count,
       formats: formats?.map(f => PredefinedFormats[f]).join(', '),
+      name: originalName,
+      position,
+      processedName,
       regex: custom?.regex.toString(),
       regexMatch:
         custom?.match === true
@@ -174,6 +175,7 @@ function createValidator(
           : custom?.match === false
             ? 'not match'
             : null,
+      type: selectorTypeToMessageString(type),
     };
   }
 
@@ -247,13 +249,13 @@ function createValidator(
       case UnderscoreOptions.forbid: {
         if (hasSingleUnderscore()) {
           context.report({
-            node,
-            messageId: 'unexpectedUnderscore',
             data: formatReportData({
+              count: 'one',
               originalName,
               position,
-              count: 'one',
             }),
+            messageId: 'unexpectedUnderscore',
+            node,
           });
           return null;
         }
@@ -265,13 +267,13 @@ function createValidator(
       case UnderscoreOptions.require: {
         if (!hasSingleUnderscore()) {
           context.report({
-            node,
-            messageId: 'missingUnderscore',
             data: formatReportData({
+              count: 'one',
               originalName,
               position,
-              count: 'one',
             }),
+            messageId: 'missingUnderscore',
+            node,
           });
           return null;
         }
@@ -282,13 +284,13 @@ function createValidator(
       case UnderscoreOptions.requireDouble: {
         if (!hasDoubleUnderscore()) {
           context.report({
-            node,
-            messageId: 'missingUnderscore',
             data: formatReportData({
+              count: 'two',
               originalName,
               position,
-              count: 'two',
             }),
+            messageId: 'missingUnderscore',
+            node,
           });
           return null;
         }
@@ -328,13 +330,13 @@ function createValidator(
     }
 
     context.report({
-      node,
-      messageId: 'missingAffix',
       data: formatReportData({
+        affixes,
         originalName,
         position,
-        affixes,
       }),
+      messageId: 'missingAffix',
+      node,
     });
     return null;
   }
@@ -362,12 +364,12 @@ function createValidator(
     }
 
     context.report({
-      node,
-      messageId: 'satisfyCustom',
       data: formatReportData({
-        originalName,
         custom,
+        originalName,
       }),
+      messageId: 'satisfyCustom',
+      node,
     });
     return false;
   }
@@ -397,16 +399,16 @@ function createValidator(
     }
 
     context.report({
-      node,
-      messageId:
-        originalName === name
-          ? 'doesNotMatchFormat'
-          : 'doesNotMatchFormatTrimmed',
       data: formatReportData({
+        formats,
         originalName,
         processedName: name,
-        formats,
       }),
+      messageId:
+        originalName === name
+          ? 'doesNotMatchFormat'
+          : 'doesNotMatchFormatTrimmed',
+      node,
     });
     return false;
   }
diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
index 262f86668071..6a4e4bc53c74 100644
--- a/packages/eslint-plugin/src/rules/naming-convention.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention.ts
@@ -1,22 +1,24 @@
 // This rule was feature-frozen before we enabled no-property-in-node.
 /* eslint-disable eslint-plugin/no-property-in-node */
 
-import { PatternVisitor } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
 import type { ScriptTarget } from 'typescript';
 
-import {
-  collectVariables,
-  createRule,
-  getParserServices,
-  requiresQuoting as _requiresQuoting,
-} from '../util';
+import { PatternVisitor } from '@typescript-eslint/scope-manager';
+import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
+
 import type {
   Context,
   Selector,
   ValidatorFunction,
 } from './naming-convention-utils';
+
+import {
+  requiresQuoting as _requiresQuoting,
+  collectVariables,
+  createRule,
+  getParserServices,
+} from '../util';
 import { Modifiers, parseOptions, SCHEMA } from './naming-convention-utils';
 
 type MessageIds =
@@ -36,57 +38,31 @@ type Options = Selector[];
 // note that that rule ignores leading and trailing underscores and only checks those in the middle of a variable name
 const defaultCamelCaseAllTheThingsConfig: Options = [
   {
-    selector: 'default',
     format: ['camelCase'],
     leadingUnderscore: 'allow',
+    selector: 'default',
     trailingUnderscore: 'allow',
   },
 
   {
-    selector: 'import',
     format: ['camelCase', 'PascalCase'],
+    selector: 'import',
   },
 
   {
-    selector: 'variable',
     format: ['camelCase', 'UPPER_CASE'],
     leadingUnderscore: 'allow',
+    selector: 'variable',
     trailingUnderscore: 'allow',
   },
 
   {
-    selector: 'typeLike',
     format: ['PascalCase'],
+    selector: 'typeLike',
   },
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'naming-convention',
-  meta: {
-    docs: {
-      description:
-        'Enforce naming conventions for everything across a codebase',
-      // technically only requires type checking if the user uses "type" modifiers
-      requiresTypeChecking: true,
-    },
-    type: 'suggestion',
-    messages: {
-      unexpectedUnderscore:
-        '{{type}} name `{{name}}` must not have a {{position}} underscore.',
-      missingUnderscore:
-        '{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).',
-      missingAffix:
-        '{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}',
-      satisfyCustom:
-        '{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}',
-      doesNotMatchFormat:
-        '{{type}} name `{{name}}` must match one of the following formats: {{formats}}',
-      doesNotMatchFormatTrimmed:
-        '{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}',
-    },
-    schema: SCHEMA,
-  },
-  defaultOptions: defaultCamelCaseAllTheThingsConfig,
   create(contextWithoutDefaults) {
     const context =
       contextWithoutDefaults.options.length > 0
@@ -106,14 +82,14 @@ export default createRule<Options, MessageIds>({
     function handleMember(
       validator: ValidatorFunction,
       node:
+        | TSESTree.AccessorPropertyNonComputedName
         | TSESTree.MethodDefinitionNonComputedName
         | TSESTree.PropertyDefinitionNonComputedName
         | TSESTree.PropertyNonComputedName
         | TSESTree.TSAbstractMethodDefinitionNonComputedName
         | TSESTree.TSAbstractPropertyDefinitionNonComputedName
         | TSESTree.TSMethodSignatureNonComputedName
-        | TSESTree.TSPropertySignatureNonComputedName
-        | TSESTree.AccessorPropertyNonComputedName,
+        | TSESTree.TSPropertySignatureNonComputedName,
       modifiers: Set<Modifiers>,
     ): void {
       const key = node.key;
@@ -126,13 +102,13 @@ export default createRule<Options, MessageIds>({
 
     function getMemberModifiers(
       node:
+        | TSESTree.AccessorProperty
         | TSESTree.MethodDefinition
         | TSESTree.PropertyDefinition
+        | TSESTree.TSAbstractAccessorProperty
         | TSESTree.TSAbstractMethodDefinition
         | TSESTree.TSAbstractPropertyDefinition
-        | TSESTree.TSParameterProperty
-        | TSESTree.AccessorProperty
-        | TSESTree.TSAbstractAccessorProperty,
+        | TSESTree.TSParameterProperty,
     ): Set<Modifiers> {
       const modifiers = new Set<Modifiers>();
       if ('key' in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) {
@@ -225,17 +201,57 @@ export default createRule<Options, MessageIds>({
 
     const selectors: {
       readonly [k in keyof TSESLint.RuleListener]: Readonly<{
-        validator: ValidatorFunction;
         handler: (
           node: Parameters<NonNullable<TSESLint.RuleListener[k]>>[0],
           validator: ValidatorFunction,
         ) => void;
+        validator: ValidatorFunction;
       }>;
     } = {
       // #region import
 
+      'FunctionDeclaration, TSDeclareFunction, FunctionExpression': {
+        handler: (
+          node:
+            | TSESTree.FunctionDeclaration
+            | TSESTree.FunctionExpression
+            | TSESTree.TSDeclareFunction,
+          validator,
+        ): void => {
+          if (node.id == null) {
+            return;
+          }
+
+          const modifiers = new Set<Modifiers>();
+          // functions create their own nested scope
+          const scope = context.sourceCode.getScope(node).upper;
+
+          if (isGlobal(scope)) {
+            modifiers.add(Modifiers.global);
+          }
+
+          if (isExported(node, node.id.name, scope)) {
+            modifiers.add(Modifiers.exported);
+          }
+
+          if (isUnused(node.id.name, scope)) {
+            modifiers.add(Modifiers.unused);
+          }
+
+          if (node.async) {
+            modifiers.add(Modifiers.async);
+          }
+
+          validator(node.id, modifiers);
+        },
+        validator: validators.function,
+      },
+
+      // #endregion
+
+      // #region variable
+
       'ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier': {
-        validator: validators.import,
         handler: (
           node:
             | TSESTree.ImportDefaultSpecifier
@@ -263,14 +279,14 @@ export default createRule<Options, MessageIds>({
 
           validator(node.local, modifiers);
         },
+        validator: validators.import,
       },
 
       // #endregion
 
-      // #region variable
+      // #region function
 
       VariableDeclarator: {
-        validator: validators.variable,
         handler: (node, validator): void => {
           const identifiers = getIdentifiersFromPattern(node.id);
 
@@ -307,112 +323,32 @@ export default createRule<Options, MessageIds>({
             validator(id, modifiers);
           });
         },
-      },
-
-      // #endregion
-
-      // #region function
-
-      'FunctionDeclaration, TSDeclareFunction, FunctionExpression': {
-        validator: validators.function,
-        handler: (
-          node:
-            | TSESTree.FunctionDeclaration
-            | TSESTree.FunctionExpression
-            | TSESTree.TSDeclareFunction,
-          validator,
-        ): void => {
-          if (node.id == null) {
-            return;
-          }
-
-          const modifiers = new Set<Modifiers>();
-          // functions create their own nested scope
-          const scope = context.sourceCode.getScope(node).upper;
-
-          if (isGlobal(scope)) {
-            modifiers.add(Modifiers.global);
-          }
-
-          if (isExported(node, node.id.name, scope)) {
-            modifiers.add(Modifiers.exported);
-          }
-
-          if (isUnused(node.id.name, scope)) {
-            modifiers.add(Modifiers.unused);
-          }
-
-          if (node.async) {
-            modifiers.add(Modifiers.async);
-          }
-
-          validator(node.id, modifiers);
-        },
+        validator: validators.variable,
       },
 
       // #endregion function
 
       // #region parameter
-      'FunctionDeclaration, TSDeclareFunction, TSEmptyBodyFunctionExpression, FunctionExpression, ArrowFunctionExpression':
+      ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type != "ArrowFunctionExpression"][value.type != "FunctionExpression"][value.type != "TSEmptyBodyFunctionExpression"]':
         {
-          validator: validators.parameter,
           handler: (
             node:
-              | TSESTree.ArrowFunctionExpression
-              | TSESTree.FunctionDeclaration
-              | TSESTree.FunctionExpression
-              | TSESTree.TSDeclareFunction
-              | TSESTree.TSEmptyBodyFunctionExpression,
+              | TSESTree.PropertyDefinitionNonComputedName
+              | TSESTree.TSAbstractPropertyDefinitionNonComputedName,
             validator,
           ): void => {
-            node.params.forEach(param => {
-              if (param.type === AST_NODE_TYPES.TSParameterProperty) {
-                return;
-              }
-
-              const identifiers = getIdentifiersFromPattern(param);
-
-              identifiers.forEach(i => {
-                const modifiers = new Set<Modifiers>();
-
-                if (isDestructured(i)) {
-                  modifiers.add(Modifiers.destructured);
-                }
-
-                if (isUnused(i.name, context.sourceCode.getScope(i))) {
-                  modifiers.add(Modifiers.unused);
-                }
-
-                validator(i, modifiers);
-              });
-            });
+            const modifiers = getMemberModifiers(node);
+            handleMember(validator, node, modifiers);
           },
+          validator: validators.classProperty,
         },
 
       // #endregion parameter
 
       // #region parameterProperty
 
-      TSParameterProperty: {
-        validator: validators.parameterProperty,
-        handler: (node, validator): void => {
-          const modifiers = getMemberModifiers(node);
-
-          const identifiers = getIdentifiersFromPattern(node.parameter);
-
-          identifiers.forEach(i => {
-            validator(i, modifiers);
-          });
-        },
-      },
-
-      // #endregion parameterProperty
-
-      // #region property
-
       ':not(ObjectPattern) > Property[computed = false][kind = "init"][value.type != "ArrowFunctionExpression"][value.type != "FunctionExpression"][value.type != "TSEmptyBodyFunctionExpression"]':
         {
-          validator: validators.objectLiteralProperty,
           handler: (
             node: TSESTree.PropertyNonComputedName,
             validator,
@@ -420,55 +356,28 @@ export default createRule<Options, MessageIds>({
             const modifiers = new Set<Modifiers>([Modifiers.public]);
             handleMember(validator, node, modifiers);
           },
+          validator: validators.objectLiteralProperty,
         },
 
-      ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type != "ArrowFunctionExpression"][value.type != "FunctionExpression"][value.type != "TSEmptyBodyFunctionExpression"]':
-        {
-          validator: validators.classProperty,
-          handler: (
-            node:
-              | TSESTree.PropertyDefinitionNonComputedName
-              | TSESTree.TSAbstractPropertyDefinitionNonComputedName,
-            validator,
-          ): void => {
-            const modifiers = getMemberModifiers(node);
-            handleMember(validator, node, modifiers);
-          },
-        },
-
-      'TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != "TSFunctionType"]':
-        {
-          validator: validators.typeProperty,
-          handler: (
-            node: TSESTree.TSPropertySignatureNonComputedName,
-            validator,
-          ): void => {
-            const modifiers = new Set<Modifiers>([Modifiers.public]);
-            if (node.readonly) {
-              modifiers.add(Modifiers.readonly);
-            }
-
-            handleMember(validator, node, modifiers);
-          },
-        },
-
-      // #endregion property
+      // #endregion parameterProperty
 
-      // #region method
+      // #region property
 
       [[
-        'Property[computed = false][kind = "init"][value.type = "ArrowFunctionExpression"]',
-        'Property[computed = false][kind = "init"][value.type = "FunctionExpression"]',
-        'Property[computed = false][kind = "init"][value.type = "TSEmptyBodyFunctionExpression"]',
+        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "ArrowFunctionExpression"]',
+        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "FunctionExpression"]',
+        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "TSEmptyBodyFunctionExpression"]',
+        ':matches(MethodDefinition, TSAbstractMethodDefinition)[computed = false][kind = "method"]',
       ].join(', ')]: {
-        validator: validators.objectLiteralMethod,
         handler: (
           node:
-            | TSESTree.PropertyNonComputedName
-            | TSESTree.TSMethodSignatureNonComputedName,
+            | TSESTree.MethodDefinitionNonComputedName
+            | TSESTree.PropertyDefinitionNonComputedName
+            | TSESTree.TSAbstractMethodDefinitionNonComputedName
+            | TSESTree.TSAbstractPropertyDefinitionNonComputedName,
           validator,
         ): void => {
-          const modifiers = new Set<Modifiers>([Modifiers.public]);
+          const modifiers = getMemberModifiers(node);
 
           if (isAsyncMemberOrProperty(node)) {
             modifiers.add(Modifiers.async);
@@ -476,24 +385,35 @@ export default createRule<Options, MessageIds>({
 
           handleMember(validator, node, modifiers);
         },
+        validator: validators.classMethod,
       },
 
       [[
-        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "ArrowFunctionExpression"]',
-        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "FunctionExpression"]',
-        ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "TSEmptyBodyFunctionExpression"]',
-        ':matches(MethodDefinition, TSAbstractMethodDefinition)[computed = false][kind = "method"]',
+        'MethodDefinition[computed = false]:matches([kind = "get"], [kind = "set"])',
+        'TSAbstractMethodDefinition[computed = false]:matches([kind="get"], [kind="set"])',
       ].join(', ')]: {
-        validator: validators.classMethod,
         handler: (
-          node:
-            | TSESTree.MethodDefinitionNonComputedName
-            | TSESTree.PropertyDefinitionNonComputedName
-            | TSESTree.TSAbstractMethodDefinitionNonComputedName
-            | TSESTree.TSAbstractPropertyDefinitionNonComputedName,
+          node: TSESTree.MethodDefinitionNonComputedName,
           validator,
         ): void => {
           const modifiers = getMemberModifiers(node);
+          handleMember(validator, node, modifiers);
+        },
+        validator: validators.classicAccessor,
+      },
+
+      [[
+        'Property[computed = false][kind = "init"][value.type = "ArrowFunctionExpression"]',
+        'Property[computed = false][kind = "init"][value.type = "FunctionExpression"]',
+        'Property[computed = false][kind = "init"][value.type = "TSEmptyBodyFunctionExpression"]',
+      ].join(', ')]: {
+        handler: (
+          node:
+            | TSESTree.PropertyNonComputedName
+            | TSESTree.TSMethodSignatureNonComputedName,
+          validator,
+        ): void => {
+          const modifiers = new Set<Modifiers>([Modifiers.public]);
 
           if (isAsyncMemberOrProperty(node)) {
             modifiers.add(Modifiers.async);
@@ -501,13 +421,17 @@ export default createRule<Options, MessageIds>({
 
           handleMember(validator, node, modifiers);
         },
+        validator: validators.objectLiteralMethod,
       },
 
+      // #endregion property
+
+      // #region method
+
       [[
         'TSMethodSignature[computed = false]',
         'TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type = "TSFunctionType"]',
       ].join(', ')]: {
-        validator: validators.typeMethod,
         handler: (
           node:
             | TSESTree.TSMethodSignatureNonComputedName
@@ -517,80 +441,110 @@ export default createRule<Options, MessageIds>({
           const modifiers = new Set<Modifiers>([Modifiers.public]);
           handleMember(validator, node, modifiers);
         },
+        validator: validators.typeMethod,
       },
 
+      [[
+        AST_NODE_TYPES.AccessorProperty,
+        AST_NODE_TYPES.TSAbstractAccessorProperty,
+      ].join(', ')]: {
+        handler: (
+          node: TSESTree.AccessorPropertyNonComputedName,
+          validator,
+        ): void => {
+          const modifiers = getMemberModifiers(node);
+          handleMember(validator, node, modifiers);
+        },
+        validator: validators.autoAccessor,
+      },
+
+      'FunctionDeclaration, TSDeclareFunction, TSEmptyBodyFunctionExpression, FunctionExpression, ArrowFunctionExpression':
+        {
+          handler: (
+            node:
+              | TSESTree.ArrowFunctionExpression
+              | TSESTree.FunctionDeclaration
+              | TSESTree.FunctionExpression
+              | TSESTree.TSDeclareFunction
+              | TSESTree.TSEmptyBodyFunctionExpression,
+            validator,
+          ): void => {
+            node.params.forEach(param => {
+              if (param.type === AST_NODE_TYPES.TSParameterProperty) {
+                return;
+              }
+
+              const identifiers = getIdentifiersFromPattern(param);
+
+              identifiers.forEach(i => {
+                const modifiers = new Set<Modifiers>();
+
+                if (isDestructured(i)) {
+                  modifiers.add(Modifiers.destructured);
+                }
+
+                if (isUnused(i.name, context.sourceCode.getScope(i))) {
+                  modifiers.add(Modifiers.unused);
+                }
+
+                validator(i, modifiers);
+              });
+            });
+          },
+          validator: validators.parameter,
+        },
+
       // #endregion method
 
       // #region accessor
 
       'Property[computed = false]:matches([kind = "get"], [kind = "set"])': {
-        validator: validators.classicAccessor,
         handler: (node: TSESTree.PropertyNonComputedName, validator): void => {
           const modifiers = new Set<Modifiers>([Modifiers.public]);
           handleMember(validator, node, modifiers);
         },
+        validator: validators.classicAccessor,
       },
 
-      [[
-        'MethodDefinition[computed = false]:matches([kind = "get"], [kind = "set"])',
-        'TSAbstractMethodDefinition[computed = false]:matches([kind="get"], [kind="set"])',
-      ].join(', ')]: {
-        validator: validators.classicAccessor,
-        handler: (
-          node: TSESTree.MethodDefinitionNonComputedName,
-          validator,
-        ): void => {
+      TSParameterProperty: {
+        handler: (node, validator): void => {
           const modifiers = getMemberModifiers(node);
-          handleMember(validator, node, modifiers);
+
+          const identifiers = getIdentifiersFromPattern(node.parameter);
+
+          identifiers.forEach(i => {
+            validator(i, modifiers);
+          });
         },
+        validator: validators.parameterProperty,
       },
 
       // #endregion accessor
 
       // #region autoAccessor
 
-      [[
-        AST_NODE_TYPES.AccessorProperty,
-        AST_NODE_TYPES.TSAbstractAccessorProperty,
-      ].join(', ')]: {
-        validator: validators.autoAccessor,
-        handler: (
-          node: TSESTree.AccessorPropertyNonComputedName,
-          validator,
-        ): void => {
-          const modifiers = getMemberModifiers(node);
-          handleMember(validator, node, modifiers);
+      'TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != "TSFunctionType"]':
+        {
+          handler: (
+            node: TSESTree.TSPropertySignatureNonComputedName,
+            validator,
+          ): void => {
+            const modifiers = new Set<Modifiers>([Modifiers.public]);
+            if (node.readonly) {
+              modifiers.add(Modifiers.readonly);
+            }
+
+            handleMember(validator, node, modifiers);
+          },
+          validator: validators.typeProperty,
         },
-      },
 
       // #endregion autoAccessor
 
       // #region enumMember
 
       // computed is optional, so can't do [computed = false]
-      'TSEnumMember[computed != true]': {
-        validator: validators.enumMember,
-        handler: (
-          node: TSESTree.TSEnumMemberNonComputedName,
-          validator,
-        ): void => {
-          const id = node.id;
-          const modifiers = new Set<Modifiers>();
-
-          if (requiresQuoting(id, compilerOptions.target)) {
-            modifiers.add(Modifiers.requiresQuotes);
-          }
-
-          validator(id, modifiers);
-        },
-      },
-
-      // #endregion enumMember
-
-      // #region class
-
       'ClassDeclaration, ClassExpression': {
-        validator: validators.class,
         handler: (
           node: TSESTree.ClassDeclaration | TSESTree.ClassExpression,
           validator,
@@ -618,17 +572,18 @@ export default createRule<Options, MessageIds>({
 
           validator(id, modifiers);
         },
+        validator: validators.class,
       },
 
-      // #endregion class
+      // #endregion enumMember
 
-      // #region interface
+      // #region class
 
-      TSInterfaceDeclaration: {
-        validator: validators.interface,
+      TSEnumDeclaration: {
         handler: (node, validator): void => {
           const modifiers = new Set<Modifiers>();
-          const scope = context.sourceCode.getScope(node);
+          // enums create their own nested scope
+          const scope = context.sourceCode.getScope(node).upper;
 
           if (isExported(node, node.id.name, scope)) {
             modifiers.add(Modifiers.exported);
@@ -640,14 +595,35 @@ export default createRule<Options, MessageIds>({
 
           validator(node.id, modifiers);
         },
+        validator: validators.enum,
+      },
+
+      // #endregion class
+
+      // #region interface
+
+      'TSEnumMember[computed != true]': {
+        handler: (
+          node: TSESTree.TSEnumMemberNonComputedName,
+          validator,
+        ): void => {
+          const id = node.id;
+          const modifiers = new Set<Modifiers>();
+
+          if (requiresQuoting(id, compilerOptions.target)) {
+            modifiers.add(Modifiers.requiresQuotes);
+          }
+
+          validator(id, modifiers);
+        },
+        validator: validators.enumMember,
       },
 
       // #endregion interface
 
       // #region typeAlias
 
-      TSTypeAliasDeclaration: {
-        validator: validators.typeAlias,
+      TSInterfaceDeclaration: {
         handler: (node, validator): void => {
           const modifiers = new Set<Modifiers>();
           const scope = context.sourceCode.getScope(node);
@@ -662,18 +638,17 @@ export default createRule<Options, MessageIds>({
 
           validator(node.id, modifiers);
         },
+        validator: validators.interface,
       },
 
       // #endregion typeAlias
 
       // #region enum
 
-      TSEnumDeclaration: {
-        validator: validators.enum,
+      TSTypeAliasDeclaration: {
         handler: (node, validator): void => {
           const modifiers = new Set<Modifiers>();
-          // enums create their own nested scope
-          const scope = context.sourceCode.getScope(node).upper;
+          const scope = context.sourceCode.getScope(node);
 
           if (isExported(node, node.id.name, scope)) {
             modifiers.add(Modifiers.exported);
@@ -685,6 +660,7 @@ export default createRule<Options, MessageIds>({
 
           validator(node.id, modifiers);
         },
+        validator: validators.typeAlias,
       },
 
       // #endregion enum
@@ -692,7 +668,6 @@ export default createRule<Options, MessageIds>({
       // #region typeParameter
 
       'TSTypeParameterDeclaration > TSTypeParameter': {
-        validator: validators.typeParameter,
         handler: (node: TSESTree.TSTypeParameter, validator): void => {
           const modifiers = new Set<Modifiers>();
           const scope = context.sourceCode.getScope(node);
@@ -703,13 +678,14 @@ export default createRule<Options, MessageIds>({
 
           validator(node.name, modifiers);
         },
+        validator: validators.typeParameter,
       },
 
       // #endregion typeParameter
     };
 
     return Object.fromEntries(
-      Object.entries(selectors).map(([selector, { validator, handler }]) => {
+      Object.entries(selectors).map(([selector, { handler, validator }]) => {
         return [
           selector,
           (node: Parameters<typeof handler>[0]): void => {
@@ -719,6 +695,32 @@ export default createRule<Options, MessageIds>({
       }),
     );
   },
+  defaultOptions: defaultCamelCaseAllTheThingsConfig,
+  meta: {
+    docs: {
+      description:
+        'Enforce naming conventions for everything across a codebase',
+      // technically only requires type checking if the user uses "type" modifiers
+      requiresTypeChecking: true,
+    },
+    messages: {
+      doesNotMatchFormat:
+        '{{type}} name `{{name}}` must match one of the following formats: {{formats}}',
+      doesNotMatchFormatTrimmed:
+        '{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}',
+      missingAffix:
+        '{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}',
+      missingUnderscore:
+        '{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).',
+      satisfyCustom:
+        '{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}',
+      unexpectedUnderscore:
+        '{{type}} name `{{name}}` must not have a {{position}} underscore.',
+    },
+    schema: SCHEMA,
+    type: 'suggestion',
+  },
+  name: 'naming-convention',
 });
 
 function getIdentifiersFromPattern(
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index b164e5713e6d..361928021fee 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -1,24 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isOptionalCallExpression } from '../util';
 
 export default createRule({
-  name: 'no-array-constructor',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow generic `Array` constructors',
-      recommended: 'recommended',
-      extendsBaseRule: true,
-    },
-    fixable: 'code',
-    messages: {
-      useLiteral: 'The array literal notation [] is preferable.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     /**
      * Disallow construction of dense arrays using the Array constructor
@@ -35,8 +21,6 @@ export default createRule({
         !isOptionalCallExpression(node)
       ) {
         context.report({
-          node,
-          messageId: 'useLiteral',
           fix(fixer) {
             if (node.arguments.length === 0) {
               return fixer.replaceText(node, '[]');
@@ -49,6 +33,8 @@ export default createRule({
               `[${fullText.slice(preambleLength + 1, -1)}]`,
             );
           },
+          messageId: 'useLiteral',
+          node,
         });
       }
     }
@@ -58,4 +44,19 @@ export default createRule({
       NewExpression: check,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow generic `Array` constructors',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      useLiteral: 'The array literal notation [] is preferable.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-array-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index 9b6230ebf821..161081c56933 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -1,7 +1,8 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import type * as ts from 'typescript';
 
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+
 import {
   createRule,
   getConstrainedTypeAtLocation,
@@ -11,23 +12,6 @@ import {
 type MessageId = 'noArrayDelete' | 'useSplice';
 
 export default createRule<[], MessageId>({
-  name: 'no-array-delete',
-  meta: {
-    hasSuggestions: true,
-    type: 'problem',
-    docs: {
-      description: 'Disallow using the `delete` operator on array values',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      noArrayDelete:
-        'Using the `delete` operator with an array expression is unsafe.',
-      useSplice: 'Use `array.splice()` instead.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -64,11 +48,10 @@ export default createRule<[], MessageId>({
         }
 
         context.report({
-          node,
           messageId: 'noArrayDelete',
+          node,
           suggest: [
             {
-              messageId: 'useSplice',
               fix(fixer): TSESLint.RuleFix | null {
                 const { object, property } = argument;
 
@@ -101,10 +84,28 @@ export default createRule<[], MessageId>({
 
                 return fixer.replaceText(node, suggestion);
               },
+              messageId: 'useSplice',
             },
           ],
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow using the `delete` operator on array values',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      noArrayDelete:
+        'Using the `delete` operator with an array expression is unsafe.',
+      useSplice: 'Use `array.splice()` instead.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-array-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index 0369e66fe66f..ed2f85fd008f 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -18,39 +19,6 @@ type Options = [
 type MessageIds = 'baseToString';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-base-to-string',
-  meta: {
-    docs: {
-      description:
-        'Require `.toString()` to only be called on objects which provide useful information when stringified',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      baseToString:
-        "'{{name}}' {{certainty}} use Object's default stringification format ('[object Object]') when stringified.",
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoredTypeNames: {
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    type: 'suggestion',
-  },
-  defaultOptions: [
-    {
-      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
-    },
-  ],
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -180,4 +148,37 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require `.toString()` to only be called on objects which provide useful information when stringified',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      baseToString:
+        "'{{name}}' {{certainty}} use Object's default stringification format ('[object Object]') when stringified.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoredTypeNames: {
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-base-to-string',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index 9caf777aabad..7e16276795c7 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -1,32 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-confusing-non-null-assertion',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow non-null assertion in locations that may be confusing',
-      recommended: 'stylistic',
-    },
-    hasSuggestions: true,
-    messages: {
-      confusingEqual:
-        'Confusing combinations of non-null assertion and equal test like "a! == b", which looks very similar to not equal "a !== b".',
-      confusingAssign:
-        'Confusing combinations of non-null assertion and equal test like "a! = b", which looks very similar to not equal "a != b".',
-      notNeedInEqualTest: 'Unnecessary non-null assertion (!) in equal test.',
-      notNeedInAssign:
-        'Unnecessary non-null assertion (!) in assignment left hand.',
-      wrapUpLeft:
-        'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       'BinaryExpression, AssignmentExpression'(
@@ -53,30 +31,30 @@ export default createRule({
           ) {
             if (isLeftHandPrimaryExpression(node.left)) {
               context.report({
-                node,
                 messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
+                node,
                 suggest: [
                   {
-                    messageId: isAssign
-                      ? 'notNeedInAssign'
-                      : 'notNeedInEqualTest',
                     fix: (fixer): TSESLint.RuleFix[] => [
                       fixer.remove(leftHandFinalToken),
                     ],
+                    messageId: isAssign
+                      ? 'notNeedInAssign'
+                      : 'notNeedInEqualTest',
                   },
                 ],
               });
             } else {
               context.report({
-                node,
                 messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
+                node,
                 suggest: [
                   {
-                    messageId: 'wrapUpLeft',
                     fix: (fixer): TSESLint.RuleFix[] => [
                       fixer.insertTextBefore(node.left, '('),
                       fixer.insertTextAfter(node.left, ')'),
                     ],
+                    messageId: 'wrapUpLeft',
                   },
                 ],
               });
@@ -86,4 +64,27 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow non-null assertion in locations that may be confusing',
+      recommended: 'stylistic',
+    },
+    hasSuggestions: true,
+    messages: {
+      confusingAssign:
+        'Confusing combinations of non-null assertion and equal test like "a! = b", which looks very similar to not equal "a != b".',
+      confusingEqual:
+        'Confusing combinations of non-null assertion and equal test like "a! == b", which looks very similar to not equal "a !== b".',
+      notNeedInAssign:
+        'Unnecessary non-null assertion (!) in assignment left hand.',
+      notNeedInEqualTest: 'Unnecessary non-null assertion (!) in equal test.',
+      wrapUpLeft:
+        'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-confusing-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 38df4fb0dc44..a4fa1f6af727 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -1,9 +1,11 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
 import type { MakeRequired } from '../util';
+
 import {
   createRule,
   getConstrainedTypeAtLocation,
@@ -33,55 +35,6 @@ export type MessageId =
   | 'voidExprWrapVoid';
 
 export default createRule<Options, MessageId>({
-  name: 'no-confusing-void-expression',
-  meta: {
-    docs: {
-      description:
-        'Require expressions of type void to appear in statement position',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      invalidVoidExpr:
-        'Placing a void expression inside another expression is forbidden. ' +
-        'Move it to its own statement instead.',
-      invalidVoidExprWrapVoid:
-        'Void expressions used inside another expression ' +
-        'must be moved to its own statement ' +
-        'or marked explicitly with the `void` operator.',
-      invalidVoidExprArrow:
-        'Returning a void expression from an arrow function shorthand is forbidden. ' +
-        'Please add braces to the arrow function.',
-      invalidVoidExprArrowWrapVoid:
-        'Void expressions returned from an arrow function shorthand ' +
-        'must be marked explicitly with the `void` operator.',
-      invalidVoidExprReturn:
-        'Returning a void expression from a function is forbidden. ' +
-        'Please move it before the `return` statement.',
-      invalidVoidExprReturnLast:
-        'Returning a void expression from a function is forbidden. ' +
-        'Please remove the `return` statement.',
-      invalidVoidExprReturnWrapVoid:
-        'Void expressions returned from a function ' +
-        'must be marked explicitly with the `void` operator.',
-      voidExprWrapVoid: 'Mark with an explicit `void` operator.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreArrowShorthand: { type: 'boolean' },
-          ignoreVoidOperator: { type: 'boolean' },
-        },
-        additionalProperties: false,
-      },
-    ],
-    type: 'problem',
-    fixable: 'code',
-    hasSuggestions: true,
-  },
-  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
-
   create(context, [options]) {
     return {
       'AwaitExpression, CallExpression, TaggedTemplateExpression'(
@@ -115,17 +68,15 @@ export default createRule<Options, MessageId>({
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
-              node,
-              messageId: 'invalidVoidExprArrowWrapVoid',
               fix: wrapVoidFix,
+              messageId: 'invalidVoidExprArrowWrapVoid',
+              node,
             });
           }
 
           // handle wrapping with braces
           const arrowFunction = invalidAncestor;
           return context.report({
-            node,
-            messageId: 'invalidVoidExprArrow',
             fix(fixer) {
               if (!canFix(arrowFunction)) {
                 return null;
@@ -161,6 +112,8 @@ export default createRule<Options, MessageId>({
               }
               return fixer.replaceText(arrowBody, newArrowBodyText);
             },
+            messageId: 'invalidVoidExprArrow',
+            node,
           });
         }
 
@@ -170,17 +123,15 @@ export default createRule<Options, MessageId>({
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
-              node,
-              messageId: 'invalidVoidExprReturnWrapVoid',
               fix: wrapVoidFix,
+              messageId: 'invalidVoidExprReturnWrapVoid',
+              node,
             });
           }
 
           if (isFinalReturn(invalidAncestor)) {
             // remove the `return` keyword
             return context.report({
-              node,
-              messageId: 'invalidVoidExprReturnLast',
               fix(fixer) {
                 if (!canFix(invalidAncestor)) {
                   return null;
@@ -194,13 +145,13 @@ export default createRule<Options, MessageId>({
                 }
                 return fixer.replaceText(invalidAncestor, newReturnStmtText);
               },
+              messageId: 'invalidVoidExprReturnLast',
+              node,
             });
           }
 
           // move before the `return` keyword
           return context.report({
-            node,
-            messageId: 'invalidVoidExprReturn',
             fix(fixer) {
               const returnValue = invalidAncestor.argument;
               const returnValueText = context.sourceCode.getText(returnValue);
@@ -218,6 +169,8 @@ export default createRule<Options, MessageId>({
               }
               return fixer.replaceText(invalidAncestor, newReturnStmtText);
             },
+            messageId: 'invalidVoidExprReturn',
+            node,
           });
         }
 
@@ -225,15 +178,15 @@ export default createRule<Options, MessageId>({
         if (options.ignoreVoidOperator) {
           // this would be reported by this rule btw. such irony
           return context.report({
-            node,
             messageId: 'invalidVoidExprWrapVoid',
-            suggest: [{ messageId: 'voidExprWrapVoid', fix: wrapVoidFix }],
+            node,
+            suggest: [{ fix: wrapVoidFix, messageId: 'voidExprWrapVoid' }],
           });
         }
 
         context.report({
-          node,
           messageId: 'invalidVoidExpr',
+          node,
         });
       },
     };
@@ -329,9 +282,9 @@ export default createRule<Options, MessageId>({
       );
       if (
         ![
+          AST_NODE_TYPES.ArrowFunctionExpression,
           AST_NODE_TYPES.FunctionDeclaration,
           AST_NODE_TYPES.FunctionExpression,
-          AST_NODE_TYPES.ArrowFunctionExpression,
         ].includes(blockParent.type)
       ) {
         // e.g. `if (cond) { return; }`
@@ -377,4 +330,53 @@ export default createRule<Options, MessageId>({
       return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
     }
   },
+  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
+  meta: {
+    docs: {
+      description:
+        'Require expressions of type void to appear in statement position',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      invalidVoidExpr:
+        'Placing a void expression inside another expression is forbidden. ' +
+        'Move it to its own statement instead.',
+      invalidVoidExprArrow:
+        'Returning a void expression from an arrow function shorthand is forbidden. ' +
+        'Please add braces to the arrow function.',
+      invalidVoidExprArrowWrapVoid:
+        'Void expressions returned from an arrow function shorthand ' +
+        'must be marked explicitly with the `void` operator.',
+      invalidVoidExprReturn:
+        'Returning a void expression from a function is forbidden. ' +
+        'Please move it before the `return` statement.',
+      invalidVoidExprReturnLast:
+        'Returning a void expression from a function is forbidden. ' +
+        'Please remove the `return` statement.',
+      invalidVoidExprReturnWrapVoid:
+        'Void expressions returned from a function ' +
+        'must be marked explicitly with the `void` operator.',
+      invalidVoidExprWrapVoid:
+        'Void expressions used inside another expression ' +
+        'must be moved to its own statement ' +
+        'or marked explicitly with the `void` operator.',
+      voidExprWrapVoid: 'Mark with an explicit `void` operator.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreArrowShorthand: { type: 'boolean' },
+          ignoreVoidOperator: { type: 'boolean' },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+
+  name: 'no-confusing-void-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
index 08dd0b35d3b8..a0d9c8e29eab 100644
--- a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
+++ b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
@@ -1,10 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -14,18 +16,6 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-dupe-class-members',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow duplicate class members',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
 
@@ -55,4 +45,16 @@ export default createRule<Options, MessageIds>({
       ),
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow duplicate class members',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'problem',
+  },
+  name: 'no-dupe-class-members',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index d8ac6586666d..e89f8d66256f 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -1,23 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-duplicate-enum-values',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow duplicate enum member values',
-      recommended: 'recommended',
-    },
-    hasSuggestions: false,
-    messages: {
-      duplicateValue: 'Duplicate enum member value {{value}}.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function isStringLiteral(
       node: TSESTree.Expression,
@@ -58,11 +45,11 @@ export default createRule({
 
           if (seenValues.has(value)) {
             context.report({
-              node: member,
-              messageId: 'duplicateValue',
               data: {
                 value,
               },
+              messageId: 'duplicateValue',
+              node: member,
             });
           } else {
             seenValues.add(value);
@@ -71,4 +58,18 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow duplicate enum member values',
+      recommended: 'recommended',
+    },
+    hasSuggestions: false,
+    messages: {
+      duplicateValue: 'Duplicate enum member value {{value}}.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-duplicate-enum-values',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index d92de657aa47..65eb54471664 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type { Type } from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type { Type } from 'typescript';
 
 import { createRule, getParserServices } from '../util';
 
@@ -67,40 +68,6 @@ const isSameAstNode = (actualNode: unknown, expectedNode: unknown): boolean => {
 };
 
 export default createRule<Options, MessageIds>({
-  name: 'no-duplicate-type-constituents',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow duplicate constituents of union or intersection types',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        type: 'object',
-        properties: {
-          ignoreIntersections: {
-            type: 'boolean',
-          },
-          ignoreUnions: {
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      ignoreIntersections: false,
-      ignoreUnions: false,
-    },
-  ],
   create(context, [{ ignoreIntersections, ignoreUnions }]) {
     const parserServices = getParserServices(context);
 
@@ -169,25 +136,22 @@ export default createRule<Options, MessageIds>({
         { count: bracketBeforeTokens.length },
       );
       const reportLocation: TSESTree.SourceLocation = {
-        start: duplicateConstituent.duplicated.loc.start,
         end:
           bracketAfterTokens.length > 0
             ? bracketAfterTokens[bracketAfterTokens.length - 1].loc.end
             : duplicateConstituent.duplicated.loc.end,
+        start: duplicateConstituent.duplicated.loc.start,
       };
       context.report({
         data: {
+          previous: context.sourceCode.getText(
+            duplicateConstituent.duplicatePrevious,
+          ),
           type:
             parentNode.type === AST_NODE_TYPES.TSIntersectionType
               ? 'Intersection'
               : 'Union',
-          previous: context.sourceCode.getText(
-            duplicateConstituent.duplicatePrevious,
-          ),
         },
-        messageId: 'duplicate',
-        node: duplicateConstituent.duplicated,
-        loc: reportLocation,
         fix: fixer => {
           return [
             beforeUnionOrIntersectionToken,
@@ -196,6 +160,9 @@ export default createRule<Options, MessageIds>({
             ...bracketAfterTokens,
           ].map(token => fixer.remove(token));
         },
+        loc: reportLocation,
+        messageId: 'duplicate',
+        node: duplicateConstituent.duplicated,
       });
     }
     return {
@@ -207,4 +174,38 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
+  defaultOptions: [
+    {
+      ignoreIntersections: false,
+      ignoreUnions: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow duplicate constituents of union or intersection types',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreIntersections: {
+            type: 'boolean',
+          },
+          ignoreUnions: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-duplicate-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index fb487fa6b7fc..d0da569f7f7e 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -1,24 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
 
 export default createRule({
-  name: 'no-dynamic-delete',
-  meta: {
-    docs: {
-      description:
-        'Disallow using the `delete` operator on computed key expressions',
-      recommended: 'strict',
-    },
-    fixable: 'code',
-    messages: {
-      dynamicDelete: 'Do not delete dynamically computed property keys.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     function createFixer(
       member: TSESTree.MemberExpression,
@@ -75,12 +61,27 @@ export default createRule({
       ];
     }
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow using the `delete` operator on computed key expressions',
+      recommended: 'strict',
+    },
+    fixable: 'code',
+    messages: {
+      dynamicDelete: 'Do not delete dynamically computed property keys.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-dynamic-delete',
 });
 
 function isAcceptableIndexExpression(property: TSESTree.Expression): boolean {
   return (
     (property.type === AST_NODE_TYPES.Literal &&
-      ['string', 'number'].includes(typeof property.value)) ||
+      ['number', 'string'].includes(typeof property.value)) ||
     (property.type === AST_NODE_TYPES.UnaryExpression &&
       property.operator === '-' &&
       property.argument.type === AST_NODE_TYPES.Literal &&
diff --git a/packages/eslint-plugin/src/rules/no-empty-function.ts b/packages/eslint-plugin/src/rules/no-empty-function.ts
index 6a8e90ebaf13..cb3ecae32597 100644
--- a/packages/eslint-plugin/src/rules/no-empty-function.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-function.ts
@@ -1,11 +1,13 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule, deepMerge } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -23,7 +25,6 @@ const schema = deepMerge(
     properties: {
       allow: {
         items: {
-          type: 'string',
           enum: [
             'functions',
             'arrowFunctions',
@@ -40,6 +41,7 @@ const schema = deepMerge(
             'decoratedFunctions',
             'overrideMethods',
           ],
+          type: 'string',
         },
       },
     },
@@ -47,23 +49,6 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-empty-function',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow empty functions',
-      recommended: 'stylistic',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: [schema],
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [
-    {
-      allow: [],
-    },
-  ],
   create(context, [{ allow = [] }]) {
     const rules = baseRule.create(context);
 
@@ -174,4 +159,21 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allow: [],
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow empty functions',
+      extendsBaseRule: true,
+      recommended: 'stylistic',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [schema],
+    type: 'suggestion',
+  },
+  name: 'no-empty-function',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index 03d00c1a9535..a31d2fb853bf 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -1,5 +1,6 @@
-import { ScopeType } from '@typescript-eslint/scope-manager';
 import type { TSESLint } from '@typescript-eslint/utils';
+
+import { ScopeType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isDefinitionFile } from '../util';
@@ -12,38 +13,6 @@ type Options = [
 type MessageIds = 'noEmpty' | 'noEmptyWithSuper';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-empty-interface',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow the declaration of empty interfaces',
-    },
-    deprecated: true,
-    replacedBy: ['@typescript-eslint/no-empty-object-type'],
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      noEmpty: 'An empty interface is equivalent to `{}`.',
-      noEmptyWithSuper:
-        'An interface declaring no members is equivalent to its supertype.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allowSingleExtends: {
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowSingleExtends: false,
-    },
-  ],
   create(context, [{ allowSingleExtends }]) {
     return {
       TSInterfaceDeclaration(node): void {
@@ -55,8 +24,8 @@ export default createRule<Options, MessageIds>({
         const extend = node.extends;
         if (extend.length === 0) {
           context.report({
-            node: node.id,
             messageId: 'noEmpty',
+            node: node.id,
           });
         } else if (extend.length === 1) {
           // interface extends exactly 1 interface --> Report depending on rule setting
@@ -92,16 +61,16 @@ export default createRule<Options, MessageIds>({
             );
 
             context.report({
-              node: node.id,
               messageId: 'noEmptyWithSuper',
+              node: node.id,
               ...(useAutoFix
                 ? { fix }
                 : !mergedWithClassDeclaration
                   ? {
                       suggest: [
                         {
-                          messageId: 'noEmptyWithSuper',
                           fix,
+                          messageId: 'noEmptyWithSuper',
                         },
                       ],
                     }
@@ -112,4 +81,36 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowSingleExtends: false,
+    },
+  ],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: 'Disallow the declaration of empty interfaces',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      noEmpty: 'An empty interface is equivalent to `{}`.',
+      noEmptyWithSuper:
+        'An interface declaring no members is equivalent to its supertype.',
+    },
+    replacedBy: ['@typescript-eslint/no-empty-object-type'],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowSingleExtends: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-empty-interface',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index 2471726240b8..f89b603c0629 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -1,4 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -17,8 +18,8 @@ export type Options = [
 
 export type MessageIds =
   | 'noEmptyInterface'
-  | 'noEmptyObject'
   | 'noEmptyInterfaceWithSuper'
+  | 'noEmptyObject'
   | 'replaceEmptyInterface'
   | 'replaceEmptyInterfaceWithSuper'
   | 'replaceEmptyObjectType';
@@ -32,51 +33,7 @@ const noEmptyMessage = (emptyType: string): string =>
   ].join('\n');
 
 export default createRule<Options, MessageIds>({
-  name: 'no-empty-object-type',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow accidentally using the "empty object" type',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      noEmptyInterface: noEmptyMessage('An empty interface declaration'),
-      noEmptyObject: noEmptyMessage('The `{}` ("empty object") type'),
-      noEmptyInterfaceWithSuper:
-        'An interface declaring no members is equivalent to its supertype.',
-      replaceEmptyInterface: 'Replace empty interface with `{{replacement}}`.',
-      replaceEmptyInterfaceWithSuper:
-        'Replace empty interface with a type alias.',
-      replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allowInterfaces: {
-            enum: ['always', 'never', 'with-single-extends'],
-            type: 'string',
-          },
-          allowObjectTypes: {
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-          allowWithName: {
-            type: 'string',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowInterfaces: 'never',
-      allowObjectTypes: 'never',
-    },
-  ],
-  create(context, [{ allowInterfaces, allowWithName, allowObjectTypes }]) {
+  create(context, [{ allowInterfaces, allowObjectTypes, allowWithName }]) {
     const allowWithNameTester = allowWithName
       ? new RegExp(allowWithName, 'u')
       : undefined;
@@ -109,8 +66,8 @@ export default createRule<Options, MessageIds>({
           if (extend.length === 0) {
             context.report({
               data: { option: 'allowInterfaces' },
-              node: node.id,
               messageId: 'noEmptyInterface',
+              node: node.id,
               ...(!mergedWithClassDeclaration && {
                 suggest: ['object', 'unknown'].map(replacement => ({
                   data: { replacement },
@@ -133,8 +90,8 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node: node.id,
             messageId: 'noEmptyInterfaceWithSuper',
+            node: node.id,
             ...(!mergedWithClassDeclaration && {
               suggest: [
                 {
@@ -175,13 +132,57 @@ export default createRule<Options, MessageIds>({
             node,
             suggest: ['object', 'unknown'].map(replacement => ({
               data: { replacement },
-              messageId: 'replaceEmptyObjectType',
               fix: (fixer): TSESLint.RuleFix =>
                 fixer.replaceText(node, replacement),
+              messageId: 'replaceEmptyObjectType',
             })),
           });
         },
       }),
     };
   },
+  defaultOptions: [
+    {
+      allowInterfaces: 'never',
+      allowObjectTypes: 'never',
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow accidentally using the "empty object" type',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      noEmptyInterface: noEmptyMessage('An empty interface declaration'),
+      noEmptyInterfaceWithSuper:
+        'An interface declaring no members is equivalent to its supertype.',
+      noEmptyObject: noEmptyMessage('The `{}` ("empty object") type'),
+      replaceEmptyInterface: 'Replace empty interface with `{{replacement}}`.',
+      replaceEmptyInterfaceWithSuper:
+        'Replace empty interface with a type alias.',
+      replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowInterfaces: {
+            enum: ['always', 'never', 'with-single-extends'],
+            type: 'string',
+          },
+          allowObjectTypes: {
+            enum: ['always', 'never'],
+            type: 'string',
+          },
+          allowWithName: {
+            type: 'string',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-empty-object-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index 923750847365..a945e69aefb3 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -12,47 +13,7 @@ export type Options = [
 export type MessageIds = 'suggestNever' | 'suggestUnknown' | 'unexpectedAny';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-explicit-any',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow the `any` type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      unexpectedAny: 'Unexpected any. Specify a different type.',
-      suggestUnknown:
-        'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.',
-      suggestNever:
-        "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.",
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          fixToUnknown: {
-            description:
-              'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
-            type: 'boolean',
-          },
-          ignoreRestArgs: {
-            description: 'Whether to ignore rest parameter arrays.',
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      fixToUnknown: false,
-      ignoreRestArgs: false,
-    },
-  ],
-  create(context, [{ ignoreRestArgs, fixToUnknown }]) {
+  create(context, [{ fixToUnknown, ignoreRestArgs }]) {
     /**
      * Checks if the node is an arrow function, function/constructor declaration or function expression
      * @param node the node to be validated.
@@ -64,13 +25,13 @@ export default createRule<Options, MessageIds>({
         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.TSConstructorType, // type T = new (...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;
+        AST_NODE_TYPES.TSEmptyBodyFunctionExpression, // declare class A { f(...args: any[]): unknown; }
+        AST_NODE_TYPES.TSFunctionType, // type T = (...args: any[]) => unknown;
+        AST_NODE_TYPES.TSMethodSignature, // type T = {f(...args: any[]): unknown};
       ].includes(node.type);
     }
 
@@ -182,16 +143,16 @@ export default createRule<Options, MessageIds>({
           fix: null,
           suggest: [
             {
-              messageId: 'suggestUnknown',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.replaceText(node, 'unknown');
               },
+              messageId: 'suggestUnknown',
             },
             {
-              messageId: 'suggestNever',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.replaceText(node, 'never');
               },
+              messageId: 'suggestNever',
             },
           ],
         };
@@ -202,11 +163,51 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node,
           messageId: 'unexpectedAny',
+          node,
           ...fixOrSuggest,
         });
       },
     };
   },
+  defaultOptions: [
+    {
+      fixToUnknown: false,
+      ignoreRestArgs: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow the `any` type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      suggestNever:
+        "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.",
+      suggestUnknown:
+        'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.',
+      unexpectedAny: 'Unexpected any. Specify a different type.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          fixToUnknown: {
+            description:
+              'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
+            type: 'boolean',
+          },
+          ignoreRestArgs: {
+            description: 'Whether to ignore rest parameter arrays.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-explicit-any',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index ee1858fe7d95..6b9edf3b67fa 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -3,39 +3,39 @@ import type { TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-extra-non-null-assertion',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow extra non-null assertions',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
-    },
-  },
-  defaultOptions: [],
   create(context) {
     function checkExtraNonNullAssertion(
       node: TSESTree.TSNonNullExpression,
     ): void {
       context.report({
-        node,
-        messageId: 'noExtraNonNullAssertion',
         fix(fixer) {
           return fixer.removeRange([node.range[1] - 1, node.range[1]]);
         },
+        messageId: 'noExtraNonNullAssertion',
+        node,
       });
     }
 
     return {
-      'TSNonNullExpression > TSNonNullExpression': checkExtraNonNullAssertion,
-      'MemberExpression[optional = true] > TSNonNullExpression.object':
-        checkExtraNonNullAssertion,
       'CallExpression[optional = true] > TSNonNullExpression.callee':
         checkExtraNonNullAssertion,
+      'MemberExpression[optional = true] > TSNonNullExpression.object':
+        checkExtraNonNullAssertion,
+      'TSNonNullExpression > TSNonNullExpression': checkExtraNonNullAssertion,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow extra non-null assertions',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-extra-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 854cec6b40eb..18043abb9833 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -14,55 +15,6 @@ type Options = [
 type MessageIds = 'empty' | 'onlyConstructor' | 'onlyStatic';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-extraneous-class',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow classes used as namespaces',
-      recommended: 'strict',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allowConstructorOnly: {
-            description:
-              'Whether to allow extraneous classes that contain only a constructor.',
-            type: 'boolean',
-          },
-          allowEmpty: {
-            description:
-              'Whether to allow extraneous classes that have no body (i.e. are empty).',
-            type: 'boolean',
-          },
-          allowStaticOnly: {
-            description:
-              'Whether to allow extraneous classes that only contain static members.',
-            type: 'boolean',
-          },
-          allowWithDecorator: {
-            description:
-              'Whether to allow extraneous classes that include a decorator.',
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-    messages: {
-      empty: 'Unexpected empty class.',
-      onlyStatic: 'Unexpected class with only static properties.',
-      onlyConstructor: 'Unexpected class with only a constructor.',
-    },
-  },
-  defaultOptions: [
-    {
-      allowConstructorOnly: false,
-      allowEmpty: false,
-      allowStaticOnly: false,
-      allowWithDecorator: false,
-    },
-  ],
   create(
     context,
     [{ allowConstructorOnly, allowEmpty, allowStaticOnly, allowWithDecorator }],
@@ -95,8 +47,8 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node: reportNode,
             messageId: 'empty',
+            node: reportNode,
           });
 
           return;
@@ -138,19 +90,68 @@ export default createRule<Options, MessageIds>({
         if (onlyConstructor) {
           if (!allowConstructorOnly) {
             context.report({
-              node: reportNode,
               messageId: 'onlyConstructor',
+              node: reportNode,
             });
           }
           return;
         }
         if (onlyStatic && !allowStaticOnly) {
           context.report({
-            node: reportNode,
             messageId: 'onlyStatic',
+            node: reportNode,
           });
         }
       },
     };
   },
+  defaultOptions: [
+    {
+      allowConstructorOnly: false,
+      allowEmpty: false,
+      allowStaticOnly: false,
+      allowWithDecorator: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow classes used as namespaces',
+      recommended: 'strict',
+    },
+    messages: {
+      empty: 'Unexpected empty class.',
+      onlyConstructor: 'Unexpected class with only a constructor.',
+      onlyStatic: 'Unexpected class with only static properties.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowConstructorOnly: {
+            description:
+              'Whether to allow extraneous classes that contain only a constructor.',
+            type: 'boolean',
+          },
+          allowEmpty: {
+            description:
+              'Whether to allow extraneous classes that have no body (i.e. are empty).',
+            type: 'boolean',
+          },
+          allowStaticOnly: {
+            description:
+              'Whether to allow extraneous classes that only contain static members.',
+            type: 'boolean',
+          },
+          allowWithDecorator: {
+            description:
+              'Whether to allow extraneous classes that include a decorator.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-extraneous-class',
 });
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index e59c32665427..746d6aa740ea 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -1,9 +1,11 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
 import type { TypeOrValueSpecifier } from '../util';
+
 import {
   createRule,
   getOperatorPrecedence,
@@ -17,8 +19,8 @@ import {
 
 type Options = [
   {
-    allowForKnownSafePromises?: TypeOrValueSpecifier[];
     allowForKnownSafeCalls?: TypeOrValueSpecifier[];
+    allowForKnownSafePromises?: TypeOrValueSpecifier[];
     checkThenables?: boolean;
     ignoreIIFE?: boolean;
     ignoreVoid?: boolean;
@@ -27,13 +29,13 @@ type Options = [
 
 type MessageId =
   | 'floating'
-  | 'floatingVoid'
-  | 'floatingUselessRejectionHandler'
-  | 'floatingUselessRejectionHandlerVoid'
   | 'floatingFixAwait'
   | 'floatingFixVoid'
   | 'floatingPromiseArray'
-  | 'floatingPromiseArrayVoid';
+  | 'floatingPromiseArrayVoid'
+  | 'floatingUselessRejectionHandler'
+  | 'floatingUselessRejectionHandlerVoid'
+  | 'floatingVoid';
 
 const messageBase =
   'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
@@ -53,61 +55,6 @@ const messagePromiseArrayVoid =
   ' or explicitly marking the expression as ignored with the `void` operator.';
 
 export default createRule<Options, MessageId>({
-  name: 'no-floating-promises',
-  meta: {
-    docs: {
-      description:
-        'Require Promise-like statements to be handled appropriately',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      floating: messageBase,
-      floatingFixAwait: 'Add await operator.',
-      floatingVoid: messageBaseVoid,
-      floatingFixVoid: 'Add void operator to ignore.',
-      floatingUselessRejectionHandler: `${messageBase} ${messageRejectionHandler}`,
-      floatingUselessRejectionHandlerVoid: `${messageBaseVoid} ${messageRejectionHandler}`,
-      floatingPromiseArray: messagePromiseArray,
-      floatingPromiseArrayVoid: messagePromiseArrayVoid,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
-          allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
-          checkThenables: {
-            description:
-              'Whether to check all "Thenable"s, not just the built-in Promise type.',
-            type: 'boolean',
-          },
-          ignoreVoid: {
-            description: 'Whether to ignore `void` expressions.',
-            type: 'boolean',
-          },
-          ignoreIIFE: {
-            description:
-              'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    type: 'problem',
-  },
-  defaultOptions: [
-    {
-      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
-      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
-      checkThenables: false,
-      ignoreIIFE: false,
-      ignoreVoid: true,
-    },
-  ],
-
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -141,20 +88,19 @@ export default createRule<Options, MessageId>({
         if (isUnhandled) {
           if (promiseArray) {
             context.report({
-              node,
               messageId: options.ignoreVoid
                 ? 'floatingPromiseArrayVoid'
                 : 'floatingPromiseArray',
+              node,
             });
           } else if (options.ignoreVoid) {
             context.report({
-              node,
               messageId: nonFunctionHandler
                 ? 'floatingUselessRejectionHandlerVoid'
                 : 'floatingVoid',
+              node,
               suggest: [
                 {
-                  messageId: 'floatingFixVoid',
                   fix(fixer): TSESLint.RuleFix | TSESLint.RuleFix[] {
                     const tsNode = services.esTreeNodeToTSNodeMap.get(
                       node.expression,
@@ -170,25 +116,26 @@ export default createRule<Options, MessageId>({
                       ),
                     ];
                   },
+                  messageId: 'floatingFixVoid',
                 },
                 {
-                  messageId: 'floatingFixAwait',
                   fix: (fixer): TSESLint.RuleFix | TSESLint.RuleFix[] =>
                     addAwait(fixer, expression, node),
+                  messageId: 'floatingFixAwait',
                 },
               ],
             });
           } else {
             context.report({
-              node,
               messageId: nonFunctionHandler
                 ? 'floatingUselessRejectionHandler'
                 : 'floating',
+              node,
               suggest: [
                 {
-                  messageId: 'floatingFixAwait',
                   fix: (fixer): TSESLint.RuleFix | TSESLint.RuleFix[] =>
                     addAwait(fixer, expression, node),
+                  messageId: 'floatingFixAwait',
                 },
               ],
             });
@@ -448,6 +395,61 @@ export default createRule<Options, MessageId>({
       return false;
     }
   },
+  defaultOptions: [
+    {
+      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
+      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
+      checkThenables: false,
+      ignoreIIFE: false,
+      ignoreVoid: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require Promise-like statements to be handled appropriately',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      floating: messageBase,
+      floatingFixAwait: 'Add await operator.',
+      floatingFixVoid: 'Add void operator to ignore.',
+      floatingPromiseArray: messagePromiseArray,
+      floatingPromiseArrayVoid: messagePromiseArrayVoid,
+      floatingUselessRejectionHandler: `${messageBase} ${messageRejectionHandler}`,
+      floatingUselessRejectionHandlerVoid: `${messageBaseVoid} ${messageRejectionHandler}`,
+      floatingVoid: messageBaseVoid,
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
+          allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
+          checkThenables: {
+            description:
+              'Whether to check all "Thenable"s, not just the built-in Promise type.',
+            type: 'boolean',
+          },
+          ignoreIIFE: {
+            description:
+              'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
+            type: 'boolean',
+          },
+          ignoreVoid: {
+            description: 'Whether to ignore `void` expressions.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+
+  name: 'no-floating-promises',
 });
 
 function hasMatchingSignature(
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index 6d104b639ebe..08fcb66e8413 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -9,21 +9,6 @@ import {
 import { getForStatementHeadLoc } from '../util/getForStatementHeadLoc';
 
 export default createRule({
-  name: 'no-for-in-array',
-  meta: {
-    docs: {
-      description: 'Disallow iterating over an array with a for-in loop',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      forInViolation:
-        'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  defaultOptions: [],
   create(context) {
     return {
       ForInStatement(node): void {
@@ -44,4 +29,19 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow iterating over an array with a for-in loop',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      forInViolation:
+        'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-for-in-array',
 });
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index 62a8d7cd102e..b2f29d50c735 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -20,23 +21,6 @@ const EVAL_LIKE_METHODS = new Set([
 ]);
 
 export default createRule({
-  name: 'no-implied-eval',
-  meta: {
-    docs: {
-      description: 'Disallow the use of `eval()`-like methods',
-      recommended: 'recommended',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    messages: {
-      noImpliedEvalError: 'Implied eval. Consider passing a function.',
-      noFunctionConstructor:
-        'Implied eval. Do not use the Function constructor to create functions.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -132,11 +116,11 @@ export default createRule({
           if (
             isBuiltinSymbolLike(services.program, type, 'FunctionConstructor')
           ) {
-            context.report({ node, messageId: 'noFunctionConstructor' });
+            context.report({ messageId: 'noFunctionConstructor', node });
             return;
           }
         } else {
-          context.report({ node, messageId: 'noFunctionConstructor' });
+          context.report({ messageId: 'noFunctionConstructor', node });
           return;
         }
       }
@@ -151,13 +135,30 @@ export default createRule({
         !isFunction(handler) &&
         isReferenceToGlobalFunction(calleeName, node, context.sourceCode)
       ) {
-        context.report({ node: handler, messageId: 'noImpliedEvalError' });
+        context.report({ messageId: 'noImpliedEvalError', node: handler });
       }
     }
 
     return {
-      NewExpression: checkImpliedEval,
       CallExpression: checkImpliedEval,
+      NewExpression: checkImpliedEval,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow the use of `eval()`-like methods',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      noFunctionConstructor:
+        'Implied eval. Do not use the Function constructor to create functions.',
+      noImpliedEvalError: 'Implied eval. Consider passing a function.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-implied-eval',
 });
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index 1658d471bc7b..727e55a6ded7 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -13,21 +14,6 @@ type Options = [];
 type MessageIds = 'useTopLevelQualifier';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-import-type-side-effects',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
-    },
-    fixable: 'code',
-    messages: {
-      useTopLevelQualifier:
-        'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       'ImportDeclaration[importKind!="type"]'(
@@ -49,8 +35,6 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node,
-          messageId: 'useTopLevelQualifier',
           fix(fixer) {
             const fixes: TSESLint.RuleFix[] = [];
             for (const specifier of specifiers) {
@@ -77,8 +61,25 @@ export default createRule<Options, MessageIds>({
 
             return fixes;
           },
+          messageId: 'useTopLevelQualifier',
+          node,
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
+    },
+    fixable: 'code',
+    messages: {
+      useTopLevelQualifier:
+        'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-import-type-side-effects',
 });
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index 51ead2ae476a..bd27cd86af07 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/internal/prefer-ast-types-enum */
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
@@ -13,40 +14,6 @@ type Options = [
 type MessageIds = 'noInferrableType';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-inferrable-types',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      noInferrableType:
-        'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreParameters: {
-            type: 'boolean',
-          },
-          ignoreProperties: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      ignoreParameters: false,
-      ignoreProperties: false,
-    },
-  ],
   create(context, [{ ignoreParameters, ignoreProperties }]) {
     function isFunctionCall(
       init: TSESTree.Expression,
@@ -97,8 +64,8 @@ export default createRule<Options, MessageIds>({
     const keywordMap = {
       [AST_NODE_TYPES.TSBigIntKeyword]: 'bigint',
       [AST_NODE_TYPES.TSBooleanKeyword]: 'boolean',
-      [AST_NODE_TYPES.TSNumberKeyword]: 'number',
       [AST_NODE_TYPES.TSNullKeyword]: 'null',
+      [AST_NODE_TYPES.TSNumberKeyword]: 'number',
       [AST_NODE_TYPES.TSStringKeyword]: 'string',
       [AST_NODE_TYPES.TSSymbolKeyword]: 'symbol',
       [AST_NODE_TYPES.TSUndefinedKeyword]: 'undefined',
@@ -211,8 +178,6 @@ export default createRule<Options, MessageIds>({
           : keywordMap[typeNode.typeAnnotation.type];
 
       context.report({
-        node,
-        messageId: 'noInferrableType',
         data: {
           type,
         },
@@ -231,6 +196,8 @@ export default createRule<Options, MessageIds>({
           }
           yield fixer.remove(typeNode);
         },
+        messageId: 'noInferrableType',
+        node,
       });
     }
 
@@ -275,11 +242,45 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
-      VariableDeclarator: inferrableVariableVisitor,
-      FunctionExpression: inferrableParameterVisitor,
-      FunctionDeclaration: inferrableParameterVisitor,
       ArrowFunctionExpression: inferrableParameterVisitor,
+      FunctionDeclaration: inferrableParameterVisitor,
+      FunctionExpression: inferrableParameterVisitor,
       PropertyDefinition: inferrablePropertyVisitor,
+      VariableDeclarator: inferrableVariableVisitor,
     };
   },
+  defaultOptions: [
+    {
+      ignoreParameters: false,
+      ignoreProperties: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      noInferrableType:
+        'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreParameters: {
+            type: 'boolean',
+          },
+          ignoreProperties: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-inferrable-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-this.ts b/packages/eslint-plugin/src/rules/no-invalid-this.ts
index bf8d2a5c904b..f27b1ccae90d 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-this.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-this.ts
@@ -1,10 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -14,19 +16,6 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-invalid-this',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow `this` keywords outside of classes or class-like objects',
-      extendsBaseRule: true,
-    },
-    messages: baseRule.meta.messages,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-  },
-  defaultOptions: [{ capIsConstructor: true }],
   create(context) {
     const rules = baseRule.create(context);
 
@@ -48,12 +37,6 @@ export default createRule<Options, MessageIds>({
 
     return {
       ...rules,
-      PropertyDefinition(): void {
-        thisIsValidStack.push(true);
-      },
-      'PropertyDefinition:exit'(): void {
-        thisIsValidStack.pop();
-      },
       AccessorProperty(): void {
         thisIsValidStack.push(true);
       },
@@ -82,6 +65,12 @@ export default createRule<Options, MessageIds>({
       'FunctionExpression:exit'(): void {
         thisIsValidStack.pop();
       },
+      PropertyDefinition(): void {
+        thisIsValidStack.push(true);
+      },
+      'PropertyDefinition:exit'(): void {
+        thisIsValidStack.pop();
+      },
       ThisExpression(node: TSESTree.ThisExpression): void {
         const thisIsValidHere = thisIsValidStack[thisIsValidStack.length - 1];
 
@@ -94,4 +83,17 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [{ capIsConstructor: true }],
+  meta: {
+    docs: {
+      description:
+        'Disallow `this` keywords outside of classes or class-like objects',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'suggestion',
+  },
+  name: 'no-invalid-this',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index f518e2dc861b..e9db3b139152 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -1,11 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 interface Options {
-  allowInGenericTypeArguments?: [string, ...string[]] | boolean;
   allowAsThisParameter?: boolean;
+  allowInGenericTypeArguments?: [string, ...string[]] | boolean;
 }
 
 type MessageIds =
@@ -17,52 +18,7 @@ type MessageIds =
   | 'invalidVoidUnionConstituent';
 
 export default createRule<[Options], MessageIds>({
-  name: 'no-invalid-void-type',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow `void` type outside of generic or return types',
-      recommended: 'strict',
-    },
-    messages: {
-      invalidVoidForGeneric:
-        '{{ generic }} may not have void as a type argument.',
-      invalidVoidNotReturnOrGeneric:
-        'void is only valid as a return type or generic type argument.',
-      invalidVoidNotReturn: 'void is only valid as a return type.',
-      invalidVoidNotReturnOrThisParam:
-        'void is only valid as return type or type of `this` parameter.',
-      invalidVoidNotReturnOrThisParamOrGeneric:
-        'void is only valid as a return type or generic type argument or the type of a `this` parameter.',
-      invalidVoidUnionConstituent:
-        'void is not valid as a constituent in a union type',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowInGenericTypeArguments: {
-            oneOf: [
-              { type: 'boolean' },
-              {
-                type: 'array',
-                items: { type: 'string' },
-                minItems: 1,
-              },
-            ],
-          },
-          allowAsThisParameter: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    { allowInGenericTypeArguments: true, allowAsThisParameter: false },
-  ],
-  create(context, [{ allowInGenericTypeArguments, allowAsThisParameter }]) {
+  create(context, [{ allowAsThisParameter, allowInGenericTypeArguments }]) {
     const validParents: AST_NODE_TYPES[] = [
       AST_NODE_TYPES.TSTypeAnnotation, //
     ];
@@ -111,8 +67,8 @@ export default createRule<[Options], MessageIds>({
             .includes(fullyQualifiedName)
         ) {
           context.report({
-            messageId: 'invalidVoidForGeneric',
             data: { generic: fullyQualifiedName },
+            messageId: 'invalidVoidForGeneric',
             node,
           });
         }
@@ -226,6 +182,51 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    { allowAsThisParameter: false, allowInGenericTypeArguments: true },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow `void` type outside of generic or return types',
+      recommended: 'strict',
+    },
+    messages: {
+      invalidVoidForGeneric:
+        '{{ generic }} may not have void as a type argument.',
+      invalidVoidNotReturn: 'void is only valid as a return type.',
+      invalidVoidNotReturnOrGeneric:
+        'void is only valid as a return type or generic type argument.',
+      invalidVoidNotReturnOrThisParam:
+        'void is only valid as return type or type of `this` parameter.',
+      invalidVoidNotReturnOrThisParamOrGeneric:
+        'void is only valid as a return type or generic type argument or the type of a `this` parameter.',
+      invalidVoidUnionConstituent:
+        'void is not valid as a constituent in a union type',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowAsThisParameter: {
+            type: 'boolean',
+          },
+          allowInGenericTypeArguments: {
+            oneOf: [
+              { type: 'boolean' },
+              {
+                items: { type: 'string' },
+                minItems: 1,
+                type: 'array',
+              },
+            ],
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'no-invalid-void-type',
 });
 
 function getNotReturnOrGenericMessageId(
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index a34217453b0d..d53f1959b906 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -1,10 +1,12 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -14,19 +16,6 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-loop-func',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow function declarations that contain unsafe references inside loop statements',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: [],
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [],
   create(context) {
     /**
      * Reports functions which match the following condition:
@@ -54,19 +43,32 @@ export default createRule<Options, MessageIds>({
 
       if (unsafeRefs.length > 0) {
         context.report({
-          node,
-          messageId: 'unsafeRefs',
           data: { varNames: `'${unsafeRefs.join("', '")}'` },
+          messageId: 'unsafeRefs',
+          node,
         });
       }
     }
 
     return {
       ArrowFunctionExpression: checkForLoops,
-      FunctionExpression: checkForLoops,
       FunctionDeclaration: checkForLoops,
+      FunctionExpression: checkForLoops,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow function declarations that contain unsafe references inside loop statements',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-loop-func',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
index 000e5d9aa0bc..1631c33ac46e 100644
--- a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
+++ b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
@@ -2,6 +2,7 @@ import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -11,20 +12,20 @@ type Options = InferOptionsTypeFromRule<NonNullable<typeof baseRule>>;
 type MessageIds = InferMessageIdsTypeFromRule<NonNullable<typeof baseRule>>;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-loss-of-precision',
+  create(context) {
+    return baseRule.create(context);
+  },
+  defaultOptions: [],
   meta: {
-    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow literal numbers that lose precision',
       extendsBaseRule: true,
     },
     hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: [],
     messages: baseRule.meta.messages,
+    schema: [],
+    type: 'problem',
   },
-  defaultOptions: [],
-  create(context) {
-    return baseRule.create(context);
-  },
+  name: 'no-loss-of-precision',
 });
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index 5a86056cb90d..7a39d084d894 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -1,11 +1,13 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule, deepMerge } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -22,10 +24,10 @@ const schema = deepMerge(
     : baseRule.meta.schema,
   {
     properties: {
-      ignoreNumericLiteralTypes: {
+      ignoreEnums: {
         type: 'boolean',
       },
-      ignoreEnums: {
+      ignoreNumericLiteralTypes: {
         type: 'boolean',
       },
       ignoreReadonlyClassProperties: {
@@ -39,28 +41,6 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-magic-numbers',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow magic numbers',
-      extendsBaseRule: true,
-    },
-    schema: [schema],
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [
-    {
-      ignore: [],
-      ignoreArrayIndexes: false,
-      enforceConst: false,
-      detectObjects: false,
-      ignoreNumericLiteralTypes: false,
-      ignoreEnums: false,
-      ignoreReadonlyClassProperties: false,
-      ignoreTypeIndexes: false,
-    },
-  ],
   create(context, [options]) {
     const rules = baseRule.create(context);
 
@@ -121,9 +101,9 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
+            data: { raw },
             messageId: 'noMagic',
             node: fullNumberNode,
-            data: { raw },
           });
 
           return;
@@ -134,6 +114,28 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      detectObjects: false,
+      enforceConst: false,
+      ignore: [],
+      ignoreArrayIndexes: false,
+      ignoreEnums: false,
+      ignoreNumericLiteralTypes: false,
+      ignoreReadonlyClassProperties: false,
+      ignoreTypeIndexes: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow magic numbers',
+      extendsBaseRule: true,
+    },
+    messages: baseRule.meta.messages,
+    schema: [schema],
+    type: 'suggestion',
+  },
+  name: 'no-magic-numbers',
 });
 
 /**
@@ -158,7 +160,7 @@ function normalizeIgnoreValue(
  */
 function normalizeLiteralValue(
   node: TSESTree.BigIntLiteral | TSESTree.NumberLiteral,
-  value: number | bigint,
+  value: bigint | number,
 ): bigint | number {
   if (
     node.parent.type === AST_NODE_TYPES.UnaryExpression &&
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index e8fdde8d1f33..d792a9a9338a 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { ESLintUtils } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -12,37 +13,6 @@ type Options = [
 ];
 
 export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
-  name: 'no-meaningless-void-operator',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow the `void` operator except when used to discard a value',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      meaninglessVoidOperator:
-        "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
-      removeVoid: "Remove 'void'",
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          checkNever: {
-            type: 'boolean',
-            default: false,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [{ checkNever: false }],
-
   create(context, [{ checkNever }]) {
     const services = ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -64,10 +34,10 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
           )
         ) {
           context.report({
-            node,
-            messageId: 'meaninglessVoidOperator',
             data: { type: checker.typeToString(argType) },
             fix,
+            messageId: 'meaninglessVoidOperator',
+            node,
           });
         } else if (
           checkNever &&
@@ -78,13 +48,44 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
           )
         ) {
           context.report({
-            node,
-            messageId: 'meaninglessVoidOperator',
             data: { type: checker.typeToString(argType) },
-            suggest: [{ messageId: 'removeVoid', fix }],
+            messageId: 'meaninglessVoidOperator',
+            node,
+            suggest: [{ fix, messageId: 'removeVoid' }],
           });
         }
       },
     };
   },
+  defaultOptions: [{ checkNever: false }],
+  meta: {
+    docs: {
+      description:
+        'Disallow the `void` operator except when used to discard a value',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      meaninglessVoidOperator:
+        "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
+      removeVoid: "Remove 'void'",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          checkNever: {
+            default: false,
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'no-meaningless-void-operator',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index f877f9d7d9cb..53c3447357ba 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -1,23 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-misused-new',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Enforce valid definition of `new` and `constructor`',
-      recommended: 'recommended',
-    },
-    schema: [],
-    messages: {
-      errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
-      errorMessageClass: 'Class cannot have method named `new`.',
-    },
-  },
-  defaultOptions: [],
   create(context) {
     /**
      * @param node type to be inspected.
@@ -51,10 +38,10 @@ export default createRule({
      */
     function isMatchingParentType(
       parent:
-        | TSESTree.TSInterfaceDeclaration
         | TSESTree.ClassDeclaration
         | TSESTree.ClassExpression
         | TSESTree.Identifier
+        | TSESTree.TSInterfaceDeclaration
         | undefined,
       returnType: TSESTree.TSTypeAnnotation | undefined,
     ): boolean {
@@ -71,6 +58,18 @@ export default createRule({
     }
 
     return {
+      "ClassBody > MethodDefinition[key.name='new']"(
+        node: TSESTree.MethodDefinition,
+      ): void {
+        if (node.value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+          if (isMatchingParentType(node.parent.parent, node.value.returnType)) {
+            context.report({
+              messageId: 'errorMessageClass',
+              node,
+            });
+          }
+        }
+      },
       'TSInterfaceBody > TSConstructSignatureDeclaration'(
         node: TSESTree.TSConstructSignatureDeclaration,
       ): void {
@@ -82,8 +81,8 @@ export default createRule({
         ) {
           // constructor
           context.report({
-            node,
             messageId: 'errorMessageInterface',
+            node,
           });
         }
       },
@@ -91,22 +90,24 @@ export default createRule({
         node: TSESTree.TSMethodSignature,
       ): void {
         context.report({
-          node,
           messageId: 'errorMessageInterface',
+          node,
         });
       },
-      "ClassBody > MethodDefinition[key.name='new']"(
-        node: TSESTree.MethodDefinition,
-      ): void {
-        if (node.value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
-          if (isMatchingParentType(node.parent.parent, node.value.returnType)) {
-            context.report({
-              node,
-              messageId: 'errorMessageClass',
-            });
-          }
-        }
-      },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Enforce valid definition of `new` and `constructor`',
+      recommended: 'recommended',
+    },
+    messages: {
+      errorMessageClass: 'Class cannot have method named `new`.',
+      errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-misused-new',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index a5433edf7d10..014578519b65 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -15,8 +16,8 @@ import {
 type Options = [
   {
     checksConditionals?: boolean;
-    checksVoidReturn?: ChecksVoidReturnOptions | boolean;
     checksSpreads?: boolean;
+    checksVoidReturn?: ChecksVoidReturnOptions | boolean;
   },
 ];
 
@@ -70,71 +71,7 @@ function parseChecksVoidReturn(
 }
 
 export default createRule<Options, MessageId>({
-  name: 'no-misused-promises',
-  meta: {
-    docs: {
-      description: 'Disallow Promises in places not designed to handle them',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      voidReturnArgument:
-        'Promise returned in function argument where a void return was expected.',
-      voidReturnAttribute:
-        'Promise-returning function provided to attribute where a void return was expected.',
-      voidReturnInheritedMethod:
-        "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.",
-      voidReturnProperty:
-        'Promise-returning function provided to property where a void return was expected.',
-      voidReturnReturnValue:
-        'Promise-returning function provided to return value where a void return was expected.',
-      voidReturnVariable:
-        'Promise-returning function provided to variable where a void return was expected.',
-      conditional: 'Expected non-Promise value in a boolean conditional.',
-      spread: 'Expected a non-Promise value to be spreaded in an object.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          checksConditionals: {
-            type: 'boolean',
-          },
-          checksVoidReturn: {
-            oneOf: [
-              { type: 'boolean' },
-              {
-                additionalProperties: false,
-                properties: {
-                  arguments: { type: 'boolean' },
-                  attributes: { type: 'boolean' },
-                  inheritedMethods: { type: 'boolean' },
-                  properties: { type: 'boolean' },
-                  returns: { type: 'boolean' },
-                  variables: { type: 'boolean' },
-                },
-                type: 'object',
-              },
-            ],
-          },
-          checksSpreads: {
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-    type: 'problem',
-  },
-  defaultOptions: [
-    {
-      checksConditionals: true,
-      checksVoidReturn: true,
-      checksSpreads: true,
-    },
-  ],
-
-  create(context, [{ checksConditionals, checksVoidReturn, checksSpreads }]) {
+  create(context, [{ checksConditionals, checksSpreads, checksVoidReturn }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
 
@@ -537,9 +474,9 @@ export default createRule<Options, MessageId>({
         return;
       }
       context.report({
-        node: services.tsNodeToESTreeNodeMap.get(nodeMember),
-        messageId: 'voidReturnInheritedMethod',
         data: { heritageTypeName: checker.typeToString(heritageType) },
+        messageId: 'voidReturnInheritedMethod',
+        node: services.tsNodeToESTreeNodeMap.get(nodeMember),
       });
     }
 
@@ -590,6 +527,70 @@ export default createRule<Options, MessageId>({
       ...(checksSpreads ? spreadChecks : {}),
     };
   },
+  defaultOptions: [
+    {
+      checksConditionals: true,
+      checksSpreads: true,
+      checksVoidReturn: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow Promises in places not designed to handle them',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      conditional: 'Expected non-Promise value in a boolean conditional.',
+      spread: 'Expected a non-Promise value to be spreaded in an object.',
+      voidReturnArgument:
+        'Promise returned in function argument where a void return was expected.',
+      voidReturnAttribute:
+        'Promise-returning function provided to attribute where a void return was expected.',
+      voidReturnInheritedMethod:
+        "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.",
+      voidReturnProperty:
+        'Promise-returning function provided to property where a void return was expected.',
+      voidReturnReturnValue:
+        'Promise-returning function provided to return value where a void return was expected.',
+      voidReturnVariable:
+        'Promise-returning function provided to variable where a void return was expected.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          checksConditionals: {
+            type: 'boolean',
+          },
+          checksSpreads: {
+            type: 'boolean',
+          },
+          checksVoidReturn: {
+            oneOf: [
+              { type: 'boolean' },
+              {
+                additionalProperties: false,
+                properties: {
+                  arguments: { type: 'boolean' },
+                  attributes: { type: 'boolean' },
+                  inheritedMethods: { type: 'boolean' },
+                  properties: { type: 'boolean' },
+                  returns: { type: 'boolean' },
+                  variables: { type: 'boolean' },
+                },
+                type: 'object',
+              },
+            ],
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+
+  name: 'no-misused-promises',
 });
 
 function isSometimesThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index ce6a706a10d0..68e3594b27bb 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -1,6 +1,7 @@
 import type { Scope } from '@typescript-eslint/scope-manager';
-import { DefinitionType } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -14,20 +15,6 @@ enum AllowedType {
 }
 
 export default createRule({
-  name: 'no-mixed-enums',
-  meta: {
-    docs: {
-      description: 'Disallow enums from having both number and string members',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      mixed: `Mixing number and string enums can be confusing.`,
-    },
-    schema: [],
-    type: 'problem',
-  },
-  defaultOptions: [],
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
@@ -217,4 +204,18 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow enums from having both number and string members',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      mixed: `Mixing number and string enums can be confusing.`,
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-mixed-enums',
 });
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index c6b9213259be..95ddae51a851 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isDefinitionFile } from '../util';
@@ -12,42 +13,6 @@ type Options = [
 type MessageIds = 'moduleSyntaxIsPreferred';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-namespace',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow TypeScript namespaces',
-      recommended: 'recommended',
-    },
-    messages: {
-      moduleSyntaxIsPreferred:
-        'ES2015 module syntax is preferred over namespaces.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowDeclarations: {
-            description:
-              'Whether to allow `declare` with custom TypeScript namespaces.',
-            type: 'boolean',
-          },
-          allowDefinitionFiles: {
-            description:
-              'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowDeclarations: false,
-      allowDefinitionFiles: true,
-    },
-  ],
   create(context, [{ allowDeclarations, allowDefinitionFiles }]) {
     function isDeclaration(node: TSESTree.Node): boolean {
       if (node.type === AST_NODE_TYPES.TSModuleDeclaration && node.declare) {
@@ -70,10 +35,46 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node,
           messageId: 'moduleSyntaxIsPreferred',
+          node,
         });
       },
     };
   },
+  defaultOptions: [
+    {
+      allowDeclarations: false,
+      allowDefinitionFiles: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow TypeScript namespaces',
+      recommended: 'recommended',
+    },
+    messages: {
+      moduleSyntaxIsPreferred:
+        'ES2015 module syntax is preferred over namespaces.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowDeclarations: {
+            description:
+              'Whether to allow `declare` with custom TypeScript namespaces.',
+            type: 'boolean',
+          },
+          allowDefinitionFiles: {
+            description:
+              'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-namespace',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index 1369254b16ae..3315fe241f15 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -1,6 +1,7 @@
 import type { Definition } from '@typescript-eslint/scope-manager';
-import { DefinitionType } from '@typescript-eslint/scope-manager';
 import type { TSESLint } from '@typescript-eslint/utils';
+
+import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { ASTUtils, TSESTree } from '@typescript-eslint/utils';
 
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
@@ -30,23 +31,6 @@ function isDefinitionWithAssignment(definition: Definition): boolean {
 }
 
 export default createRule({
-  name: 'no-non-null-asserted-nullish-coalescing',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow non-null assertions in the left operand of a nullish coalescing operator',
-      recommended: 'strict',
-    },
-    messages: {
-      noNonNullAssertedNullishCoalescing:
-        'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
-      suggestRemovingNonNull: 'Remove the non-null assertion.',
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  defaultOptions: [],
   create(context) {
     return {
       'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(
@@ -62,8 +46,8 @@ export default createRule({
         }
 
         context.report({
-          node,
           messageId: 'noNonNullAssertedNullishCoalescing',
+          node,
           /*
           Use a suggestion instead of a fixer, because this can break type checks.
           The resulting type of the nullish coalesce is only influenced by the right operand if the left operand can be `null` or `undefined`.
@@ -79,7 +63,6 @@ export default createRule({
           */
           suggest: [
             {
-              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 const exclamationMark = nullThrows(
                   context.sourceCode.getLastToken(
@@ -90,10 +73,28 @@ export default createRule({
                 );
                 return fixer.remove(exclamationMark);
               },
+              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow non-null assertions in the left operand of a nullish coalescing operator',
+      recommended: 'strict',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNullAssertedNullishCoalescing:
+        'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
+      suggestRemovingNonNull: 'Remove the non-null assertion.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-non-null-asserted-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index efc8fc26cf5a..2e474b0a5513 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -3,23 +3,6 @@ import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-non-null-asserted-optional-chain',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow non-null assertions after an optional chain expression',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      noNonNullOptionalChain:
-        'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.',
-      suggestRemovingNonNull: 'You should remove the non-null assertion.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       // non-nulling a wrapped chain will scrub all nulls introduced by the chain
@@ -31,18 +14,18 @@ export default createRule({
         // selector guarantees this assertion
         const parent = node.parent as TSESTree.TSNonNullExpression;
         context.report({
-          node,
           messageId: 'noNonNullOptionalChain',
+          node,
           // use a suggestion instead of a fixer, because this can obviously break type checks
           suggest: [
             {
-              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.removeRange([
                   parent.range[1] - 1,
                   parent.range[1],
                 ]);
               },
+              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
@@ -55,19 +38,36 @@ export default createRule({
         node: TSESTree.TSNonNullExpression,
       ): void {
         context.report({
-          node,
           messageId: 'noNonNullOptionalChain',
+          node,
           // use a suggestion instead of a fixer, because this can obviously break type checks
           suggest: [
             {
-              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.removeRange([node.range[1] - 1, node.range[1]]);
               },
+              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow non-null assertions after an optional chain expression',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNullOptionalChain:
+        'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.',
+      suggestRemovingNonNull: 'You should remove the non-null assertion.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-non-null-asserted-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 475262c2a4a0..422f860489c0 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -1,4 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -11,23 +12,6 @@ import {
 type MessageIds = 'noNonNull' | 'suggestOptionalChain';
 
 export default createRule<[], MessageIds>({
-  name: 'no-non-null-assertion',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow non-null assertions using the `!` postfix operator',
-      recommended: 'strict',
-    },
-    hasSuggestions: true,
-    messages: {
-      noNonNull: 'Forbidden non-null assertion.',
-      suggestOptionalChain:
-        'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       TSNonNullExpression(node): void {
@@ -58,13 +42,12 @@ export default createRule<[], MessageIds>({
             if (node.parent.computed) {
               // it is x![y]?.z
               suggest.push({
-                messageId: 'suggestOptionalChain',
                 fix: replaceTokenWithOptional(),
+                messageId: 'suggestOptionalChain',
               });
             } else {
               // it is x!.y?.z
               suggest.push({
-                messageId: 'suggestOptionalChain',
                 fix(fixer) {
                   // x!.y?.z
                   //   ^ punctuator
@@ -77,19 +60,20 @@ export default createRule<[], MessageIds>({
                     fixer.insertTextBefore(punctuator, '?'),
                   ];
                 },
+                messageId: 'suggestOptionalChain',
               });
             }
           } else if (node.parent.computed) {
             // it is x!?.[y].z
             suggest.push({
-              messageId: 'suggestOptionalChain',
               fix: removeToken(),
+              messageId: 'suggestOptionalChain',
             });
           } else {
             // it is x!?.y.z
             suggest.push({
-              messageId: 'suggestOptionalChain',
               fix: removeToken(),
+              messageId: 'suggestOptionalChain',
             });
           }
         } else if (
@@ -99,24 +83,41 @@ export default createRule<[], MessageIds>({
           if (!node.parent.optional) {
             // it is x.y?.z!()
             suggest.push({
-              messageId: 'suggestOptionalChain',
               fix: replaceTokenWithOptional(),
+              messageId: 'suggestOptionalChain',
             });
           } else {
             // it is x.y.z!?.()
             suggest.push({
-              messageId: 'suggestOptionalChain',
               fix: removeToken(),
+              messageId: 'suggestOptionalChain',
             });
           }
         }
 
         context.report({
-          node,
           messageId: 'noNonNull',
+          node,
           suggest,
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow non-null assertions using the `!` postfix operator',
+      recommended: 'strict',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNull: 'Forbidden non-null assertion.',
+      suggestOptionalChain:
+        'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index b084d90650b0..4e77b8adc561 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -1,5 +1,6 @@
-import { ScopeType } from '@typescript-eslint/scope-manager';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import { ScopeType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, getNameLocationInGlobalDirectiveComment } from '../util';
@@ -13,41 +14,6 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'no-redeclare',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow variable redeclaration',
-      extendsBaseRule: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          builtinGlobals: {
-            type: 'boolean',
-          },
-          ignoreDeclarationMerge: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      redeclared: "'{{id}}' is already defined.",
-      redeclaredAsBuiltin:
-        "'{{id}}' is already defined as a built-in global variable.",
-      redeclaredBySyntax:
-        "'{{id}}' is already defined by a variable declaration.",
-    },
-  },
-  defaultOptions: [
-    {
-      builtinGlobals: true,
-      ignoreDeclarationMerge: true,
-    },
-  ],
   create(context, [options]) {
     const CLASS_DECLARATION_MERGE_NODES = new Set<AST_NODE_TYPES>([
       AST_NODE_TYPES.TSInterfaceDeclaration,
@@ -65,9 +31,9 @@ export default createRule<Options, MessageIds>({
 
     function* iterateDeclarations(variable: TSESLint.Scope.Variable): Generator<
       {
-        type: 'builtin' | 'comment' | 'syntax';
-        node?: TSESTree.Comment | TSESTree.Identifier;
         loc?: TSESTree.SourceLocation;
+        node?: TSESTree.Comment | TSESTree.Identifier;
+        type: 'builtin' | 'comment' | 'syntax';
       },
       void
     > {
@@ -86,13 +52,13 @@ export default createRule<Options, MessageIds>({
       ) {
         for (const comment of variable.eslintExplicitGlobalComments) {
           yield {
-            type: 'comment',
-            node: comment,
             loc: getNameLocationInGlobalDirectiveComment(
               context.sourceCode,
               comment,
               variable.name,
             ),
+            node: comment,
+            type: 'comment',
           };
         }
       }
@@ -143,7 +109,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one class declaration, which needs to be reported
           for (const { identifier } of classDecls) {
-            yield { type: 'syntax', node: identifier, loc: identifier.loc };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -164,7 +130,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one function declaration, which needs to be reported
           for (const { identifier } of functionDecls) {
-            yield { type: 'syntax', node: identifier, loc: identifier.loc };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -185,14 +151,14 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one enum declaration, which needs to be reported
           for (const { identifier } of enumDecls) {
-            yield { type: 'syntax', node: identifier, loc: identifier.loc };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
       }
 
       for (const { identifier } of identifiers) {
-        yield { type: 'syntax', node: identifier, loc: identifier.loc };
+        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
       }
     }
 
@@ -217,14 +183,14 @@ export default createRule<Options, MessageIds>({
         const data = { id: variable.name };
 
         // Report extra declarations.
-        for (const { type, node, loc } of extraDeclarations) {
+        for (const { loc, node, type } of extraDeclarations) {
           const messageId =
             type === declaration.type ? 'redeclared' : detailMessageId;
 
           if (node) {
-            context.report({ node, loc, messageId, data });
+            context.report({ data, loc, messageId, node });
           } else if (loc) {
-            context.report({ loc, messageId, data });
+            context.report({ data, loc, messageId });
           }
         }
       }
@@ -246,6 +212,15 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
+      ArrowFunctionExpression: checkForBlock,
+
+      BlockStatement: checkForBlock,
+      ForInStatement: checkForBlock,
+      ForOfStatement: checkForBlock,
+
+      ForStatement: checkForBlock,
+      FunctionDeclaration: checkForBlock,
+      FunctionExpression: checkForBlock,
       Program(node): void {
         const scope = context.sourceCode.getScope(node);
 
@@ -261,16 +236,42 @@ export default createRule<Options, MessageIds>({
           findVariablesInScope(scope.childScopes[0]);
         }
       },
-
-      FunctionDeclaration: checkForBlock,
-      FunctionExpression: checkForBlock,
-      ArrowFunctionExpression: checkForBlock,
-
-      BlockStatement: checkForBlock,
-      ForStatement: checkForBlock,
-      ForInStatement: checkForBlock,
-      ForOfStatement: checkForBlock,
       SwitchStatement: checkForBlock,
     };
   },
+  defaultOptions: [
+    {
+      builtinGlobals: true,
+      ignoreDeclarationMerge: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow variable redeclaration',
+      extendsBaseRule: true,
+    },
+    messages: {
+      redeclared: "'{{id}}' is already defined.",
+      redeclaredAsBuiltin:
+        "'{{id}}' is already defined as a built-in global variable.",
+      redeclaredBySyntax:
+        "'{{id}}' is already defined by a variable declaration.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          builtinGlobals: {
+            type: 'boolean',
+          },
+          ignoreDeclarationMerge: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-redeclare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index 7a1475ad0f32..063f9f92f383 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -57,9 +57,9 @@ const keywordNodeTypesToTsTypes = new Map([
   [TSESTree.AST_NODE_TYPES.TSBigIntKeyword, ts.TypeFlags.BigInt],
   [TSESTree.AST_NODE_TYPES.TSBooleanKeyword, ts.TypeFlags.Boolean],
   [TSESTree.AST_NODE_TYPES.TSNeverKeyword, ts.TypeFlags.Never],
-  [TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown],
   [TSESTree.AST_NODE_TYPES.TSNumberKeyword, ts.TypeFlags.Number],
   [TSESTree.AST_NODE_TYPES.TSStringKeyword, ts.TypeFlags.String],
+  [TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown],
 ]);
 
 type PrimitiveTypeFlag = (typeof primitiveTypeFlags)[number];
@@ -192,25 +192,6 @@ function unionTypePartsUnlessBoolean(type: ts.Type): ts.Type[] {
 }
 
 export default createRule({
-  name: 'no-redundant-type-constituents',
-  meta: {
-    docs: {
-      description:
-        'Disallow members of unions and intersections that do nothing or override type information',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
-      primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
-      overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
-      overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
-      errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const typesCache = new Map<TSESTree.TypeNode, TypeFlagsWithName[]>();
@@ -532,4 +513,23 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow members of unions and intersections that do nothing or override type information',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
+      literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
+      overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
+      overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
+      primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-redundant-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 64f626076c32..69337e0d2cd4 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 
 import * as util from '../util';
@@ -12,35 +13,6 @@ type Options = [
 type MessageIds = 'noRequireImports';
 
 export default util.createRule<Options, MessageIds>({
-  name: 'no-require-imports',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow invocation of `require()`',
-      recommended: 'recommended',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allow: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Patterns of import paths to allow requiring from.',
-          },
-          allowAsImport: {
-            type: 'boolean',
-            description: 'Allows `require` statements in import declarations.',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      noRequireImports: 'A `require()` style import is forbidden.',
-    },
-  },
-  defaultOptions: [{ allow: [], allowAsImport: false }],
   create(context, options) {
     const allowAsImport = options[0].allowAsImport;
     const allowPatterns = options[0].allow?.map(
@@ -75,8 +47,8 @@ export default util.createRule<Options, MessageIds>({
         // of the commonjs standard
         if (!variable?.identifiers.length) {
           context.report({
-            node,
             messageId: 'noRequireImports',
+            node,
           });
         }
       },
@@ -94,10 +66,39 @@ export default util.createRule<Options, MessageIds>({
           return;
         }
         context.report({
-          node,
           messageId: 'noRequireImports',
+          node,
         });
       },
     };
   },
+  defaultOptions: [{ allow: [], allowAsImport: false }],
+  meta: {
+    docs: {
+      description: 'Disallow invocation of `require()`',
+      recommended: 'recommended',
+    },
+    messages: {
+      noRequireImports: 'A `require()` style import is forbidden.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: {
+            description: 'Patterns of import paths to allow requiring from.',
+            items: { type: 'string' },
+            type: 'array',
+          },
+          allowAsImport: {
+            description: 'Allows `require` statements in import declarations.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'no-require-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-imports.ts b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
index f61baa7ed396..3245778679dc 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
@@ -1,5 +1,4 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type {
   JSONSchema4AnyOfSchema,
   JSONSchema4ArraySchema,
@@ -11,12 +10,15 @@ import type {
   RuleListener,
 } from 'eslint/lib/rules/no-restricted-imports';
 import type { Ignore } from 'ignore';
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import ignore from 'ignore';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -40,58 +42,56 @@ const baseSchema = baseRule.meta.schema as {
   anyOf: [
     unknown,
     {
-      type: 'array';
       items: [
         {
-          type: 'object';
           properties: {
             paths: {
-              type: 'array';
               items: {
                 anyOf: [
                   { type: 'string' },
                   {
-                    type: 'object';
                     properties: JSONSchema4ObjectSchema['properties'];
                     required: string[];
+                    type: 'object';
                   },
                 ];
               };
+              type: 'array';
             };
             patterns: {
               anyOf: [
-                { type: 'array'; items: { type: 'string' } },
+                { items: { type: 'string' }; type: 'array' },
                 {
-                  type: 'array';
                   items: {
-                    type: 'object';
                     properties: JSONSchema4ObjectSchema['properties'];
                     required: string[];
+                    type: 'object';
                   };
+                  type: 'array';
                 },
               ];
             };
           };
+          type: 'object';
         },
       ];
+      type: 'array';
     },
   ];
 };
 
 const allowTypeImportsOptionSchema: JSONSchema4ObjectSchema['properties'] = {
   allowTypeImports: {
-    type: 'boolean',
     description: 'Disallow value imports, but allow type-only imports.',
+    type: 'boolean',
   },
 };
 
 const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
-  type: 'array',
   items: {
     anyOf: [
       { type: 'string' },
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -108,25 +108,25 @@ const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
               .required,
           undefined,
         ),
+        type: 'object',
       },
     ],
   },
+  type: 'array',
   uniqueItems: true,
 };
 
 const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
   anyOf: [
     {
-      type: 'array',
       items: {
         type: 'string',
       },
+      type: 'array',
       uniqueItems: true,
     },
     {
-      type: 'array',
       items: {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -143,7 +143,9 @@ const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
               .required,
           [],
         ),
+        type: 'object',
       },
+      type: 'array',
       uniqueItems: true,
     },
   ],
@@ -153,18 +155,18 @@ const schema: JSONSchema4AnyOfSchema = {
   anyOf: [
     arrayOfStringsOrObjects,
     {
-      type: 'array',
+      additionalItems: false,
       items: [
         {
-          type: 'object',
+          additionalProperties: false,
           properties: {
             paths: arrayOfStringsOrObjects,
             patterns: arrayOfStringsOrObjectPatterns,
           },
-          additionalProperties: false,
+          type: 'object',
         },
       ],
-      additionalItems: false,
+      type: 'array',
     },
   ],
 };
@@ -228,18 +230,6 @@ function shouldCreateRule(
 }
 
 export default createRule<Options, MessageIds>({
-  name: 'no-restricted-imports',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow specified modules when loaded by `import`',
-      extendsBaseRule: true,
-    },
-    messages: baseRule.meta.messages,
-    fixable: baseRule.meta.fixable,
-    schema,
-  },
-  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
     const { options } = context;
@@ -308,6 +298,29 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
+      ExportAllDeclaration: rules.ExportAllDeclaration,
+      'ExportNamedDeclaration[source]'(
+        node: {
+          source: NonNullable<TSESTree.ExportNamedDeclaration['source']>;
+        } & TSESTree.ExportNamedDeclaration,
+      ): void {
+        if (
+          node.exportKind === 'type' ||
+          (node.specifiers.length > 0 &&
+            node.specifiers.every(specifier => specifier.exportKind === 'type'))
+        ) {
+          const importSource = node.source.value.trim();
+          if (
+            !isAllowedTypeImportPath(importSource) &&
+            !isAllowedTypeImportPattern(importSource)
+          ) {
+            return rules.ExportNamedDeclaration(node);
+          }
+        } else {
+          return rules.ExportNamedDeclaration(node);
+        }
+      },
+      ImportDeclaration: checkImportNode,
       TSImportEqualsDeclaration(
         node: TSESTree.TSImportEqualsDeclaration,
       ): void {
@@ -316,46 +329,35 @@ export default createRule<Options, MessageIds>({
         ) {
           const synthesizedImport: TSESTree.ImportDeclaration = {
             ...node,
-            type: AST_NODE_TYPES.ImportDeclaration,
-            source: node.moduleReference.expression,
             assertions: [],
             attributes: [],
+            source: node.moduleReference.expression,
             specifiers: [
               {
                 ...node.id,
-                type: AST_NODE_TYPES.ImportDefaultSpecifier,
                 local: node.id,
+                type: AST_NODE_TYPES.ImportDefaultSpecifier,
                 // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension
                 parent: node.id.parent,
               },
             ],
+            type: AST_NODE_TYPES.ImportDeclaration,
           };
           return checkImportNode(synthesizedImport);
         }
       },
-      ImportDeclaration: checkImportNode,
-      'ExportNamedDeclaration[source]'(
-        node: TSESTree.ExportNamedDeclaration & {
-          source: NonNullable<TSESTree.ExportNamedDeclaration['source']>;
-        },
-      ): void {
-        if (
-          node.exportKind === 'type' ||
-          (node.specifiers.length > 0 &&
-            node.specifiers.every(specifier => specifier.exportKind === 'type'))
-        ) {
-          const importSource = node.source.value.trim();
-          if (
-            !isAllowedTypeImportPath(importSource) &&
-            !isAllowedTypeImportPattern(importSource)
-          ) {
-            return rules.ExportNamedDeclaration(node);
-          }
-        } else {
-          return rules.ExportNamedDeclaration(node);
-        }
-      },
-      ExportAllDeclaration: rules.ExportAllDeclaration,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow specified modules when loaded by `import`',
+      extendsBaseRule: true,
+    },
+    fixable: baseRule.meta.fixable,
+    messages: baseRule.meta.messages,
+    schema,
+    type: 'suggestion',
+  },
+  name: 'no-restricted-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index c13f2838d85d..87ee382ee28c 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -1,24 +1,25 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, objectReduceKey } from '../util';
 
 type Types = Record<
   string,
-  | boolean
-  | string
   | {
-      message: string;
       fixWith?: string;
+      message: string;
       suggest?: readonly string[];
     }
+  | boolean
+  | string
   | null
 >;
 
 export type Options = [
   {
-    types?: Types;
     extendDefaults?: boolean;
+    types?: Types;
   },
 ];
 
@@ -36,7 +37,7 @@ function stringifyNode(
 }
 
 function getCustomMessage(
-  bannedType: string | true | { message?: string; fixWith?: string } | null,
+  bannedType: { fixWith?: string; message?: string } | true | string | null,
 ): string {
   if (!bannedType || bannedType === true) {
     return '';
@@ -68,70 +69,6 @@ const TYPE_KEYWORDS = {
 };
 
 export default createRule<Options, MessageIds>({
-  name: 'no-restricted-types',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow certain types',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
-      bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.',
-    },
-    schema: [
-      {
-        $defs: {
-          banConfig: {
-            oneOf: [
-              {
-                type: 'boolean',
-                enum: [true],
-                description: 'Bans the type with the default message',
-              },
-              {
-                type: 'string',
-                description: 'Bans the type with a custom message',
-              },
-              {
-                type: 'object',
-                description: 'Bans a type',
-                properties: {
-                  message: {
-                    type: 'string',
-                    description: 'Custom error message',
-                  },
-                  fixWith: {
-                    type: 'string',
-                    description:
-                      'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
-                  },
-                  suggest: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Types to suggest replacing with.',
-                  },
-                },
-                additionalProperties: false,
-              },
-            ],
-          },
-        },
-        type: 'object',
-        properties: {
-          types: {
-            type: 'object',
-            additionalProperties: {
-              $ref: '#/items/0/$defs/banConfig',
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [{}],
   create(context, [{ types = {} }]) {
     const bannedTypes = new Map(
       Object.entries(types).map(([type, data]) => [removeSpaces(type), data]),
@@ -156,23 +93,23 @@ export default createRule<Options, MessageIds>({
           : undefined;
 
       context.report({
-        node: typeNode,
-        messageId: 'bannedTypeMessage',
         data: {
-          name,
           customMessage,
+          name,
         },
         fix: fixWith
           ? (fixer): TSESLint.RuleFix => fixer.replaceText(typeNode, fixWith)
           : null,
+        messageId: 'bannedTypeMessage',
+        node: typeNode,
         suggest: suggest?.map(replacement => ({
-          messageId: 'bannedTypeReplacement',
           data: {
             name,
             replacement,
           },
           fix: (fixer): TSESLint.RuleFix =>
             fixer.replaceText(typeNode, replacement),
+          messageId: 'bannedTypeReplacement',
         })),
       });
     }
@@ -218,4 +155,68 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: 'Disallow certain types',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
+      bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.',
+    },
+    schema: [
+      {
+        $defs: {
+          banConfig: {
+            oneOf: [
+              {
+                description: 'Bans the type with the default message',
+                enum: [true],
+                type: 'boolean',
+              },
+              {
+                description: 'Bans the type with a custom message',
+                type: 'string',
+              },
+              {
+                additionalProperties: false,
+                description: 'Bans a type',
+                properties: {
+                  fixWith: {
+                    description:
+                      'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
+                    type: 'string',
+                  },
+                  message: {
+                    description: 'Custom error message',
+                    type: 'string',
+                  },
+                  suggest: {
+                    description: 'Types to suggest replacing with.',
+                    items: { type: 'string' },
+                    type: 'array',
+                  },
+                },
+                type: 'object',
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          types: {
+            additionalProperties: {
+              $ref: '#/items/0/$defs/banConfig',
+            },
+            type: 'object',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-restricted-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 152d536239e8..049b656f1c6f 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -1,5 +1,6 @@
-import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import { DefinitionType, ScopeType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -11,9 +12,9 @@ type Options = [
     allow?: string[];
     builtinGlobals?: boolean;
     hoist?: 'all' | 'functions' | 'never';
+    ignoreFunctionTypeParameterNameValueShadow?: boolean;
     ignoreOnInitialization?: boolean;
     ignoreTypeValueShadow?: boolean;
-    ignoreFunctionTypeParameterNameValueShadow?: boolean;
   },
 ];
 
@@ -24,60 +25,6 @@ const allowedFunctionVariableDefTypes = new Set([
 ]);
 
 export default createRule<Options, MessageIds>({
-  name: 'no-shadow',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow variable declarations from shadowing variables declared in the outer scope',
-      extendsBaseRule: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          builtinGlobals: {
-            type: 'boolean',
-          },
-          hoist: {
-            type: 'string',
-            enum: ['all', 'functions', 'never'],
-          },
-          allow: {
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-          ignoreOnInitialization: {
-            type: 'boolean',
-          },
-          ignoreTypeValueShadow: {
-            type: 'boolean',
-          },
-          ignoreFunctionTypeParameterNameValueShadow: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      noShadow:
-        "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
-      noShadowGlobal: "'{{name}}' is already a global variable.",
-    },
-  },
-  defaultOptions: [
-    {
-      allow: [],
-      builtinGlobals: false,
-      hoist: 'functions',
-      ignoreOnInitialization: false,
-      ignoreTypeValueShadow: true,
-      ignoreFunctionTypeParameterNameValueShadow: true,
-    },
-  ],
   create(context, [options]) {
     /**
      * Check if a scope is a TypeScript module augmenting the global namespace.
@@ -420,14 +367,14 @@ export default createRule<Options, MessageIds>({
           }
         } else if (
           [
-            AST_NODE_TYPES.FunctionDeclaration,
-            AST_NODE_TYPES.ClassDeclaration,
-            AST_NODE_TYPES.FunctionExpression,
-            AST_NODE_TYPES.ClassExpression,
             AST_NODE_TYPES.ArrowFunctionExpression,
             AST_NODE_TYPES.CatchClause,
-            AST_NODE_TYPES.ImportDeclaration,
+            AST_NODE_TYPES.ClassDeclaration,
+            AST_NODE_TYPES.ClassExpression,
             AST_NODE_TYPES.ExportNamedDeclaration,
+            AST_NODE_TYPES.FunctionDeclaration,
+            AST_NODE_TYPES.FunctionExpression,
+            AST_NODE_TYPES.ImportDeclaration,
           ].includes(node.type)
         ) {
           break;
@@ -515,13 +462,13 @@ export default createRule<Options, MessageIds>({
      */
     function getDeclaredLocation(
       variable: TSESLint.Scope.Variable,
-    ): { global: false; line: number; column: number } | { global: true } {
+    ): { column: number; global: false; line: number } | { global: true } {
       const identifier = variable.identifiers.at(0);
       if (identifier) {
         return {
+          column: identifier.loc.start.column + 1,
           global: false,
           line: identifier.loc.start.line,
-          column: identifier.loc.start.column + 1,
         };
       }
       return {
@@ -613,18 +560,18 @@ export default createRule<Options, MessageIds>({
             node: variable.identifiers[0],
             ...(location.global
               ? {
-                  messageId: 'noShadowGlobal',
                   data: {
                     name: variable.name,
                   },
+                  messageId: 'noShadowGlobal',
                 }
               : {
-                  messageId: 'noShadow',
                   data: {
                     name: variable.name,
-                    shadowedLine: location.line,
                     shadowedColumn: location.column,
+                    shadowedLine: location.line,
                   },
+                  messageId: 'noShadow',
                 }),
           });
         }
@@ -646,4 +593,58 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allow: [],
+      builtinGlobals: false,
+      hoist: 'functions',
+      ignoreFunctionTypeParameterNameValueShadow: true,
+      ignoreOnInitialization: false,
+      ignoreTypeValueShadow: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow variable declarations from shadowing variables declared in the outer scope',
+      extendsBaseRule: true,
+    },
+    messages: {
+      noShadow:
+        "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
+      noShadowGlobal: "'{{name}}' is already a global variable.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: {
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          builtinGlobals: {
+            type: 'boolean',
+          },
+          hoist: {
+            enum: ['all', 'functions', 'never'],
+            type: 'string',
+          },
+          ignoreFunctionTypeParameterNameValueShadow: {
+            type: 'boolean',
+          },
+          ignoreOnInitialization: {
+            type: 'boolean',
+          },
+          ignoreTypeValueShadow: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-shadow',
 });
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 98006e56328d..7bee02498dc0 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -12,46 +13,6 @@ type Options = [
 type MessageIds = 'thisAssignment' | 'thisDestructure';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-this-alias',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow aliasing `this`',
-      recommended: 'recommended',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allowDestructuring: {
-            description:
-              'Whether to ignore destructurings, such as `const { props, state } = this`.',
-            type: 'boolean',
-          },
-          allowedNames: {
-            description:
-              'Names to ignore, such as ["self"] for `const self = this;`.',
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-      },
-    ],
-    messages: {
-      thisAssignment: "Unexpected aliasing of 'this' to local variable.",
-      thisDestructure:
-        "Unexpected aliasing of members of 'this' to local variables.",
-    },
-  },
-  defaultOptions: [
-    {
-      allowDestructuring: true,
-      allowedNames: [],
-    },
-  ],
   create(context, [{ allowDestructuring, allowedNames }]) {
     return {
       "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(
@@ -71,14 +32,54 @@ export default createRule<Options, MessageIds>({
             : false;
         if (!hasAllowedName) {
           context.report({
-            node: id,
             messageId:
               id.type === AST_NODE_TYPES.Identifier
                 ? 'thisAssignment'
                 : 'thisDestructure',
+            node: id,
           });
         }
       },
     };
   },
+  defaultOptions: [
+    {
+      allowDestructuring: true,
+      allowedNames: [],
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow aliasing `this`',
+      recommended: 'recommended',
+    },
+    messages: {
+      thisAssignment: "Unexpected aliasing of 'this' to local variable.",
+      thisDestructure:
+        "Unexpected aliasing of members of 'this' to local variables.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowDestructuring: {
+            description:
+              'Whether to ignore destructurings, such as `const { props, state } = this`.',
+            type: 'boolean',
+          },
+          allowedNames: {
+            description:
+              'Names to ignore, such as ["self"] for `const self = this;`.',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-this-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index 53e64a3b5c69..adf47dad6248 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -6,8 +7,8 @@ import { createRule } from '../util';
 type Values =
   | 'always'
   | 'in-intersections'
-  | 'in-unions-and-intersections'
   | 'in-unions'
+  | 'in-unions-and-intersections'
   | 'never';
 
 type Options = [
@@ -16,10 +17,10 @@ type Options = [
     allowCallbacks?: 'always' | 'never';
     allowConditionalTypes?: 'always' | 'never';
     allowConstructors?: 'always' | 'never';
+    allowGenerics?: 'always' | 'never';
     allowLiterals?: Values;
     allowMappedTypes?: Values;
     allowTupleTypes?: Values;
-    allowGenerics?: 'always' | 'never';
   },
 ];
 type MessageIds = 'noCompositionAlias' | 'noTypeAlias';
@@ -28,94 +29,11 @@ type CompositionType =
   | AST_NODE_TYPES.TSIntersectionType
   | AST_NODE_TYPES.TSUnionType;
 interface TypeWithLabel {
-  node: TSESTree.Node;
   compositionType: CompositionType | null;
+  node: TSESTree.Node;
 }
 
 export default createRule<Options, MessageIds>({
-  name: 'no-type-alias',
-  meta: {
-    deprecated: true,
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow type aliases',
-      // too opinionated to be recommended
-    },
-    messages: {
-      noTypeAlias: 'Type {{alias}} are not allowed.',
-      noCompositionAlias:
-        '{{typeName}} in {{compositionType}} types are not allowed.',
-    },
-    schema: [
-      {
-        $defs: {
-          expandedOptions: {
-            type: 'string',
-            enum: [
-              'always',
-              'never',
-              'in-unions',
-              'in-intersections',
-              'in-unions-and-intersections',
-            ] satisfies Values[],
-          },
-          simpleOptions: {
-            type: 'string',
-            enum: ['always', 'never'],
-          },
-        },
-        type: 'object',
-        properties: {
-          allowAliases: {
-            description: 'Whether to allow direct one-to-one type aliases.',
-            $ref: '#/items/0/$defs/expandedOptions',
-          },
-          allowCallbacks: {
-            description: 'Whether to allow type aliases for callbacks.',
-            $ref: '#/items/0/$defs/simpleOptions',
-          },
-          allowConditionalTypes: {
-            description: 'Whether to allow type aliases for conditional types.',
-            $ref: '#/items/0/$defs/simpleOptions',
-          },
-          allowConstructors: {
-            description: 'Whether to allow type aliases with constructors.',
-            $ref: '#/items/0/$defs/simpleOptions',
-          },
-          allowLiterals: {
-            description:
-              'Whether to allow type aliases with object literal types.',
-            $ref: '#/items/0/$defs/expandedOptions',
-          },
-          allowMappedTypes: {
-            description: 'Whether to allow type aliases with mapped types.',
-            $ref: '#/items/0/$defs/expandedOptions',
-          },
-          allowTupleTypes: {
-            description: 'Whether to allow type aliases with tuple types.',
-            $ref: '#/items/0/$defs/expandedOptions',
-          },
-          allowGenerics: {
-            description: 'Whether to allow type aliases with generic types.',
-            $ref: '#/items/0/$defs/simpleOptions',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowAliases: 'never',
-      allowCallbacks: 'never',
-      allowConditionalTypes: 'never',
-      allowConstructors: 'never',
-      allowLiterals: 'never',
-      allowMappedTypes: 'never',
-      allowTupleTypes: 'never',
-      allowGenerics: 'never',
-    },
-  ],
   create(
     context,
     [
@@ -124,10 +42,10 @@ export default createRule<Options, MessageIds>({
         allowCallbacks,
         allowConditionalTypes,
         allowConstructors,
+        allowGenerics,
         allowLiterals,
         allowMappedTypes,
         allowTupleTypes,
-        allowGenerics,
       },
     ],
   ) {
@@ -189,17 +107,15 @@ export default createRule<Options, MessageIds>({
     ): void {
       if (isRoot) {
         return context.report({
-          node,
-          messageId: 'noTypeAlias',
           data: {
             alias: type.toLowerCase(),
           },
+          messageId: 'noTypeAlias',
+          node,
         });
       }
 
       return context.report({
-        node,
-        messageId: 'noCompositionAlias',
         data: {
           compositionType:
             compositionType === AST_NODE_TYPES.TSUnionType
@@ -207,6 +123,8 @@ export default createRule<Options, MessageIds>({
               : 'intersection',
           typeName: type,
         },
+        messageId: 'noCompositionAlias',
+        node,
       });
     }
 
@@ -330,7 +248,7 @@ export default createRule<Options, MessageIds>({
           return acc;
         }, []);
       }
-      return [{ node, compositionType }];
+      return [{ compositionType, node }];
     }
 
     return {
@@ -348,4 +266,87 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowAliases: 'never',
+      allowCallbacks: 'never',
+      allowConditionalTypes: 'never',
+      allowConstructors: 'never',
+      allowGenerics: 'never',
+      allowLiterals: 'never',
+      allowMappedTypes: 'never',
+      allowTupleTypes: 'never',
+    },
+  ],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: 'Disallow type aliases',
+      // too opinionated to be recommended
+    },
+    messages: {
+      noCompositionAlias:
+        '{{typeName}} in {{compositionType}} types are not allowed.',
+      noTypeAlias: 'Type {{alias}} are not allowed.',
+    },
+    schema: [
+      {
+        $defs: {
+          expandedOptions: {
+            enum: [
+              'always',
+              'never',
+              'in-unions',
+              'in-intersections',
+              'in-unions-and-intersections',
+            ] satisfies Values[],
+            type: 'string',
+          },
+          simpleOptions: {
+            enum: ['always', 'never'],
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          allowAliases: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow direct one-to-one type aliases.',
+          },
+          allowCallbacks: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases for callbacks.',
+          },
+          allowConditionalTypes: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases for conditional types.',
+          },
+          allowConstructors: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases with constructors.',
+          },
+          allowGenerics: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases with generic types.',
+          },
+          allowLiterals: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description:
+              'Whether to allow type aliases with object literal types.',
+          },
+          allowMappedTypes: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow type aliases with mapped types.',
+          },
+          allowTupleTypes: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow type aliases with tuple types.',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-type-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 17732e926868..4d9df9513e96 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -14,8 +15,8 @@ type MessageIds =
 
 type Options = [
   {
-    allowComparingNullableBooleansToTrue?: boolean;
     allowComparingNullableBooleansToFalse?: boolean;
+    allowComparingNullableBooleansToTrue?: boolean;
   },
 ];
 
@@ -30,53 +31,6 @@ interface BooleanComparisonWithTypeInformation extends BooleanComparison {
 }
 
 export default createRule<Options, MessageIds>({
-  name: 'no-unnecessary-boolean-literal-compare',
-  meta: {
-    docs: {
-      description:
-        'Disallow unnecessary equality comparisons against boolean literals',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      direct:
-        'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
-      negated:
-        'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
-      comparingNullableToTrueDirect:
-        'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.',
-      comparingNullableToTrueNegated:
-        'This expression unnecessarily compares a nullable boolean value to true instead of negating it.',
-      comparingNullableToFalse:
-        'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowComparingNullableBooleansToTrue: {
-            description:
-              'Whether to allow comparisons between nullable boolean variables and `true`.',
-            type: 'boolean',
-          },
-          allowComparingNullableBooleansToFalse: {
-            description:
-              'Whether to allow comparisons between nullable boolean variables and `false`.',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    type: 'suggestion',
-  },
-  defaultOptions: [
-    {
-      allowComparingNullableBooleansToTrue: true,
-      allowComparingNullableBooleansToFalse: true,
-    },
-  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -176,8 +130,8 @@ export default createRule<Options, MessageIds>({
         const negated = !comparisonType.isPositive;
 
         return {
-          literalBooleanInComparison,
           expression,
+          literalBooleanInComparison,
           negated,
         };
       }
@@ -268,6 +222,53 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowComparingNullableBooleansToFalse: true,
+      allowComparingNullableBooleansToTrue: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow unnecessary equality comparisons against boolean literals',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      comparingNullableToFalse:
+        'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.',
+      comparingNullableToTrueDirect:
+        'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.',
+      comparingNullableToTrueNegated:
+        'This expression unnecessarily compares a nullable boolean value to true instead of negating it.',
+      direct:
+        'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
+      negated:
+        'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowComparingNullableBooleansToFalse: {
+            description:
+              'Whether to allow comparisons between nullable boolean variables and `false`.',
+            type: 'boolean',
+          },
+          allowComparingNullableBooleansToTrue: {
+            description:
+              'Whether to allow comparisons between nullable boolean variables and `true`.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-boolean-literal-compare',
 });
 
 interface EqualsKind {
@@ -277,27 +278,27 @@ interface EqualsKind {
 
 function getEqualsKind(operator: string): EqualsKind | undefined {
   switch (operator) {
-    case '==':
+    case '!=':
       return {
-        isPositive: true,
+        isPositive: false,
         isStrict: false,
       };
 
-    case '===':
+    case '!==':
       return {
-        isPositive: true,
+        isPositive: false,
         isStrict: true,
       };
 
-    case '!=':
+    case '==':
       return {
-        isPositive: false,
+        isPositive: true,
         isStrict: false,
       };
 
-    case '!==':
+    case '===':
       return {
-        isPositive: false,
+        isPositive: true,
         isStrict: true,
       };
 
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index e3bf94a30c78..4e8fea5ee6af 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -87,61 +88,6 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
-  name: 'no-unnecessary-condition',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow conditionals where the type is always truthy or always falsy',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowConstantLoopConditions: {
-            description:
-              'Whether to ignore constant loop conditions, such as `while (true)`.',
-            type: 'boolean',
-          },
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            description:
-              'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    fixable: 'code',
-    messages: {
-      alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
-      alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
-      alwaysTruthyFunc:
-        'This callback should return a conditional, but return is always truthy.',
-      alwaysFalsyFunc:
-        'This callback should return a conditional, but return is always falsy.',
-      neverNullish:
-        'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
-      alwaysNullish:
-        'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
-      literalBooleanExpression:
-        'Unnecessary conditional, both sides of the expression are literal values.',
-      noOverlapBooleanExpression:
-        'Unnecessary conditional, the types have no overlap.',
-      never: 'Unnecessary conditional, value is `never`.',
-      neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-    },
-  },
-  defaultOptions: [
-    {
-      allowConstantLoopConditions: false,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-    },
-  ],
   create(
     context,
     [
@@ -166,8 +112,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          start: { line: 0, column: 0 },
-          end: { line: 0, column: 0 },
+          end: { column: 0, line: 0 },
+          start: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
@@ -291,7 +237,7 @@ export default createRule<Options, MessageId>({
       }
 
       if (messageId) {
-        context.report({ node, messageId });
+        context.report({ messageId, node });
       }
     }
 
@@ -339,7 +285,7 @@ export default createRule<Options, MessageId>({
       }
 
       if (messageId) {
-        context.report({ node, messageId });
+        context.report({ messageId, node });
       }
     }
 
@@ -372,7 +318,7 @@ export default createRule<Options, MessageId>({
       const leftType = getConstrainedTypeAtLocation(services, node.left);
       const rightType = getConstrainedTypeAtLocation(services, node.right);
       if (isLiteral(leftType) && isLiteral(rightType)) {
-        context.report({ node, messageId: 'literalBooleanExpression' });
+        context.report({ messageId: 'literalBooleanExpression', node });
         return;
       }
       // Workaround for https://github.com/microsoft/TypeScript/issues/37160
@@ -404,7 +350,7 @@ export default createRule<Options, MessageId>({
           (leftType.flags === NULL && !isComparable(rightType, NULL)) ||
           (rightType.flags === NULL && !isComparable(leftType, NULL))
         ) {
-          context.report({ node, messageId: 'noOverlapBooleanExpression' });
+          context.report({ messageId: 'noOverlapBooleanExpression', node });
           return;
         }
       }
@@ -517,14 +463,14 @@ export default createRule<Options, MessageId>({
         }
         if (!returnTypes.some(isPossiblyFalsy)) {
           return context.report({
-            node: callback,
             messageId: 'alwaysTruthyFunc',
+            node: callback,
           });
         }
         if (!returnTypes.some(isPossiblyTruthy)) {
           return context.report({
-            node: callback,
             messageId: 'alwaysFalsyFunc',
+            node: callback,
           });
         }
       }
@@ -654,7 +600,7 @@ export default createRule<Options, MessageId>({
     function checkOptionalChain(
       node: TSESTree.CallExpression | TSESTree.MemberExpression,
       beforeOperator: TSESTree.Node,
-      fix: '.' | '',
+      fix: '' | '.',
     ): void {
       // We only care if this step in the chain is optional. If just descend
       // from an optional chain, then that's fine.
@@ -686,12 +632,12 @@ export default createRule<Options, MessageId>({
       );
 
       context.report({
-        node,
-        loc: questionDotOperator.loc,
-        messageId: 'neverOptionalChain',
         fix(fixer) {
           return fixer.replaceText(questionDotOperator, fix);
         },
+        loc: questionDotOperator.loc,
+        messageId: 'neverOptionalChain',
+        node,
       });
     }
 
@@ -710,7 +656,7 @@ export default createRule<Options, MessageId>({
     ): void {
       // Similar to checkLogicalExpressionForUnnecessaryConditionals, since
       // a ||= b is equivalent to a || (a = b)
-      if (['||=', '&&='].includes(node.operator)) {
+      if (['&&=', '||='].includes(node.operator)) {
         checkNode(node.left);
       } else if (node.operator === '??=') {
         checkNodeForNullish(node.left);
@@ -721,14 +667,69 @@ export default createRule<Options, MessageId>({
       AssignmentExpression: checkAssignmentExpression,
       BinaryExpression: checkIfBinaryExpressionIsNecessaryConditional,
       CallExpression: checkCallExpression,
+      'CallExpression[optional = true]': checkOptionalCallExpression,
       ConditionalExpression: (node): void => checkNode(node.test),
       DoWhileStatement: checkIfLoopIsNecessaryConditional,
       ForStatement: checkIfLoopIsNecessaryConditional,
       IfStatement: (node): void => checkNode(node.test),
       LogicalExpression: checkLogicalExpressionForUnnecessaryConditionals,
-      WhileStatement: checkIfLoopIsNecessaryConditional,
       'MemberExpression[optional = true]': checkOptionalMemberExpression,
-      'CallExpression[optional = true]': checkOptionalCallExpression,
+      WhileStatement: checkIfLoopIsNecessaryConditional,
     };
   },
+  defaultOptions: [
+    {
+      allowConstantLoopConditions: false,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow conditionals where the type is always truthy or always falsy',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
+      alwaysFalsyFunc:
+        'This callback should return a conditional, but return is always falsy.',
+      alwaysNullish:
+        'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
+      alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
+      alwaysTruthyFunc:
+        'This callback should return a conditional, but return is always truthy.',
+      literalBooleanExpression:
+        'Unnecessary conditional, both sides of the expression are literal values.',
+      never: 'Unnecessary conditional, value is `never`.',
+      neverNullish:
+        'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
+      neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
+      noOverlapBooleanExpression:
+        'Unnecessary conditional, the types have no overlap.',
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowConstantLoopConditions: {
+            description:
+              'Whether to ignore constant loop conditions, such as `while (true)`.',
+            type: 'boolean',
+          },
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            description:
+              'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-condition',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index 4e589a93af5c..7a5751430309 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -1,5 +1,6 @@
-import { DefinitionType } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 
 import { createRule, getStaticStringValue, nullThrows } from '../util';
@@ -7,24 +8,10 @@ import { createRule, getStaticStringValue, nullThrows } from '../util';
 const UNNECESSARY_OPERATORS = new Set(['=', '&&=', '||=', '??=']);
 
 export default createRule({
-  name: 'no-unnecessary-parameter-property-assignment',
-  meta: {
-    docs: {
-      description:
-        'Disallow unnecessary assignment of constructor property parameter',
-    },
-    messages: {
-      unnecessaryAssign:
-        'This assignment is unnecessary since it is already assigned by a parameter property.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     const reportInfoStack: {
-      assignedBeforeUnnecessary: Set<string>;
       assignedBeforeConstructor: Set<string>;
+      assignedBeforeUnnecessary: Set<string>;
       unnecessaryAssignments: {
         name: string;
         node: TSESTree.AssignmentExpression;
@@ -57,9 +44,9 @@ export default createRule({
     function findParentFunction(
       node: TSESTree.Node | undefined,
     ):
-      | TSESTree.FunctionExpression
-      | TSESTree.FunctionDeclaration
       | TSESTree.ArrowFunctionExpression
+      | TSESTree.FunctionDeclaration
+      | TSESTree.FunctionExpression
       | undefined {
       if (
         !node ||
@@ -136,51 +123,24 @@ export default createRule({
     return {
       ClassBody(): void {
         reportInfoStack.push({
-          unnecessaryAssignments: [],
-          assignedBeforeUnnecessary: new Set(),
           assignedBeforeConstructor: new Set(),
+          assignedBeforeUnnecessary: new Set(),
+          unnecessaryAssignments: [],
         });
       },
       'ClassBody:exit'(): void {
-        const { unnecessaryAssignments, assignedBeforeConstructor } =
+        const { assignedBeforeConstructor, unnecessaryAssignments } =
           nullThrows(reportInfoStack.pop(), 'The top stack should exist');
         unnecessaryAssignments.forEach(({ name, node }) => {
           if (assignedBeforeConstructor.has(name)) {
             return;
           }
           context.report({
-            node,
             messageId: 'unnecessaryAssign',
+            node,
           });
         });
       },
-      'PropertyDefinition AssignmentExpression'(
-        node: TSESTree.AssignmentExpression,
-      ): void {
-        const name = getPropertyName(node.left);
-
-        if (!name) {
-          return;
-        }
-
-        const functionNode = findParentFunction(node);
-        if (functionNode) {
-          if (
-            !(
-              isArrowIIFE(functionNode) &&
-              findParentPropertyDefinition(node)?.value === functionNode.parent
-            )
-          ) {
-            return;
-          }
-        }
-
-        const { assignedBeforeConstructor } = nullThrows(
-          reportInfoStack.at(-1),
-          'The top stack should exist',
-        );
-        assignedBeforeConstructor.add(name);
-      },
       "MethodDefinition[kind='constructor'] > FunctionExpression AssignmentExpression"(
         node: TSESTree.AssignmentExpression,
       ): void {
@@ -227,6 +187,47 @@ export default createRule({
           });
         }
       },
+      'PropertyDefinition AssignmentExpression'(
+        node: TSESTree.AssignmentExpression,
+      ): void {
+        const name = getPropertyName(node.left);
+
+        if (!name) {
+          return;
+        }
+
+        const functionNode = findParentFunction(node);
+        if (functionNode) {
+          if (
+            !(
+              isArrowIIFE(functionNode) &&
+              findParentPropertyDefinition(node)?.value === functionNode.parent
+            )
+          ) {
+            return;
+          }
+        }
+
+        const { assignedBeforeConstructor } = nullThrows(
+          reportInfoStack.at(-1),
+          'The top stack should exist',
+        );
+        assignedBeforeConstructor.add(name);
+      },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow unnecessary assignment of constructor property parameter',
+    },
+    messages: {
+      unnecessaryAssign:
+        'This assignment is unnecessary since it is already assigned by a parameter property.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-parameter-property-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index 434df4f56a32..aebd62131a9f 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -6,21 +7,6 @@ import * as ts from 'typescript';
 import { createRule, getParserServices } from '../util';
 
 export default createRule({
-  name: 'no-unnecessary-qualifier',
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary namespace qualifiers',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      unnecessaryQualifier:
-        "Qualifier is unnecessary since '{{ name }}' is in scope.",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     const namespacesInScope: ts.Node[] = [];
     let currentFailedNamespaceExpression: TSESTree.Node | null = null;
@@ -109,14 +95,14 @@ export default createRule({
       ) {
         currentFailedNamespaceExpression = node;
         context.report({
-          node: qualifier,
-          messageId: 'unnecessaryQualifier',
           data: {
             name: context.sourceCode.getText(name),
           },
           fix(fixer) {
             return fixer.removeRange([qualifier.range[0], name.range[0]]);
           },
+          messageId: 'unnecessaryQualifier',
+          node: qualifier,
         });
       }
     }
@@ -157,25 +143,15 @@ export default createRule({
     }
 
     return {
-      'TSModuleDeclaration > TSModuleBlock'(
-        node: TSESTree.TSModuleBlock,
-      ): void {
-        enterDeclaration(node.parent);
-      },
-      TSEnumDeclaration: enterDeclaration,
-      'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]':
-        enterDeclaration,
       'ExportNamedDeclaration[declaration.type="TSEnumDeclaration"]':
         enterDeclaration,
-      'TSModuleDeclaration:exit': exitDeclaration,
-      'TSEnumDeclaration:exit': exitDeclaration,
-      'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]:exit':
-        exitDeclaration,
       'ExportNamedDeclaration[declaration.type="TSEnumDeclaration"]:exit':
         exitDeclaration,
-      TSQualifiedName(node: TSESTree.TSQualifiedName): void {
-        visitNamespaceAccess(node, node.left, node.right);
-      },
+      'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]':
+        enterDeclaration,
+      'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]:exit':
+        exitDeclaration,
+      'MemberExpression:exit': resetCurrentNamespaceExpression,
       'MemberExpression[computed=false]'(
         node: TSESTree.MemberExpression,
       ): void {
@@ -184,8 +160,33 @@ export default createRule({
           visitNamespaceAccess(node, node.object, property);
         }
       },
+      TSEnumDeclaration: enterDeclaration,
+      'TSEnumDeclaration:exit': exitDeclaration,
+      'TSModuleDeclaration > TSModuleBlock'(
+        node: TSESTree.TSModuleBlock,
+      ): void {
+        enterDeclaration(node.parent);
+      },
+      'TSModuleDeclaration:exit': exitDeclaration,
+      TSQualifiedName(node: TSESTree.TSQualifiedName): void {
+        visitNamespaceAccess(node, node.left, node.right);
+      },
       'TSQualifiedName:exit': resetCurrentNamespaceExpression,
-      'MemberExpression:exit': resetCurrentNamespaceExpression,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary namespace qualifiers',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      unnecessaryQualifier:
+        "Qualifier is unnecessary since '{{ name }}' is in scope.",
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-qualifier',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index dc15a9bbcd06..0698a772a372 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -25,28 +26,12 @@ function endsWithUnescapedDollarSign(str: string): boolean {
 }
 
 export default createRule<[], MessageId>({
-  name: 'no-unnecessary-template-expression',
-  meta: {
-    fixable: 'code',
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow unnecessary template expressions',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      noUnnecessaryTemplateExpression:
-        'Template literal expression is unnecessary and can be simplified.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
 
     function isUnderlyingTypeString(
       expression: TSESTree.Expression,
-    ): expression is TSESTree.StringLiteral | TSESTree.Identifier {
+    ): expression is TSESTree.Identifier | TSESTree.StringLiteral {
       const type = getConstrainedTypeAtLocation(services, expression);
 
       const isString = (t: ts.Type): boolean => {
@@ -105,17 +90,17 @@ export default createRule<[], MessageId>({
 
         if (hasSingleStringVariable) {
           context.report({
-            node: node.expressions[0],
-            messageId: 'noUnnecessaryTemplateExpression',
             fix(fixer): TSESLint.RuleFix | null {
               const wrappingCode = getMovedNodeCode({
-                sourceCode: context.sourceCode,
-                nodeToMove: node.expressions[0],
                 destinationNode: node,
+                nodeToMove: node.expressions[0],
+                sourceCode: context.sourceCode,
               });
 
               return fixer.replaceText(node, wrappingCode);
             },
+            messageId: 'noUnnecessaryTemplateExpression',
+            node: node.expressions[0],
           });
 
           return;
@@ -246,8 +231,6 @@ export default createRule<[], MessageId>({
           }
 
           context.report({
-            node: expression,
-            messageId: 'noUnnecessaryTemplateExpression',
             fix(fixer): TSESLint.RuleFix[] {
               return [
                 // Remove the quasis' parts that are related to the current expression.
@@ -263,9 +246,27 @@ export default createRule<[], MessageId>({
                 ...fixers.flatMap(cb => cb(fixer)),
               ];
             },
+            messageId: 'noUnnecessaryTemplateExpression',
+            node: expression,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary template expressions',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      noUnnecessaryTemplateExpression:
+        'Template literal expression is unnecessary and can be simplified.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-template-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index d482ef1b672a..cb50145babfb 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -23,22 +24,6 @@ type ParameterCapableTSNode =
 type MessageIds = 'unnecessaryTypeParameter';
 
 export default createRule<[], MessageIds>({
-  name: 'no-unnecessary-type-arguments',
-  meta: {
-    docs: {
-      description: 'Disallow type arguments that are equal to the default',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      unnecessaryTypeParameter:
-        'This is the default value for this type parameter, so it can be omitted.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -96,14 +81,14 @@ export default createRule<[], MessageIds>({
       }
 
       context.report({
-        node: arg,
-        messageId: 'unnecessaryTypeParameter',
         fix: fixer =>
           fixer.removeRange(
             i === 0
               ? esParameters.range
               : [esParameters.params[i - 1].range[1], arg.range[1]],
           ),
+        messageId: 'unnecessaryTypeParameter',
+        node: arg,
       });
     }
 
@@ -118,6 +103,22 @@ export default createRule<[], MessageIds>({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow type arguments that are equal to the default',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      unnecessaryTypeParameter:
+        'This is the default value for this type parameter, so it can be omitted.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-type-arguments',
 });
 
 function getTypeParametersFromNode(
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index 6b69d9e381d4..6a91baf9336b 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -1,5 +1,6 @@
 import type { Scope } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -25,39 +26,6 @@ type Options = [
 type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-unnecessary-type-assertion',
-  meta: {
-    docs: {
-      description:
-        'Disallow type assertions that do not change the type of an expression',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      unnecessaryAssertion:
-        'This assertion is unnecessary since it does not change the type of the expression.',
-      contextuallyUnnecessary:
-        'This assertion is unnecessary since the receiver accepts the original type of the expression.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          typesToIgnore: {
-            description: 'A list of type names to ignore.',
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-      },
-    ],
-    type: 'suggestion',
-  },
-  defaultOptions: [{}],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -207,6 +175,83 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
+      'TSAsExpression, TSTypeAssertion'(
+        node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
+      ): void {
+        if (
+          options.typesToIgnore?.includes(
+            context.sourceCode.getText(node.typeAnnotation),
+          )
+        ) {
+          return;
+        }
+
+        const castType = services.getTypeAtLocation(node);
+        const uncastType = services.getTypeAtLocation(node.expression);
+        const typeIsUnchanged = isTypeUnchanged(uncastType, castType);
+
+        const wouldSameTypeBeInferred = castType.isLiteral()
+          ? isImplicitlyNarrowedConstDeclaration(node)
+          : !isConstAssertion(node.typeAnnotation);
+
+        if (typeIsUnchanged && wouldSameTypeBeInferred) {
+          context.report({
+            fix(fixer) {
+              if (node.type === AST_NODE_TYPES.TSTypeAssertion) {
+                const openingAngleBracket = nullThrows(
+                  context.sourceCode.getTokenBefore(
+                    node.typeAnnotation,
+                    token =>
+                      token.type === AST_TOKEN_TYPES.Punctuator &&
+                      token.value === '<',
+                  ),
+                  NullThrowsReasons.MissingToken('<', 'type annotation'),
+                );
+                const closingAngleBracket = nullThrows(
+                  context.sourceCode.getTokenAfter(
+                    node.typeAnnotation,
+                    token =>
+                      token.type === AST_TOKEN_TYPES.Punctuator &&
+                      token.value === '>',
+                  ),
+                  NullThrowsReasons.MissingToken('>', 'type annotation'),
+                );
+
+                // < ( number ) > ( 3 + 5 )
+                // ^---remove---^
+                return fixer.removeRange([
+                  openingAngleBracket.range[0],
+                  closingAngleBracket.range[1],
+                ]);
+              }
+              // `as` is always present in TSAsExpression
+              const asToken = nullThrows(
+                context.sourceCode.getTokenAfter(
+                  node.expression,
+                  token =>
+                    token.type === AST_TOKEN_TYPES.Identifier &&
+                    token.value === 'as',
+                ),
+                NullThrowsReasons.MissingToken('>', 'type annotation'),
+              );
+              const tokenBeforeAs = nullThrows(
+                context.sourceCode.getTokenBefore(asToken, {
+                  includeComments: true,
+                }),
+                NullThrowsReasons.MissingToken('comment', 'as'),
+              );
+
+              // ( 3 + 5 )  as  number
+              //          ^--remove--^
+              return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
+            },
+            messageId: 'unnecessaryAssertion',
+            node,
+          });
+        }
+
+        // TODO - add contextually unnecessary check for this
+      },
       TSNonNullExpression(node): void {
         if (
           node.parent.type === AST_NODE_TYPES.AssignmentExpression &&
@@ -214,14 +259,14 @@ export default createRule<Options, MessageIds>({
         ) {
           if (node.parent.left === node) {
             context.report({
-              node,
-              messageId: 'contextuallyUnnecessary',
               fix(fixer) {
                 return fixer.removeRange([
                   node.expression.range[1],
                   node.range[1],
                 ]);
               },
+              messageId: 'contextuallyUnnecessary',
+              node,
             });
           }
           // for all other = assignments we ignore non-null checks
@@ -244,11 +289,11 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            node,
-            messageId: 'unnecessaryAssertion',
             fix(fixer) {
               return fixer.removeRange([node.range[1] - 1, node.range[1]]);
             },
+            messageId: 'unnecessaryAssertion',
+            node,
           });
         } else {
           // we know it's a nullable type
@@ -292,96 +337,52 @@ export default createRule<Options, MessageIds>({
 
             if (isValidUndefined && isValidNull && isValidVoid) {
               context.report({
-                node,
-                messageId: 'contextuallyUnnecessary',
                 fix(fixer) {
                   return fixer.removeRange([
                     node.expression.range[1],
                     node.range[1],
                   ]);
                 },
+                messageId: 'contextuallyUnnecessary',
+                node,
               });
             }
           }
         }
       },
-      'TSAsExpression, TSTypeAssertion'(
-        node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
-      ): void {
-        if (
-          options.typesToIgnore?.includes(
-            context.sourceCode.getText(node.typeAnnotation),
-          )
-        ) {
-          return;
-        }
-
-        const castType = services.getTypeAtLocation(node);
-        const uncastType = services.getTypeAtLocation(node.expression);
-        const typeIsUnchanged = isTypeUnchanged(uncastType, castType);
-
-        const wouldSameTypeBeInferred = castType.isLiteral()
-          ? isImplicitlyNarrowedConstDeclaration(node)
-          : !isConstAssertion(node.typeAnnotation);
-
-        if (typeIsUnchanged && wouldSameTypeBeInferred) {
-          context.report({
-            node,
-            messageId: 'unnecessaryAssertion',
-            fix(fixer) {
-              if (node.type === AST_NODE_TYPES.TSTypeAssertion) {
-                const openingAngleBracket = nullThrows(
-                  context.sourceCode.getTokenBefore(
-                    node.typeAnnotation,
-                    token =>
-                      token.type === AST_TOKEN_TYPES.Punctuator &&
-                      token.value === '<',
-                  ),
-                  NullThrowsReasons.MissingToken('<', 'type annotation'),
-                );
-                const closingAngleBracket = nullThrows(
-                  context.sourceCode.getTokenAfter(
-                    node.typeAnnotation,
-                    token =>
-                      token.type === AST_TOKEN_TYPES.Punctuator &&
-                      token.value === '>',
-                  ),
-                  NullThrowsReasons.MissingToken('>', 'type annotation'),
-                );
-
-                // < ( number ) > ( 3 + 5 )
-                // ^---remove---^
-                return fixer.removeRange([
-                  openingAngleBracket.range[0],
-                  closingAngleBracket.range[1],
-                ]);
-              }
-              // `as` is always present in TSAsExpression
-              const asToken = nullThrows(
-                context.sourceCode.getTokenAfter(
-                  node.expression,
-                  token =>
-                    token.type === AST_TOKEN_TYPES.Identifier &&
-                    token.value === 'as',
-                ),
-                NullThrowsReasons.MissingToken('>', 'type annotation'),
-              );
-              const tokenBeforeAs = nullThrows(
-                context.sourceCode.getTokenBefore(asToken, {
-                  includeComments: true,
-                }),
-                NullThrowsReasons.MissingToken('comment', 'as'),
-              );
-
-              // ( 3 + 5 )  as  number
-              //          ^--remove--^
-              return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
+    };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description:
+        'Disallow type assertions that do not change the type of an expression',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      contextuallyUnnecessary:
+        'This assertion is unnecessary since the receiver accepts the original type of the expression.',
+      unnecessaryAssertion:
+        'This assertion is unnecessary since it does not change the type of the expression.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          typesToIgnore: {
+            description: 'A list of type names to ignore.',
+            items: {
+              type: 'string',
             },
-          });
-        }
-
-        // TODO - add contextually unnecessary check for this
+            type: 'array',
+          },
+        },
+        type: 'object',
       },
-    };
+    ],
+    type: 'suggestion',
   },
+  name: 'no-unnecessary-type-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index d31044ce86d2..4664ddfc4a47 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -1,10 +1,11 @@
-import { extname } from 'node:path';
-
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { extname } from 'node:path';
 import * as ts from 'typescript';
 
 import type { MakeRequired } from '../util';
+
 import { createRule } from '../util';
 
 type TypeParameterWithConstraint = MakeRequired<
@@ -13,23 +14,6 @@ type TypeParameterWithConstraint = MakeRequired<
 >;
 
 export default createRule({
-  name: 'no-unnecessary-type-constraint',
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary constraints on generic types',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      unnecessaryConstraint:
-        'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
-      removeUnnecessaryConstraint:
-        'Remove the unnecessary `{{constraint}}` constraint.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     // In theory, we could use the type checker for more advanced constraint types...
     // ...but in practice, these types are rare, and likely not worth requiring type info.
@@ -81,9 +65,10 @@ export default createRule({
             constraint,
             name: node.name.name,
           },
+          messageId: 'unnecessaryConstraint',
+          node,
           suggest: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: {
                 constraint,
               },
@@ -93,10 +78,9 @@ export default createRule({
                   shouldAddTrailingComma() ? ',' : '',
                 );
               },
+              messageId: 'removeUnnecessaryConstraint',
             },
           ],
-          messageId: 'unnecessaryConstraint',
-          node,
         });
       }
     };
@@ -114,4 +98,21 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary constraints on generic types',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      removeUnnecessaryConstraint:
+        'Remove the unnecessary `{{constraint}}` constraint.',
+      unnecessaryConstraint:
+        'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unnecessary-type-constraint',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index d1fa75410f1a..940c5fc05dbe 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -1,32 +1,20 @@
 import type { Reference } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
 import type { MakeRequired } from '../util';
+
 import { createRule, getParserServices } from '../util';
 
 type NodeWithTypeParameters = MakeRequired<
-  ts.SignatureDeclaration | ts.ClassLikeDeclaration,
+  ts.ClassLikeDeclaration | ts.SignatureDeclaration,
   'typeParameters'
 >;
 
 export default createRule({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow type parameters that aren't used multiple times",
-      requiresTypeChecking: true,
-      recommended: 'strict',
-    },
-    messages: {
-      sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unnecessary-type-parameters',
   create(context) {
     const parserServices = getParserServices(context);
 
@@ -67,11 +55,11 @@ export default createRule({
         context.report({
           data: {
             descriptor,
-            uses: identifierCounts === 1 ? 'never used' : 'used only once',
             name: typeParameter.name.text,
+            uses: identifierCounts === 1 ? 'never used' : 'used only once',
           },
-          node: esTypeParameter,
           messageId: 'sole',
+          node: esTypeParameter,
         });
       }
     }
@@ -98,6 +86,20 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow type parameters that aren't used multiple times",
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unnecessary-type-parameters',
 });
 
 function isTypeParameterRepeatedInAST(
@@ -399,9 +401,9 @@ function collectTypeParameterUsageCounts(
 }
 
 interface MappedType extends ts.ObjectType {
-  typeParameter?: ts.Type;
   constraintType?: ts.Type;
   templateType?: ts.Type;
+  typeParameter?: ts.Type;
 }
 
 function isMappedType(type: ts.Type): type is MappedType {
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index 08950fa8d732..57bc5984f96e 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type * as ts from 'typescript';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import {
   createRule,
   getParserServices,
@@ -25,24 +26,31 @@ const enum RestTypeKind {
 }
 type RestType =
   | {
-      type: ts.Type;
-      kind: RestTypeKind.Array;
       index: number;
+      kind: RestTypeKind.Array;
+      type: ts.Type;
     }
   | {
-      type: ts.Type;
-      kind: RestTypeKind.Other;
       index: number;
+      kind: RestTypeKind.Other;
+      type: ts.Type;
     }
   | {
-      typeArguments: readonly ts.Type[];
-      kind: RestTypeKind.Tuple;
       index: number;
+      kind: RestTypeKind.Tuple;
+      typeArguments: readonly ts.Type[];
     };
 
 class FunctionSignature {
+  private hasConsumedArguments = false;
+
   private parameterTypeIndex = 0;
 
+  private constructor(
+    private paramTypes: ts.Type[],
+    private restType: RestType | null,
+  ) {}
+
   public static create(
     checker: ts.TypeChecker,
     tsNode: ts.CallLikeExpression,
@@ -65,21 +73,21 @@ class FunctionSignature {
         // is a rest param
         if (checker.isArrayType(type)) {
           restType = {
-            type: checker.getTypeArguments(type)[0],
-            kind: RestTypeKind.Array,
             index: i,
+            kind: RestTypeKind.Array,
+            type: checker.getTypeArguments(type)[0],
           };
         } else if (checker.isTupleType(type)) {
           restType = {
-            typeArguments: checker.getTypeArguments(type),
-            kind: RestTypeKind.Tuple,
             index: i,
+            kind: RestTypeKind.Tuple,
+            typeArguments: checker.getTypeArguments(type),
           };
         } else {
           restType = {
-            type,
-            kind: RestTypeKind.Other,
             index: i,
+            kind: RestTypeKind.Other,
+            type,
           };
         }
         break;
@@ -91,12 +99,9 @@ class FunctionSignature {
     return new this(paramTypes, restType);
   }
 
-  private hasConsumedArguments = false;
-
-  private constructor(
-    private paramTypes: ts.Type[],
-    private restType: RestType | null,
-  ) {}
+  public consumeRemainingArguments(): void {
+    this.hasConsumedArguments = true;
+  }
 
   public getNextParameterType(): ts.Type | null {
     const index = this.parameterTypeIndex;
@@ -133,38 +138,15 @@ class FunctionSignature {
     }
     return this.paramTypes[index];
   }
-
-  public consumeRemainingArguments(): void {
-    this.hasConsumedArguments = true;
-  }
 }
 
 export default createRule<[], MessageIds>({
-  name: 'no-unsafe-argument',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow calling a function with a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeArgument:
-        'Unsafe argument of type `{{sender}}` assigned to a parameter of type `{{receiver}}`.',
-      unsafeTupleSpread:
-        'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
-      unsafeArraySpread: 'Unsafe spread of an `any` array type.',
-      unsafeSpread: 'Unsafe spread of an `any` type.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
 
     function checkUnsafeArguments(
-      args: TSESTree.Expression[] | TSESTree.CallExpressionArgument[],
+      args: TSESTree.CallExpressionArgument[] | TSESTree.Expression[],
       callee: TSESTree.Expression,
       node:
         | TSESTree.CallExpression
@@ -200,16 +182,16 @@ export default createRule<[], MessageIds>({
             if (isTypeAnyType(spreadArgType)) {
               // foo(...any)
               context.report({
-                node: argument,
                 messageId: 'unsafeSpread',
+                node: argument,
               });
             } else if (isTypeAnyArrayType(spreadArgType, checker)) {
               // foo(...any[])
 
               // TODO - we could break down the spread and compare the array type against each argument
               context.report({
-                node: argument,
                 messageId: 'unsafeArraySpread',
+                node: argument,
               });
             } else if (checker.isTupleType(spreadArgType)) {
               // foo(...[tuple1, tuple2])
@@ -230,12 +212,12 @@ export default createRule<[], MessageIds>({
                 );
                 if (result) {
                   context.report({
-                    node: argument,
-                    messageId: 'unsafeTupleSpread',
                     data: {
-                      sender: checker.typeToString(tupleType),
                       receiver: checker.typeToString(parameterType),
+                      sender: checker.typeToString(tupleType),
                     },
+                    messageId: 'unsafeTupleSpread',
+                    node: argument,
                   });
                 }
               }
@@ -267,12 +249,12 @@ export default createRule<[], MessageIds>({
             );
             if (result) {
               context.report({
-                node: argument,
-                messageId: 'unsafeArgument',
                 data: {
-                  sender: checker.typeToString(argumentType),
                   receiver: checker.typeToString(parameterType),
+                  sender: checker.typeToString(argumentType),
                 },
+                messageId: 'unsafeArgument',
+                node: argument,
               });
             }
           }
@@ -291,4 +273,23 @@ export default createRule<[], MessageIds>({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow calling a function with a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeArgument:
+        'Unsafe argument of type `{{sender}}` assigned to a parameter of type `{{receiver}}`.',
+      unsafeArraySpread: 'Unsafe spread of an `any` array type.',
+      unsafeSpread: 'Unsafe spread of an `any` type.',
+      unsafeTupleSpread:
+        'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-argument',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 22b3bfd09bd9..3caa4c1cd4bf 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type * as ts from 'typescript';
 
 import {
   createRule,
@@ -27,32 +28,6 @@ const enum ComparisonType {
 }
 
 export default createRule({
-  name: 'no-unsafe-assignment',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow assigning a value with type `any` to variables and properties',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      anyAssignment: 'Unsafe assignment of an {{sender}} value.',
-      anyAssignmentThis: [
-        'Unsafe assignment of an {{sender}} value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeArrayPattern:
-        'Unsafe array destructuring of an {{sender}} array value.',
-      unsafeArrayPatternFromTuple:
-        'Unsafe array destructuring of a tuple element with an {{sender}} value.',
-      unsafeAssignment:
-        'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
-      unsafeArraySpread: 'Unsafe spread of an {{sender}} value in an array.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -87,9 +62,9 @@ export default createRule({
       // const [x] = ([] as any[]);
       if (isTypeAnyArrayType(senderType, checker)) {
         context.report({
-          node: receiverNode,
-          messageId: 'unsafeArrayPattern',
           data: createData(senderType),
+          messageId: 'unsafeArrayPattern',
+          node: receiverNode,
         });
         return false;
       }
@@ -126,9 +101,9 @@ export default createRule({
         // check for the any type first so we can handle [[[x]]] = [any]
         if (isTypeAnyType(senderType)) {
           context.report({
-            node: receiverElement,
-            messageId: 'unsafeArrayPatternFromTuple',
             data: createData(senderType),
+            messageId: 'unsafeArrayPatternFromTuple',
+            node: receiverElement,
           });
           // we want to report on every invalid element in the tuple
           didReport = true;
@@ -213,9 +188,9 @@ export default createRule({
         // check for the any type first so we can handle {x: {y: z}} = {x: any}
         if (isTypeAnyType(senderType)) {
           context.report({
-            node: receiverProperty.value,
-            messageId: 'unsafeArrayPatternFromTuple',
             data: createData(senderType),
+            messageId: 'unsafeArrayPatternFromTuple',
+            node: receiverProperty.value,
           });
           didReport = true;
         } else if (
@@ -277,9 +252,9 @@ export default createRule({
         }
 
         context.report({
-          node: reportingNode,
-          messageId,
           data: createData(senderType),
+          messageId,
+          node: reportingNode,
         });
 
         return true;
@@ -299,11 +274,11 @@ export default createRule({
         return false;
       }
 
-      const { sender, receiver } = result;
+      const { receiver, sender } = result;
       context.report({
-        node: reportingNode,
-        messageId: 'unsafeAssignment',
         data: createData(sender, receiver),
+        messageId: 'unsafeAssignment',
+        node: reportingNode,
       });
       return true;
     }
@@ -324,8 +299,8 @@ export default createRule({
     ): Readonly<Record<string, unknown>> | undefined {
       if (receiverType) {
         return {
-          sender: `\`${checker.typeToString(senderType)}\``,
           receiver: `\`${checker.typeToString(receiverType)}\``,
+          sender: `\`${checker.typeToString(senderType)}\``,
         };
       }
       return {
@@ -336,29 +311,26 @@ export default createRule({
     }
 
     return {
-      'VariableDeclarator[init != null]'(
-        node: TSESTree.VariableDeclarator,
+      'AssignmentExpression[operator = "="], AssignmentPattern'(
+        node: TSESTree.AssignmentExpression | TSESTree.AssignmentPattern,
       ): void {
-        const init = nullThrows(
-          node.init,
-          NullThrowsReasons.MissingToken(node.type, 'init'),
-        );
         let didReport = checkAssignment(
-          node.id,
-          init,
+          node.left,
+          node.right,
           node,
-          getComparisonType(node.id.typeAnnotation),
+          // the variable already has some form of a type to compare against
+          ComparisonType.Basic,
         );
 
         if (!didReport) {
-          didReport = checkArrayDestructureHelper(node.id, init);
+          didReport = checkArrayDestructureHelper(node.left, node.right);
         }
         if (!didReport) {
-          checkObjectDestructureHelper(node.id, init);
+          checkObjectDestructureHelper(node.left, node.right);
         }
       },
       'PropertyDefinition[value != null]'(
-        node: TSESTree.PropertyDefinition & { value: NonNullable<unknown> },
+        node: { value: NonNullable<unknown> } & TSESTree.PropertyDefinition,
       ): void {
         checkAssignment(
           node.key,
@@ -367,22 +339,25 @@ export default createRule({
           getComparisonType(node.typeAnnotation),
         );
       },
-      'AssignmentExpression[operator = "="], AssignmentPattern'(
-        node: TSESTree.AssignmentExpression | TSESTree.AssignmentPattern,
+      'VariableDeclarator[init != null]'(
+        node: TSESTree.VariableDeclarator,
       ): void {
+        const init = nullThrows(
+          node.init,
+          NullThrowsReasons.MissingToken(node.type, 'init'),
+        );
         let didReport = checkAssignment(
-          node.left,
-          node.right,
+          node.id,
+          init,
           node,
-          // the variable already has some form of a type to compare against
-          ComparisonType.Basic,
+          getComparisonType(node.id.typeAnnotation),
         );
 
         if (!didReport) {
-          didReport = checkArrayDestructureHelper(node.left, node.right);
+          didReport = checkArrayDestructureHelper(node.id, init);
         }
         if (!didReport) {
-          checkObjectDestructureHelper(node.left, node.right);
+          checkObjectDestructureHelper(node.id, init);
         }
       },
       // object pattern props are checked via assignments
@@ -401,9 +376,9 @@ export default createRule({
         const restType = services.getTypeAtLocation(node.argument);
         if (isTypeAnyType(restType) || isTypeAnyArrayType(restType, checker)) {
           context.report({
-            node,
-            messageId: 'unsafeArraySpread',
             data: createData(restType),
+            messageId: 'unsafeArraySpread',
+            node,
           });
         }
       },
@@ -428,4 +403,30 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow assigning a value with type `any` to variables and properties',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      anyAssignment: 'Unsafe assignment of an {{sender}} value.',
+      anyAssignmentThis: [
+        'Unsafe assignment of an {{sender}} value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+      unsafeArrayPattern:
+        'Unsafe array destructuring of an {{sender}} array value.',
+      unsafeArrayPatternFromTuple:
+        'Unsafe array destructuring of a tuple element with an {{sender}} value.',
+      unsafeArraySpread: 'Unsafe spread of an {{sender}} value in an array.',
+      unsafeAssignment:
+        'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 6bdec17a4427..bf661c03d7d3 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 
 import {
@@ -16,26 +17,6 @@ type MessageIds =
   | 'unsafeTemplateTag';
 
 export default createRule<[], MessageIds>({
-  name: 'no-unsafe-call',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow calling a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeCall: 'Unsafe call of an {{type}} typed value.',
-      unsafeCallThis: [
-        'Unsafe call of an `any` typed value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeNew: 'Unsafe construction of an any type value.',
-      unsafeTemplateTag: 'Unsafe any typed template tag.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
@@ -68,11 +49,11 @@ export default createRule<[], MessageIds>({
         const isErrorType = tsutils.isIntrinsicErrorType(type);
 
         context.report({
-          node: reportingNode,
-          messageId,
           data: {
             type: isErrorType ? '`error` type' : '`any`',
           },
+          messageId,
+          node: reportingNode,
         });
       }
     }
@@ -91,4 +72,24 @@ export default createRule<[], MessageIds>({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow calling a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeCall: 'Unsafe call of an {{type}} typed value.',
+      unsafeCallThis: [
+        'Unsafe call of an `any` typed value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+      unsafeNew: 'Unsafe construction of an any type value.',
+      unsafeTemplateTag: 'Unsafe any typed template tag.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-call',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index 2d8a797b116f..9b698b2ace71 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -1,25 +1,11 @@
 import type { Scope } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'no-unsafe-declaration-merging',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow unsafe declaration merging',
-      recommended: 'recommended',
-      requiresTypeChecking: false,
-    },
-    messages: {
-      unsafeMerging:
-        'Unsafe declaration merging between classes and interfaces.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function checkUnsafeDeclaration(
       scope: Scope,
@@ -38,8 +24,8 @@ export default createRule({
 
       if (defs.some(def => def.node.type === unsafeKind)) {
         context.report({
-          node,
           messageId: 'unsafeMerging',
+          node,
         });
       }
     }
@@ -70,4 +56,19 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow unsafe declaration merging',
+      recommended: 'recommended',
+      requiresTypeChecking: false,
+    },
+    messages: {
+      unsafeMerging:
+        'Unsafe declaration merging between classes and interfaces.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-declaration-merging',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index ae7b33bc0e3e..eb1045559fa0 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -55,25 +56,6 @@ function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined {
 }
 
 export default createRule({
-  name: 'no-unsafe-enum-comparison',
-  meta: {
-    hasSuggestions: true,
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow comparing an enum value with a non-enum value',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      mismatchedCase:
-        'The case statement does not have a shared enum type with the switch predicate.',
-      mismatchedCondition:
-        'The two values in this comparison do not have a shared enum type.',
-      replaceValueWithEnum: 'Replace with an enum value comparison.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
@@ -145,7 +127,6 @@ export default createRule({
             node,
             suggest: [
               {
-                messageId: 'replaceValueWithEnum',
                 fix(fixer): TSESLint.RuleFix | null {
                   // Replace the right side with an enum key if possible:
                   //
@@ -178,6 +159,7 @@ export default createRule({
 
                   return null;
                 },
+                messageId: 'replaceValueWithEnum',
               },
             ],
           });
@@ -204,4 +186,23 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow comparing an enum value with a non-enum value',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      mismatchedCase:
+        'The case statement does not have a shared enum type with the switch predicate.',
+      mismatchedCondition:
+        'The two values in this comparison do not have a shared enum type.',
+      replaceValueWithEnum: 'Replace with an enum value comparison.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-unsafe-enum-comparison',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index 624c038f8ff7..53ae131c1016 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -1,26 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isReferenceToGlobalFunction } from '../util';
 
 export default createRule({
-  name: 'no-unsafe-function-type',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow using the unsafe built-in Function type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      bannedFunctionType: [
-        'The `Function` type accepts any function-like value.',
-        'Prefer explicitly defining any function parameters and return type.',
-      ].join('\n'),
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function checkBannedTypes(node: TSESTree.Node): void {
       if (
@@ -29,8 +13,8 @@ export default createRule({
         isReferenceToGlobalFunction('Function', node, context.sourceCode)
       ) {
         context.report({
-          node,
           messageId: 'bannedFunctionType',
+          node,
         });
       }
     }
@@ -47,4 +31,21 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow using the unsafe built-in Function type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      bannedFunctionType: [
+        'The `Function` type accepts any function-like value.',
+        'Prefer explicitly defining any function parameters and return type.',
+      ].join('\n'),
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 4fae2b560073..1d789d949925 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type * as ts from 'typescript';
 
 import {
   createRule,
@@ -12,37 +13,16 @@ import {
 } from '../util';
 
 const enum State {
-  Unsafe = 1,
   Safe = 2,
+  Unsafe = 1,
 }
 
-function createDataType(type: ts.Type): '`error` typed' | '`any`' {
+function createDataType(type: ts.Type): '`any`' | '`error` typed' {
   const isErrorType = tsutils.isIntrinsicErrorType(type);
   return isErrorType ? '`error` typed' : '`any`';
 }
 
 export default createRule({
-  name: 'no-unsafe-member-access',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow member access on a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeMemberExpression:
-        'Unsafe member access {{property}} on an {{type}} value.',
-      unsafeThisMemberExpression: [
-        'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeComputedMemberAccess:
-        'Computed name {{property}} resolves to an {{type}} value.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
@@ -94,12 +74,12 @@ export default createRule({
         }
 
         context.report({
-          node: node.property,
-          messageId,
           data: {
             property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
             type: createDataType(type),
           },
+          messageId,
+          node: node.property,
         });
       }
 
@@ -130,15 +110,36 @@ export default createRule({
         if (isTypeAnyType(type)) {
           const propertyName = context.sourceCode.getText(node);
           context.report({
-            node,
-            messageId: 'unsafeComputedMemberAccess',
             data: {
               property: `[${propertyName}]`,
               type: createDataType(type),
             },
+            messageId: 'unsafeComputedMemberAccess',
+            node,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow member access on a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeComputedMemberAccess:
+        'Computed name {{property}} resolves to an {{type}} value.',
+      unsafeMemberExpression:
+        'Unsafe member access {{property}} on an {{type}} value.',
+      unsafeThisMemberExpression: [
+        'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-member-access',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index 1b89ffbf8568..5bda8442c7c5 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -19,26 +20,6 @@ import {
 } from '../util';
 
 export default createRule({
-  name: 'no-unsafe-return',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow returning a value with type `any` from a function',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeReturn: 'Unsafe return of a value of type {{type}}.',
-      unsafeReturnThis: [
-        'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeReturnAssignment:
-        'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -192,8 +173,6 @@ export default createRule({
 
         // If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
         return context.report({
-          node: reportingNode,
-          messageId,
           data: {
             type: isErrorType
               ? 'error'
@@ -203,6 +182,8 @@ export default createRule({
                   ? '`Promise<any>`'
                   : '`any[]`',
           },
+          messageId,
+          node: reportingNode,
         });
       }
 
@@ -219,19 +200,20 @@ export default createRule({
           return;
         }
 
-        const { sender, receiver } = result;
+        const { receiver, sender } = result;
         return context.report({
-          node: reportingNode,
-          messageId: 'unsafeReturnAssignment',
           data: {
-            sender: checker.typeToString(sender),
             receiver: checker.typeToString(receiver),
+            sender: checker.typeToString(sender),
           },
+          messageId: 'unsafeReturnAssignment',
+          node: reportingNode,
         });
       }
     }
 
     return {
+      'ArrowFunctionExpression > :not(BlockStatement).body': checkReturn,
       ReturnStatement(node): void {
         const argument = node.argument;
         if (!argument) {
@@ -240,7 +222,26 @@ export default createRule({
 
         checkReturn(argument, node);
       },
-      'ArrowFunctionExpression > :not(BlockStatement).body': checkReturn,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow returning a value with type `any` from a function',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeReturn: 'Unsafe return of a value of type {{type}}.',
+      unsafeReturnAssignment:
+        'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.',
+      unsafeReturnThis: [
+        'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-return',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index a61572515437..2619ea4ec52b 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -7,21 +7,6 @@ type Options = [];
 type MessageIds = 'unaryMinus';
 
 export default util.createRule<Options, MessageIds>({
-  name: 'no-unsafe-unary-minus',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Require unary negation to take a number',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unaryMinus:
-        'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       UnaryExpression(node): void {
@@ -49,12 +34,27 @@ export default util.createRule<Options, MessageIds>({
             )
         ) {
           context.report({
+            data: { type: checker.typeToString(argType) },
             messageId: 'unaryMinus',
             node,
-            data: { type: checker.typeToString(argType) },
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Require unary negation to take a number',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unaryMinus:
+        'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-unsafe-unary-minus',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-expressions.ts b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
index 3c386aa69a87..8f832ca5a780 100644
--- a/packages/eslint-plugin/src/rules/no-unused-expressions.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
@@ -4,6 +4,7 @@ import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -13,25 +14,6 @@ type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 type Options = InferOptionsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  name: 'no-unused-expressions',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow unused expressions',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [
-    {
-      allowShortCircuit: false,
-      allowTernary: false,
-      allowTaggedTemplates: false,
-    },
-  ],
   create(context, [{ allowShortCircuit = false, allowTernary = false }]) {
     const rules = baseRule.create(context);
 
@@ -78,4 +60,23 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowShortCircuit: false,
+      allowTaggedTemplates: false,
+      allowTernary: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow unused expressions',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'suggestion',
+  },
+  name: 'no-unused-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index d98c2f5bf5a5..28feecb5f887 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -2,11 +2,12 @@ import type {
   Definition,
   ScopeVariable,
 } from '@typescript-eslint/scope-manager';
+import type { TSESTree } from '@typescript-eslint/utils';
+
 import {
   DefinitionType,
   PatternVisitor,
 } from '@typescript-eslint/scope-manager';
-import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
 
 import {
@@ -25,30 +26,30 @@ export type Options = [
   | 'all'
   | 'local'
   | {
-      vars?: 'all' | 'local';
-      varsIgnorePattern?: string;
       args?: 'after-used' | 'all' | 'none';
-      ignoreRestSiblings?: boolean;
       argsIgnorePattern?: string;
       caughtErrors?: 'all' | 'none';
       caughtErrorsIgnorePattern?: string;
       destructuredArrayIgnorePattern?: string;
       ignoreClassWithStaticInitBlock?: boolean;
+      ignoreRestSiblings?: boolean;
       reportUsedIgnorePattern?: boolean;
+      vars?: 'all' | 'local';
+      varsIgnorePattern?: string;
     },
 ];
 
 interface TranslatedOptions {
-  vars: 'all' | 'local';
-  varsIgnorePattern?: RegExp;
   args: 'after-used' | 'all' | 'none';
-  ignoreRestSiblings: boolean;
   argsIgnorePattern?: RegExp;
   caughtErrors: 'all' | 'none';
   caughtErrorsIgnorePattern?: RegExp;
   destructuredArrayIgnorePattern?: RegExp;
   ignoreClassWithStaticInitBlock: boolean;
+  ignoreRestSiblings: boolean;
   reportUsedIgnorePattern: boolean;
+  vars: 'all' | 'local';
+  varsIgnorePattern?: RegExp;
 }
 
 type VariableType =
@@ -58,83 +59,17 @@ type VariableType =
   | 'variable';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-unused-vars',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow unused variables',
-      recommended: 'recommended',
-      extendsBaseRule: true,
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            type: 'string',
-            enum: ['all', 'local'],
-          },
-          {
-            type: 'object',
-            properties: {
-              vars: {
-                type: 'string',
-                enum: ['all', 'local'],
-              },
-              varsIgnorePattern: {
-                type: 'string',
-              },
-              args: {
-                type: 'string',
-                enum: ['all', 'after-used', 'none'],
-              },
-              ignoreRestSiblings: {
-                type: 'boolean',
-              },
-              argsIgnorePattern: {
-                type: 'string',
-              },
-              caughtErrors: {
-                type: 'string',
-                enum: ['all', 'none'],
-              },
-              caughtErrorsIgnorePattern: {
-                type: 'string',
-              },
-              destructuredArrayIgnorePattern: {
-                type: 'string',
-              },
-              ignoreClassWithStaticInitBlock: {
-                type: 'boolean',
-              },
-              reportUsedIgnorePattern: {
-                type: 'boolean',
-              },
-            },
-            additionalProperties: false,
-          },
-        ],
-      },
-    ],
-    messages: {
-      unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
-      usedIgnoredVar:
-        "'{{varName}}' is marked as ignored but is used{{additional}}.",
-      usedOnlyAsType:
-        "'{{varName}}' is {{action}} but only used as a type{{additional}}.",
-    },
-  },
-  defaultOptions: [{}],
   create(context, [firstOption]) {
     const MODULE_DECL_CACHE = new Map<TSESTree.TSModuleDeclaration, boolean>();
 
     const options = ((): TranslatedOptions => {
       const options: TranslatedOptions = {
-        vars: 'all',
         args: 'after-used',
-        ignoreRestSiblings: false,
         caughtErrors: 'all',
         ignoreClassWithStaticInitBlock: false,
+        ignoreRestSiblings: false,
         reportUsedIgnorePattern: false,
+        vars: 'all',
       };
 
       if (typeof firstOption === 'string') {
@@ -267,7 +202,7 @@ export default createRule<Options, MessageIds>({
       let additionalMessageData = '';
 
       if (def) {
-        const { variableDescription, pattern } = getVariableDescription(
+        const { pattern, variableDescription } = getVariableDescription(
           defToVariableType(def),
         );
 
@@ -277,9 +212,9 @@ export default createRule<Options, MessageIds>({
       }
 
       return {
-        varName: unusedVar.name,
         action: 'defined',
         additional: additionalMessageData,
+        varName: unusedVar.name,
       };
     }
 
@@ -296,7 +231,7 @@ export default createRule<Options, MessageIds>({
       let additionalMessageData = '';
 
       if (def) {
-        const { variableDescription, pattern } = getVariableDescription(
+        const { pattern, variableDescription } = getVariableDescription(
           defToVariableType(def),
         );
 
@@ -306,9 +241,9 @@ export default createRule<Options, MessageIds>({
       }
 
       return {
-        varName: unusedVar.name,
         action: 'assigned a value',
         additional: additionalMessageData,
+        varName: unusedVar.name,
       };
     }
 
@@ -323,7 +258,7 @@ export default createRule<Options, MessageIds>({
       variable: ScopeVariable,
       variableType: VariableType,
     ): Record<string, unknown> {
-      const { variableDescription, pattern } =
+      const { pattern, variableDescription } =
         getVariableDescription(variableType);
 
       let additionalMessageData = '';
@@ -333,8 +268,8 @@ export default createRule<Options, MessageIds>({
       }
 
       return {
-        varName: variable.name,
         additional: additionalMessageData,
+        varName: variable.name,
       };
     }
 
@@ -433,9 +368,9 @@ export default createRule<Options, MessageIds>({
         ) {
           if (options.reportUsedIgnorePattern && used) {
             context.report({
-              node: def.name,
-              messageId: 'usedIgnoredVar',
               data: getUsedIgnoredMessageData(variable, 'array-destructure'),
+              messageId: 'usedIgnoredVar',
+              node: def.name,
             });
           }
           continue;
@@ -463,9 +398,9 @@ export default createRule<Options, MessageIds>({
           ) {
             if (options.reportUsedIgnorePattern && used) {
               context.report({
-                node: def.name,
-                messageId: 'usedIgnoredVar',
                 data: getUsedIgnoredMessageData(variable, 'catch-clause'),
+                messageId: 'usedIgnoredVar',
+                node: def.name,
               });
             }
             continue;
@@ -482,9 +417,9 @@ export default createRule<Options, MessageIds>({
           ) {
             if (options.reportUsedIgnorePattern && used) {
               context.report({
-                node: def.name,
-                messageId: 'usedIgnoredVar',
                 data: getUsedIgnoredMessageData(variable, 'parameter'),
+                messageId: 'usedIgnoredVar',
+                node: def.name,
               });
             }
             continue;
@@ -505,9 +440,9 @@ export default createRule<Options, MessageIds>({
         ) {
           if (options.reportUsedIgnorePattern && used) {
             context.report({
-              node: def.name,
-              messageId: 'usedIgnoredVar',
               data: getUsedIgnoredMessageData(variable, 'variable'),
+              messageId: 'usedIgnoredVar',
+              node: def.name,
             });
           }
           continue;
@@ -608,19 +543,19 @@ export default createRule<Options, MessageIds>({
             const idLength = id.name.length;
 
             const loc = {
-              start,
               end: {
-                line: start.line,
                 column: start.column + idLength,
+                line: start.line,
               },
+              start,
             };
 
             context.report({
-              loc,
-              messageId,
               data: unusedVar.references.some(ref => ref.isWrite())
                 ? getAssignedMessageData(unusedVar)
                 : getDefinedMessageData(unusedVar),
+              loc,
+              messageId,
             });
 
             // If there are no regular declaration, report the first `/*globals*/` comment directive.
@@ -631,14 +566,14 @@ export default createRule<Options, MessageIds>({
             const directiveComment = unusedVar.eslintExplicitGlobalComments[0];
 
             context.report({
-              node: programNode,
+              data: getDefinedMessageData(unusedVar),
               loc: getNameLocationInGlobalDirectiveComment(
                 context.sourceCode,
                 directiveComment,
                 unusedVar.name,
               ),
               messageId: 'unusedVar',
-              data: getDefinedMessageData(unusedVar),
+              node: programNode,
             });
           }
         }
@@ -721,8 +656,8 @@ export default createRule<Options, MessageIds>({
 
       let scope = context.sourceCode.getScope(node);
       const shouldUseUpperScope = [
-        AST_NODE_TYPES.TSModuleDeclaration,
         AST_NODE_TYPES.TSDeclareFunction,
+        AST_NODE_TYPES.TSModuleDeclaration,
       ].includes(node.type);
 
       if (scope.variableScope !== scope) {
@@ -747,6 +682,72 @@ export default createRule<Options, MessageIds>({
       visitor.visit(node);
     }
   },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: 'Disallow unused variables',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    messages: {
+      unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
+      usedIgnoredVar:
+        "'{{varName}}' is marked as ignored but is used{{additional}}.",
+      usedOnlyAsType:
+        "'{{varName}}' is {{action}} but only used as a type{{additional}}.",
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            enum: ['all', 'local'],
+            type: 'string',
+          },
+          {
+            additionalProperties: false,
+            properties: {
+              args: {
+                enum: ['all', 'after-used', 'none'],
+                type: 'string',
+              },
+              argsIgnorePattern: {
+                type: 'string',
+              },
+              caughtErrors: {
+                enum: ['all', 'none'],
+                type: 'string',
+              },
+              caughtErrorsIgnorePattern: {
+                type: 'string',
+              },
+              destructuredArrayIgnorePattern: {
+                type: 'string',
+              },
+              ignoreClassWithStaticInitBlock: {
+                type: 'boolean',
+              },
+              ignoreRestSiblings: {
+                type: 'boolean',
+              },
+              reportUsedIgnorePattern: {
+                type: 'boolean',
+              },
+              vars: {
+                enum: ['all', 'local'],
+                type: 'string',
+              },
+              varsIgnorePattern: {
+                type: 'string',
+              },
+            },
+            type: 'object',
+          },
+        ],
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'no-unused-vars',
 });
 
 /*
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index f333683d2f42..cd60bb1e708f 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -1,5 +1,6 @@
-import { DefinitionType } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -33,13 +34,13 @@ function parseOptions(options: Config | string | null): Required<Config> {
   }
 
   return {
-    functions,
+    allowNamedExports,
     classes,
     enums,
-    variables,
-    typedefs,
+    functions,
     ignoreTypeReferences,
-    allowNamedExports,
+    typedefs,
+    variables,
   };
 }
 
@@ -203,63 +204,18 @@ function isInInitializer(
 }
 
 interface Config {
-  functions?: boolean;
+  allowNamedExports?: boolean;
   classes?: boolean;
   enums?: boolean;
-  variables?: boolean;
-  typedefs?: boolean;
+  functions?: boolean;
   ignoreTypeReferences?: boolean;
-  allowNamedExports?: boolean;
+  typedefs?: boolean;
+  variables?: boolean;
 }
-type Options = [Config | 'nofunc'];
+type Options = ['nofunc' | Config];
 type MessageIds = 'noUseBeforeDefine';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-use-before-define',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow the use of variables before they are defined',
-      extendsBaseRule: true,
-    },
-    messages: {
-      noUseBeforeDefine: "'{{name}}' was used before it was defined.",
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            type: 'string',
-            enum: ['nofunc'],
-          },
-          {
-            type: 'object',
-            properties: {
-              functions: { type: 'boolean' },
-              classes: { type: 'boolean' },
-              enums: { type: 'boolean' },
-              variables: { type: 'boolean' },
-              typedefs: { type: 'boolean' },
-              ignoreTypeReferences: { type: 'boolean' },
-              allowNamedExports: { type: 'boolean' },
-            },
-            additionalProperties: false,
-          },
-        ],
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      functions: true,
-      classes: true,
-      enums: true,
-      variables: true,
-      typedefs: true,
-      ignoreTypeReferences: true,
-      allowNamedExports: false,
-    },
-  ],
   create(context, optionsWithDefault) {
     const options = parseOptions(optionsWithDefault[0]);
 
@@ -313,11 +269,11 @@ export default createRule<Options, MessageIds>({
 
         function report(): void {
           context.report({
-            node: reference.identifier,
-            messageId: 'noUseBeforeDefine',
             data: {
               name: reference.identifier.name,
             },
+            messageId: 'noUseBeforeDefine',
+            node: reference.identifier,
           });
         }
 
@@ -365,4 +321,49 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowNamedExports: false,
+      classes: true,
+      enums: true,
+      functions: true,
+      ignoreTypeReferences: true,
+      typedefs: true,
+      variables: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow the use of variables before they are defined',
+      extendsBaseRule: true,
+    },
+    messages: {
+      noUseBeforeDefine: "'{{name}}' was used before it was defined.",
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            enum: ['nofunc'],
+            type: 'string',
+          },
+          {
+            additionalProperties: false,
+            properties: {
+              allowNamedExports: { type: 'boolean' },
+              classes: { type: 'boolean' },
+              enums: { type: 'boolean' },
+              functions: { type: 'boolean' },
+              ignoreTypeReferences: { type: 'boolean' },
+              typedefs: { type: 'boolean' },
+              variables: { type: 'boolean' },
+            },
+            type: 'object',
+          },
+        ],
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'no-use-before-define',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index cd91a71c2002..39a28c1e8fa0 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -1,10 +1,12 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
@@ -42,19 +44,6 @@ function checkParams(node: TSESTree.MethodDefinition): boolean {
 }
 
 export default createRule<Options, MessageIds>({
-  name: 'no-useless-constructor',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow unnecessary constructors',
-      recommended: 'strict',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    schema: baseRule.meta.schema,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
     return {
@@ -69,4 +58,17 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary constructors',
+      extendsBaseRule: true,
+      recommended: 'strict',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+    type: 'problem',
+  },
+  name: 'no-useless-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index a21f1cfa6224..32befd651a19 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isDefinitionFile } from '../util';
@@ -24,21 +25,6 @@ const exportOrImportNodeTypes = new Set([
 ]);
 
 export default createRule({
-  name: 'no-useless-empty-export',
-  meta: {
-    docs: {
-      description:
-        "Disallow empty exports that don't change anything in a module file",
-    },
-    fixable: 'code',
-    hasSuggestions: false,
-    messages: {
-      uselessExport: 'Empty export does nothing and can be removed.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     // In a definition file, export {} is necessary to make the module properly
     // encapsulated, even when there are other exports
@@ -80,4 +66,19 @@ export default createRule({
       TSModuleDeclaration: checkNode,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        "Disallow empty exports that don't change anything in a module file",
+    },
+    fixable: 'code',
+    hasSuggestions: false,
+    messages: {
+      uselessExport: 'Empty export does nothing and can be removed.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'no-useless-empty-export',
 });
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index b7c38620168a..c13c95350c1a 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 
 import { createRule, getStaticStringValue } from '../util';
@@ -11,32 +12,6 @@ type Options = [
 type MessageIds = 'noVarReqs';
 
 export default createRule<Options, MessageIds>({
-  name: 'no-var-requires',
-  meta: {
-    deprecated: true,
-    replacedBy: ['@typescript-eslint/no-require-imports'],
-    type: 'problem',
-    docs: {
-      description: 'Disallow `require` statements except in import statements',
-    },
-    messages: {
-      noVarReqs: 'Require statement not part of import statement.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allow: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Patterns of import paths to allow requiring from.',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [{ allow: [] }],
   create(context, options) {
     const allowPatterns = options[0].allow.map(
       pattern => new RegExp(pattern, 'u'),
@@ -85,12 +60,38 @@ export default createRule<Options, MessageIds>({
 
           if (!variable?.identifiers.length) {
             context.report({
-              node,
               messageId: 'noVarReqs',
+              node,
             });
           }
         }
       },
     };
   },
+  defaultOptions: [{ allow: [] }],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: 'Disallow `require` statements except in import statements',
+    },
+    messages: {
+      noVarReqs: 'Require statement not part of import statement.',
+    },
+    replacedBy: ['@typescript-eslint/no-require-imports'],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: {
+            description: 'Patterns of import paths to allow requiring from.',
+            items: { type: 'string' },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'no-var-requires',
 });
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index f51b6c8564b5..433684819dfc 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isReferenceToGlobalFunction } from '../util';
@@ -15,21 +16,6 @@ const classNames = new Set([
 ]);
 
 export default createRule({
-  name: 'no-wrapper-object-types',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow using confusing built-in primitive class wrappers',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      bannedClassType:
-        'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function checkBannedTypes(
       node: TSESTree.EntityName | TSESTree.Expression,
@@ -47,7 +33,7 @@ export default createRule({
       const preferred = typeName.toLowerCase();
 
       context.report({
-        data: { typeName, preferred },
+        data: { preferred, typeName },
         fix: includeFix
           ? (fixer): TSESLint.RuleFix => fixer.replaceText(node, preferred)
           : undefined,
@@ -68,4 +54,19 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow using confusing built-in primitive class wrappers',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      bannedClassType:
+        'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-wrapper-object-types',
 });
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index e4b237cccc85..364c10053c19 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -11,23 +12,6 @@ import {
 } from '../util';
 
 export default createRule({
-  name: 'non-nullable-type-assertion-style',
-  meta: {
-    docs: {
-      description: 'Enforce non-null assertions over explicit type casts',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferNonNullAssertion:
-        'Use a ! assertion to more succinctly remove null and undefined from the type.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
-
   create(context) {
     const services = getParserServices(context);
 
@@ -144,4 +128,21 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Enforce non-null assertions over explicit type casts',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferNonNullAssertion:
+        'Use a ! assertion to more succinctly remove null and undefined from the type.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'non-nullable-type-assertion-style',
 });
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index 45a6dac0942d..2c48b9d2d3db 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -20,40 +21,6 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'only-throw-error',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow throwing non-`Error` values as exceptions',
-      recommended: 'recommended',
-      extendsBaseRule: 'no-throw-literal',
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowThrowingAny: {
-            type: 'boolean',
-          },
-          allowThrowingUnknown: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      object: 'Expected an error object to be thrown.',
-      undef: 'Do not throw undefined.',
-    },
-  },
-  defaultOptions: [
-    {
-      allowThrowingAny: true,
-      allowThrowingUnknown: true,
-    },
-  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -68,7 +35,7 @@ export default createRule<Options, MessageIds>({
       const type = services.getTypeAtLocation(node);
 
       if (type.flags & ts.TypeFlags.Undefined) {
-        context.report({ node, messageId: 'undef' });
+        context.report({ messageId: 'undef', node });
         return;
       }
 
@@ -84,7 +51,7 @@ export default createRule<Options, MessageIds>({
         return;
       }
 
-      context.report({ node, messageId: 'object' });
+      context.report({ messageId: 'object', node });
     }
 
     return {
@@ -95,4 +62,38 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowThrowingAny: true,
+      allowThrowingUnknown: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow throwing non-`Error` values as exceptions',
+      extendsBaseRule: 'no-throw-literal',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      object: 'Expected an error object to be thrown.',
+      undef: 'Do not throw undefined.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowThrowingAny: {
+            type: 'boolean',
+          },
+          allowThrowingUnknown: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'only-throw-error',
 });
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index 5246594e912e..4ebdd23264b6 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, nullThrows } from '../util';
@@ -24,58 +25,6 @@ type Options = [
 type MessageIds = 'preferClassProperty' | 'preferParameterProperty';
 
 export default createRule<Options, MessageIds>({
-  name: 'parameter-properties',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Require or disallow parameter properties in class constructors',
-    },
-    messages: {
-      preferClassProperty:
-        'Property {{parameter}} should be declared as a class property.',
-      preferParameterProperty:
-        'Property {{parameter}} should be declared as a parameter property.',
-    },
-    schema: [
-      {
-        $defs: {
-          modifier: {
-            type: 'string',
-            enum: [
-              'readonly',
-              'private',
-              'protected',
-              'public',
-              'private readonly',
-              'protected readonly',
-              'public readonly',
-            ],
-          },
-        },
-        type: 'object',
-        properties: {
-          allow: {
-            type: 'array',
-            items: {
-              $ref: '#/items/0/$defs/modifier',
-            },
-          },
-          prefer: {
-            type: 'string',
-            enum: ['class-property', 'parameter-property'],
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allow: [],
-      prefer: 'class-property',
-    },
-  ],
   create(context, [{ allow = [], prefer = 'class-property' }]) {
     /**
      * Gets the modifiers of `node`.
@@ -117,11 +66,11 @@ export default createRule<Options, MessageIds>({
                   (node.parameter.left as TSESTree.Identifier).name;
 
             context.report({
-              node,
-              messageId: 'preferClassProperty',
               data: {
                 parameter: name,
               },
+              messageId: 'preferClassProperty',
+              node,
             });
           }
         },
@@ -169,10 +118,6 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
-      'ClassDeclaration, ClassExpression'(): void {
-        propertyNodesByNameStack.push(new Map());
-      },
-
       ':matches(ClassDeclaration, ClassExpression):exit'(): void {
         const propertyNodesByName = nullThrows(
           propertyNodesByNameStack.pop(),
@@ -213,6 +158,10 @@ export default createRule<Options, MessageIds>({
         }
       },
 
+      'ClassDeclaration, ClassExpression'(): void {
+        propertyNodesByNameStack.push(new Map());
+      },
+
       'MethodDefinition[kind="constructor"]'(
         node: TSESTree.MethodDefinition,
       ): void {
@@ -244,4 +193,56 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allow: [],
+      prefer: 'class-property',
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require or disallow parameter properties in class constructors',
+    },
+    messages: {
+      preferClassProperty:
+        'Property {{parameter}} should be declared as a class property.',
+      preferParameterProperty:
+        'Property {{parameter}} should be declared as a parameter property.',
+    },
+    schema: [
+      {
+        $defs: {
+          modifier: {
+            enum: [
+              'readonly',
+              'private',
+              'protected',
+              'public',
+              'private readonly',
+              'protected readonly',
+              'public readonly',
+            ],
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          allow: {
+            items: {
+              $ref: '#/items/0/$defs/modifier',
+            },
+            type: 'array',
+          },
+          prefer: {
+            enum: ['class-property', 'parameter-property'],
+            type: 'string',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'parameter-properties',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index f3bcaf2963af..54841bf69c4f 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -1,28 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'prefer-as-const',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce the use of `as const` over literal type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      preferConstAssertion:
-        'Expected a `const` instead of a literal type assertion.',
-      variableConstAssertion:
-        'Expected a `const` assertion instead of a literal type annotation.',
-      variableSuggest: 'You should use `as const` instead of type annotation.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function compareTypes(
       valueNode: TSESTree.Expression,
@@ -37,21 +19,21 @@ export default createRule({
       ) {
         if (canFix) {
           context.report({
-            node: typeNode,
-            messageId: 'preferConstAssertion',
             fix: fixer => fixer.replaceText(typeNode, 'const'),
+            messageId: 'preferConstAssertion',
+            node: typeNode,
           });
         } else {
           context.report({
-            node: typeNode,
             messageId: 'variableConstAssertion',
+            node: typeNode,
             suggest: [
               {
-                messageId: 'variableSuggest',
                 fix: (fixer): TSESLint.RuleFix[] => [
                   fixer.remove(typeNode.parent),
                   fixer.insertTextAfter(valueNode, ' as const'),
                 ],
+                messageId: 'variableSuggest',
               },
             ],
           });
@@ -60,17 +42,17 @@ export default createRule({
     }
 
     return {
+      PropertyDefinition(node): void {
+        if (node.value && node.typeAnnotation) {
+          compareTypes(node.value, node.typeAnnotation.typeAnnotation, false);
+        }
+      },
       TSAsExpression(node): void {
         compareTypes(node.expression, node.typeAnnotation, true);
       },
       TSTypeAssertion(node): void {
         compareTypes(node.expression, node.typeAnnotation, true);
       },
-      PropertyDefinition(node): void {
-        if (node.value && node.typeAnnotation) {
-          compareTypes(node.value, node.typeAnnotation.typeAnnotation, false);
-        }
-      },
       VariableDeclarator(node): void {
         if (node.init && node.id.typeAnnotation) {
           compareTypes(node.init, node.id.typeAnnotation.typeAnnotation, false);
@@ -78,4 +60,23 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Enforce the use of `as const` over literal type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      preferConstAssertion:
+        'Expected a `const` instead of a literal type assertion.',
+      variableConstAssertion:
+        'Expected a `const` assertion instead of a literal type annotation.',
+      variableSuggest: 'You should use `as const` instead of type annotation.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'prefer-as-const',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index 60e53dbb61e6..dcfa10eb8ab3 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -1,28 +1,30 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
-import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as tsutils from 'ts-api-utils';
+
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../util';
+
 import { createRule, getParserServices, isTypeAnyType } from '../util';
 import { getESLintCoreRule } from '../util/getESLintCoreRule';
 
 const baseRule = getESLintCoreRule('prefer-destructuring');
 
 type BaseOptions = InferOptionsTypeFromRule<typeof baseRule>;
-type EnforcementOptions = BaseOptions[1] & {
+type EnforcementOptions = {
   enforceForDeclarationWithTypeAnnotation?: boolean;
-};
+} & BaseOptions[1];
 type Options = [BaseOptions[0], EnforcementOptions];
 
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 const destructuringTypeConfig: JSONSchema4 = {
-  type: 'object',
+  additionalProperties: false,
   properties: {
     array: {
       type: 'boolean',
@@ -31,89 +33,63 @@ const destructuringTypeConfig: JSONSchema4 = {
       type: 'boolean',
     },
   },
-  additionalProperties: false,
+  type: 'object',
 };
 
 const schema: readonly JSONSchema4[] = [
   {
     oneOf: [
       {
-        type: 'object',
+        additionalProperties: false,
         properties: {
-          VariableDeclarator: destructuringTypeConfig,
           AssignmentExpression: destructuringTypeConfig,
+          VariableDeclarator: destructuringTypeConfig,
         },
-        additionalProperties: false,
+        type: 'object',
       },
       destructuringTypeConfig,
     ],
   },
   {
-    type: 'object',
     properties: {
-      enforceForRenamedProperties: {
+      enforceForDeclarationWithTypeAnnotation: {
         type: 'boolean',
       },
-      enforceForDeclarationWithTypeAnnotation: {
+      enforceForRenamedProperties: {
         type: 'boolean',
       },
     },
+    type: 'object',
   },
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-destructuring',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require destructuring from arrays and/or objects',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    schema,
-    fixable: baseRule.meta.fixable,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-  },
-  defaultOptions: [
-    {
-      VariableDeclarator: {
-        array: true,
-        object: true,
-      },
-      AssignmentExpression: {
-        array: true,
-        object: true,
-      },
-    },
-    {},
-  ],
   create(context, [enabledTypes, options]) {
     const {
-      enforceForRenamedProperties = false,
       enforceForDeclarationWithTypeAnnotation = false,
+      enforceForRenamedProperties = false,
     } = options;
-    const { program, esTreeNodeToTSNodeMap } = getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program } = getParserServices(context);
     const typeChecker = program.getTypeChecker();
     const baseRules = baseRule.create(context);
     let baseRulesWithoutFixCache: typeof baseRules | null = null;
 
     return {
-      VariableDeclarator(node): void {
-        performCheck(node.id, node.init, node);
-      },
       AssignmentExpression(node): void {
         if (node.operator !== '=') {
           return;
         }
         performCheck(node.left, node.right, node);
       },
+      VariableDeclarator(node): void {
+        performCheck(node.id, node.init, node);
+      },
     };
 
     function performCheck(
       leftNode: TSESTree.BindingName | TSESTree.Expression,
       rightNode: TSESTree.Expression | null,
-      reportNode: TSESTree.VariableDeclarator | TSESTree.AssignmentExpression,
+      reportNode: TSESTree.AssignmentExpression | TSESTree.VariableDeclarator,
     ): void {
       const rules =
         leftNode.type === AST_NODE_TYPES.Identifier &&
@@ -145,9 +121,9 @@ export default createRule<Options, MessageIds>({
             return;
           }
           context.report({
-            node: reportNode,
-            messageId: 'preferDestructuring',
             data: { type: 'object' },
+            messageId: 'preferDestructuring',
+            node: reportNode,
           });
           return;
         }
@@ -162,8 +138,8 @@ export default createRule<Options, MessageIds>({
 
     function getNormalizedEnabledType(
       nodeType:
-        | AST_NODE_TYPES.VariableDeclarator
-        | AST_NODE_TYPES.AssignmentExpression,
+        | AST_NODE_TYPES.AssignmentExpression
+        | AST_NODE_TYPES.VariableDeclarator,
       destructuringType: 'array' | 'object',
     ): boolean | undefined {
       if ('object' in enabledTypes || 'array' in enabledTypes) {
@@ -179,6 +155,32 @@ export default createRule<Options, MessageIds>({
       return baseRulesWithoutFixCache;
     }
   },
+  defaultOptions: [
+    {
+      AssignmentExpression: {
+        array: true,
+        object: true,
+      },
+      VariableDeclarator: {
+        array: true,
+        object: true,
+      },
+    },
+    {},
+  ],
+  meta: {
+    docs: {
+      description: 'Require destructuring from arrays and/or objects',
+      extendsBaseRule: true,
+      requiresTypeChecking: true,
+    },
+    fixable: baseRule.meta.fixable,
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema,
+    type: 'suggestion',
+  },
+  name: 'prefer-destructuring',
 });
 
 type Context = TSESLint.RuleContext<MessageIds, Options>;
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index 00dae8cccb96..14fac17fa4a7 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -5,23 +5,6 @@ import { createRule } from '../util';
 type MessageIds = 'defineInitializer' | 'defineInitializerSuggestion';
 
 export default createRule<[], MessageIds>({
-  name: 'prefer-enum-initializers',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require each enum member value to be explicitly initialized',
-    },
-    hasSuggestions: true,
-    messages: {
-      defineInitializer:
-        "The value of the member '{{ name }}' should be explicitly defined.",
-      defineInitializerSuggestion:
-        'Can be fixed to {{ name }} = {{ suggested }}',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
       const { members } = node.body;
@@ -30,32 +13,32 @@ export default createRule<[], MessageIds>({
         if (member.initializer == null) {
           const name = context.sourceCode.getText(member);
           context.report({
-            node: member,
-            messageId: 'defineInitializer',
             data: {
               name,
             },
+            messageId: 'defineInitializer',
+            node: member,
             suggest: [
               {
-                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: index },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = ${index}`);
                 },
+                messageId: 'defineInitializerSuggestion',
               },
               {
-                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: index + 1 },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = ${index + 1}`);
                 },
+                messageId: 'defineInitializerSuggestion',
               },
               {
-                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: `'${name}'` },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = '${name}'`);
                 },
+                messageId: 'defineInitializerSuggestion',
               },
             ],
           });
@@ -67,4 +50,21 @@ export default createRule<[], MessageIds>({
       TSEnumDeclaration,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Require each enum member value to be explicitly initialized',
+    },
+    hasSuggestions: true,
+    messages: {
+      defineInitializer:
+        "The value of the member '{{ name }}' should be explicitly defined.",
+      defineInitializerSuggestion:
+        'Can be fixed to {{ name }} = {{ suggested }}',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'prefer-enum-initializers',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index 587cd5d0f03d..7b61e01b5160 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -1,9 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { RuleFix, Scope } from '@typescript-eslint/utils/ts-eslint';
-import * as tsutils from 'ts-api-utils';
 import type { Type } from 'typescript';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as tsutils from 'ts-api-utils';
+
 import {
   createRule,
   getConstrainedTypeAtLocation,
@@ -13,33 +14,14 @@ import {
 } from '../util';
 
 export default createRule({
-  name: 'prefer-find',
-  meta: {
-    docs: {
-      description:
-        'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      preferFind: 'Prefer .find(...) instead of .filter(...)[0].',
-      preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
-    },
-    schema: [],
-    type: 'suggestion',
-    hasSuggestions: true,
-  },
-
-  defaultOptions: [],
-
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
 
     interface FilterExpressionData {
-      isBracketSyntaxForFilter: boolean;
       filterNode: TSESTree.Node;
+      isBracketSyntaxForFilter: boolean;
     }
 
     function parseArrayFilterExpressions(
@@ -102,8 +84,8 @@ export default createRule({
             if (isArrayish(filteredObjectType)) {
               return [
                 {
-                  isBracketSyntaxForFilter,
                   filterNode,
+                  isBracketSyntaxForFilter,
                 },
               ];
             }
@@ -251,11 +233,10 @@ export default createRule({
           const filterExpressions = parseArrayFilterExpressions(object);
           if (filterExpressions.length !== 0) {
             context.report({
-              node,
               messageId: 'preferFind',
+              node,
               suggest: [
                 {
-                  messageId: 'preferFindSuggestion',
                   fix: (fixer): TSESLint.RuleFix[] => {
                     return [
                       ...filterExpressions.map(filterExpression =>
@@ -272,6 +253,7 @@ export default createRule({
                       ),
                     ];
                   },
+                  messageId: 'preferFindSuggestion',
                 },
               ],
             });
@@ -291,11 +273,10 @@ export default createRule({
           const filterExpressions = parseArrayFilterExpressions(object);
           if (filterExpressions.length !== 0) {
             context.report({
-              node,
               messageId: 'preferFind',
+              node,
               suggest: [
                 {
-                  messageId: 'preferFindSuggestion',
                   fix: (fixer): TSESLint.RuleFix[] => {
                     return [
                       ...filterExpressions.map(filterExpression =>
@@ -312,6 +293,7 @@ export default createRule({
                       ),
                     ];
                   },
+                  messageId: 'preferFindSuggestion',
                 },
               ],
             });
@@ -320,6 +302,25 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+
+  meta: {
+    docs: {
+      description:
+        'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      preferFind: 'Prefer .find(...) instead of .filter(...)[0].',
+      preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'prefer-find',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index 18622a04e2ec..2f76b4f09328 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -1,24 +1,10 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, isAssignee } from '../util';
 
 export default createRule({
-  name: 'prefer-for-of',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce the use of `for-of` loop over the standard `for` loop where possible',
-      recommended: 'stylistic',
-    },
-    messages: {
-      preferForOf:
-        'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     function isSingleVariableDeclaration(
       node: TSESTree.Node | null,
@@ -154,11 +140,26 @@ export default createRule({
           isIndexOnlyUsedWithArray(node.body, indexVar, arrayExpression)
         ) {
           context.report({
-            node,
             messageId: 'preferForOf',
+            node,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Enforce the use of `for-of` loop over the standard `for` loop where possible',
+      recommended: 'stylistic',
+    },
+    messages: {
+      preferForOf:
+        'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'prefer-for-of',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index c7372c067f0b..04e1bd174db1 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -1,32 +1,15 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
 
 export const phrases = {
-  [AST_NODE_TYPES.TSTypeLiteral]: 'Type literal',
   [AST_NODE_TYPES.TSInterfaceDeclaration]: 'Interface',
+  [AST_NODE_TYPES.TSTypeLiteral]: 'Type literal',
 } as const;
 
 export default createRule({
-  name: 'prefer-function-type',
-  meta: {
-    docs: {
-      description:
-        'Enforce using function types instead of interfaces with call signatures',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      functionTypeOverCallableType:
-        '{{ literalOrInterface }} only has a call signature, you should use a function type instead.',
-      unexpectedThisOnFunctionOnlyInterface:
-        "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  defaultOptions: [],
   create(context) {
     /**
      * Checks if there the interface has exactly one supertype that isn't named 'Function'
@@ -85,11 +68,11 @@ export default createRule({
           // the message can be confusing if we don't point directly to the `this` node instead of the whole member
           // and in favour of generating at most one error we'll only report the first occurrence of `this` if there are multiple
           context.report({
-            node: tsThisTypes[0],
-            messageId: 'unexpectedThisOnFunctionOnlyInterface',
             data: {
               interfaceName: node.id.name,
             },
+            messageId: 'unexpectedThisOnFunctionOnlyInterface',
+            node: tsThisTypes[0],
           });
           return;
         }
@@ -176,12 +159,12 @@ export default createRule({
             };
 
         context.report({
-          node: member,
-          messageId: 'functionTypeOverCallableType',
           data: {
             literalOrInterface: phrases[node.type],
           },
           fix,
+          messageId: 'functionTypeOverCallableType',
+          node: member,
         });
       }
     }
@@ -221,4 +204,22 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Enforce using function types instead of interfaces with call signatures',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      functionTypeOverCallableType:
+        '{{ literalOrInterface }} only has a call signature, you should use a function type instead.',
+      unexpectedThisOnFunctionOnlyInterface:
+        "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'prefer-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index 1a8f705b312f..ddb58e74123e 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -1,5 +1,6 @@
-import { parseRegExpLiteral } from '@eslint-community/regexpp';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import { parseRegExpLiteral } from '@eslint-community/regexpp';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -11,25 +12,6 @@ import {
 } from '../util';
 
 export default createRule({
-  name: 'prefer-includes',
-  defaultOptions: [],
-
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Enforce `includes` method over `indexOf` method',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferIncludes: "Use 'includes()' method instead.",
-      preferStringIncludes:
-        'Use `String#includes()` method with a string instead.',
-    },
-    schema: [],
-  },
-
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
@@ -102,7 +84,7 @@ export default createRule({
         return null;
       }
 
-      const { pattern, flags } = parseRegExpLiteral(evaluated.value);
+      const { flags, pattern } = parseRegExpLiteral(evaluated.value);
       if (
         pattern.alternatives.length !== 1 ||
         flags.ignoreCase ||
@@ -124,13 +106,13 @@ export default createRule({
     function escapeString(str: string): string {
       const EscapeMap = {
         '\0': '\\0',
-        "'": "\\'",
-        '\\': '\\\\',
+        '\t': '\\t',
         '\n': '\\n',
-        '\r': '\\r',
         '\v': '\\v',
-        '\t': '\\t',
         '\f': '\\f',
+        '\r': '\\r',
+        "'": "\\'",
+        '\\': '\\\\',
         // "\b" cause unexpected replacements
         // '\b': '\\b',
       };
@@ -188,8 +170,8 @@ export default createRule({
 
       // Report it.
       context.report({
-        node: compareNode,
         messageId: 'preferIncludes',
+        node: compareNode,
         ...(allowFixing && {
           *fix(fixer): Generator<TSESLint.RuleFix> {
             if (negative) {
@@ -219,7 +201,7 @@ export default createRule({
 
       // /bar/.test(foo)
       'CallExpression[arguments.length=1] > MemberExpression.callee[property.name="test"][computed=false]'(
-        node: TSESTree.MemberExpression & { parent: TSESTree.CallExpression },
+        node: { parent: TSESTree.CallExpression } & TSESTree.MemberExpression,
       ): void {
         const callNode = node.parent;
         const text = parseRegExp(node.object);
@@ -239,8 +221,6 @@ export default createRule({
         }
 
         context.report({
-          node: callNode,
-          messageId: 'preferStringIncludes',
           *fix(fixer) {
             const argNode = callNode.arguments[0];
             const needsParen =
@@ -261,8 +241,29 @@ export default createRule({
               `${node.optional ? '?.' : '.'}includes('${escapeString(text)}')`,
             );
           },
+          messageId: 'preferStringIncludes',
+          node: callNode,
         });
       },
     };
   },
+  defaultOptions: [],
+
+  meta: {
+    docs: {
+      description: 'Enforce `includes` method over `indexOf` method',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferIncludes: "Use 'includes()' method instead.",
+      preferStringIncludes:
+        'Use `String#includes()` method with a string instead.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'prefer-includes',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index efc3eacdd518..e2ff6be8757c 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -1,37 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, getStaticStringValue } from '../util';
 
 export default createRule({
-  name: 'prefer-literal-enum-member',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require all enum members to be literal values',
-      recommended: 'strict',
-      requiresTypeChecking: false,
-    },
-    messages: {
-      notLiteral: `Explicit enum value must only be a literal value (string, number, boolean, etc).`,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowBitwiseExpressions: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowBitwiseExpressions: false,
-    },
-  ],
   create(context, [{ allowBitwiseExpressions }]) {
     function isIdentifierWithName(node: TSESTree.Node, name: string): boolean {
       return node.type === AST_NODE_TYPES.Identifier && node.name === name;
@@ -107,7 +80,7 @@ export default createRule({
         if (node.initializer.type === AST_NODE_TYPES.UnaryExpression) {
           if (
             node.initializer.argument.type === AST_NODE_TYPES.Literal &&
-            ['+', '-'].includes(node.initializer.operator)
+            ['-', '+'].includes(node.initializer.operator)
           ) {
             return;
           }
@@ -123,7 +96,7 @@ export default createRule({
         if (
           node.initializer.type === AST_NODE_TYPES.UnaryExpression &&
           node.initializer.argument.type === AST_NODE_TYPES.Literal &&
-          (['+', '-'].includes(node.initializer.operator) ||
+          (['-', '+'].includes(node.initializer.operator) ||
             (allowBitwiseExpressions && node.initializer.operator === '~'))
         ) {
           return;
@@ -132,7 +105,7 @@ export default createRule({
         if (
           allowBitwiseExpressions &&
           node.initializer.type === AST_NODE_TYPES.BinaryExpression &&
-          ['|', '&', '^', '<<', '>>', '>>>'].includes(
+          ['&', '^', '<<', '>>', '>>>', '|'].includes(
             node.initializer.operator,
           ) &&
           isAllowedBitwiseOperand(declaration, node.initializer.left) &&
@@ -142,10 +115,38 @@ export default createRule({
         }
 
         context.report({
-          node: node.id,
           messageId: 'notLiteral',
+          node: node.id,
         });
       },
     };
   },
+  defaultOptions: [
+    {
+      allowBitwiseExpressions: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Require all enum members to be literal values',
+      recommended: 'strict',
+      requiresTypeChecking: false,
+    },
+    messages: {
+      notLiteral: `Explicit enum value must only be a literal value (string, number, boolean, etc).`,
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowBitwiseExpressions: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-literal-enum-member',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index 774c65e53771..5d20247caf5b 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -3,22 +3,6 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  name: 'prefer-namespace-keyword',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      useNamespace:
-        "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     return {
       TSModuleDeclaration(node): void {
@@ -35,14 +19,30 @@ export default createRule({
           moduleType.value === 'module'
         ) {
           context.report({
-            node,
-            messageId: 'useNamespace',
             fix(fixer) {
               return fixer.replaceText(moduleType, 'namespace');
             },
+            messageId: 'useNamespace',
+            node,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      useNamespace:
+        "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'prefer-namespace-keyword',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 87a23ab98808..360e09f3b7a7 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -41,77 +42,6 @@ export type MessageIds =
   | 'suggestNullish';
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-nullish-coalescing',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      preferNullishOverOr:
-        'Prefer using nullish coalescing operator (`??`) instead of a logical or (`||`), as it is a safer operator.',
-      preferNullishOverTernary:
-        'Prefer using nullish coalescing operator (`??`) instead of a ternary expression, as it is simpler to read.',
-      suggestNullish: 'Fix to nullish coalescing operator (`??`).',
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            type: 'boolean',
-          },
-          ignoreConditionalTests: {
-            type: 'boolean',
-          },
-          ignoreMixedLogicalExpressions: {
-            type: 'boolean',
-          },
-          ignorePrimitives: {
-            oneOf: [
-              {
-                type: 'object',
-                properties: {
-                  bigint: { type: 'boolean' },
-                  boolean: { type: 'boolean' },
-                  number: { type: 'boolean' },
-                  string: { type: 'boolean' },
-                },
-              },
-              {
-                type: 'boolean',
-                enum: [true],
-              },
-            ],
-          },
-          ignoreTernaryTests: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-      ignoreConditionalTests: true,
-      ignoreTernaryTests: false,
-      ignoreMixedLogicalExpressions: false,
-      ignorePrimitives: {
-        bigint: false,
-        boolean: false,
-        number: false,
-        string: false,
-      },
-    },
-  ],
   create(
     context,
     [
@@ -139,8 +69,8 @@ export default createRule<Options, MessageIds>({
     ) {
       context.report({
         loc: {
-          start: { line: 0, column: 0 },
-          end: { line: 0, column: 0 },
+          end: { column: 0, line: 0 },
+          start: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
@@ -277,11 +207,10 @@ export default createRule<Options, MessageIds>({
 
         if (isFixable) {
           context.report({
-            node,
             messageId: 'preferNullishOverTernary',
+            node,
             suggest: [
               {
-                messageId: 'suggestNullish',
                 fix(fixer: TSESLint.RuleFixer): TSESLint.RuleFix {
                   const [left, right] =
                     operator === '===' || operator === '=='
@@ -295,6 +224,7 @@ export default createRule<Options, MessageIds>({
                     )}`,
                   );
                 },
+                messageId: 'suggestNullish',
               },
             ],
           });
@@ -375,18 +305,89 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node: barBarOperator,
           messageId: 'preferNullishOverOr',
+          node: barBarOperator,
           suggest: [
             {
-              messageId: 'suggestNullish',
               fix,
+              messageId: 'suggestNullish',
             },
           ],
         });
       },
     };
   },
+  defaultOptions: [
+    {
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      ignoreConditionalTests: true,
+      ignoreMixedLogicalExpressions: false,
+      ignorePrimitives: {
+        bigint: false,
+        boolean: false,
+        number: false,
+        string: false,
+      },
+      ignoreTernaryTests: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+      preferNullishOverOr:
+        'Prefer using nullish coalescing operator (`??`) instead of a logical or (`||`), as it is a safer operator.',
+      preferNullishOverTernary:
+        'Prefer using nullish coalescing operator (`??`) instead of a ternary expression, as it is simpler to read.',
+      suggestNullish: 'Fix to nullish coalescing operator (`??`).',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+          },
+          ignoreConditionalTests: {
+            type: 'boolean',
+          },
+          ignoreMixedLogicalExpressions: {
+            type: 'boolean',
+          },
+          ignorePrimitives: {
+            oneOf: [
+              {
+                properties: {
+                  bigint: { type: 'boolean' },
+                  boolean: { type: 'boolean' },
+                  number: { type: 'boolean' },
+                  string: { type: 'boolean' },
+                },
+                type: 'object',
+              },
+              {
+                enum: [true],
+                type: 'boolean',
+              },
+            ],
+          },
+          ignoreTernaryTests: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-nullish-coalescing',
 });
 
 function isConditionalTest(node: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts
index b755c9463954..de1147b54447 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts
@@ -1,14 +1,14 @@
 export type PreferOptionalChainMessageIds =
-  | 'preferOptionalChain'
-  | 'optionalChainSuggest';
+  | 'optionalChainSuggest'
+  | 'preferOptionalChain';
 
 export interface PreferOptionalChainOptions {
+  allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean;
   checkAny?: boolean;
-  checkUnknown?: boolean;
-  checkString?: boolean;
-  checkNumber?: boolean;
-  checkBoolean?: boolean;
   checkBigInt?: boolean;
+  checkBoolean?: boolean;
+  checkNumber?: boolean;
+  checkString?: boolean;
+  checkUnknown?: boolean;
   requireNullish?: boolean;
-  allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean;
 }
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts
index 8a3358ad7172..cd4894cc384c 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts
@@ -2,16 +2,23 @@ import type {
   ParserServicesWithTypeInformation,
   TSESTree,
 } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type {
   ReportDescriptor,
   ReportFixFunction,
   RuleContext,
   SourceCode,
 } from '@typescript-eslint/utils/ts-eslint';
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { unionTypeParts } from 'ts-api-utils';
 import * as ts from 'typescript';
 
+import type { ValidOperand } from './gatherLogicalOperands';
+import type {
+  PreferOptionalChainMessageIds,
+  PreferOptionalChainOptions,
+} from './PreferOptionalChainOptions';
+
 import {
   getFixOrSuggest,
   getOperatorPrecedenceForNode,
@@ -24,12 +31,7 @@ import {
 } from '../../util';
 import { checkNullishAndReport } from './checkNullishAndReport';
 import { compareNodes, NodeComparisonResult } from './compareNodes';
-import type { ValidOperand } from './gatherLogicalOperands';
 import { NullishComparisonType } from './gatherLogicalOperands';
-import type {
-  PreferOptionalChainMessageIds,
-  PreferOptionalChainOptions,
-} from './PreferOptionalChainOptions';
 
 function includesType(
   parserServices: ParserServicesWithTypeInformation,
@@ -55,7 +57,7 @@ type OperandAnalyzer = (
   operand: ValidOperand,
   index: number,
   chain: readonly ValidOperand[],
-) => readonly [ValidOperand] | readonly [ValidOperand, ValidOperand] | null;
+) => readonly [ValidOperand, ValidOperand] | readonly [ValidOperand] | null;
 const analyzeAndChainOperand: OperandAnalyzer = (
   parserServices,
   operand,
@@ -405,17 +407,17 @@ function getReportDescriptor(
     fixer.replaceTextRange(reportRange, newCode);
 
   return {
-    messageId: 'preferOptionalChain',
     loc: {
-      start: sourceCode.getLocFromIndex(reportRange[0]),
       end: sourceCode.getLocFromIndex(reportRange[1]),
+      start: sourceCode.getLocFromIndex(reportRange[0]),
     },
+    messageId: 'preferOptionalChain',
     ...getFixOrSuggest({
-      useFix: !useSuggestionFixer,
       suggestion: {
-        messageId: 'optionalChainSuggest',
         fix,
+        messageId: 'optionalChainSuggest',
       },
+      useFix: !useSuggestionFixer,
     }),
   };
 
@@ -541,7 +543,7 @@ export function analyzeChain(
 
   // Things like x !== null && x !== undefined have two nodes, but they are
   // one logical unit here, so we'll allow them to be grouped.
-  let subChain: (ValidOperand | readonly ValidOperand[])[] = [];
+  let subChain: (readonly ValidOperand[] | ValidOperand)[] = [];
   const maybeReportThenReset = (
     newChainSeed?: readonly [ValidOperand, ...ValidOperand[]],
   ): void => {
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/checkNullishAndReport.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/checkNullishAndReport.ts
index 404b3736040a..158376eb7755 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/checkNullishAndReport.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/checkNullishAndReport.ts
@@ -1,4 +1,3 @@
-import { isTypeFlagSet } from '@typescript-eslint/type-utils';
 import type {
   ParserServicesWithTypeInformation,
   TSESTree,
@@ -7,6 +6,8 @@ import type {
   ReportDescriptor,
   RuleContext,
 } from '@typescript-eslint/utils/ts-eslint';
+
+import { isTypeFlagSet } from '@typescript-eslint/type-utils';
 import { unionTypeParts } from 'ts-api-utils';
 import * as ts from 'typescript';
 
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/compareNodes.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/compareNodes.ts
index d9dce486ec91..8cbc5469f0d7 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/compareNodes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/compareNodes.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { visitorKeys } from '@typescript-eslint/visitor-keys';
 
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
index 53beee5d2826..82b519fcd08a 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
@@ -2,8 +2,9 @@ import type {
   ParserServicesWithTypeInformation,
   TSESTree,
 } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import {
   isBigIntLiteralType,
   isBooleanLiteralType,
@@ -13,17 +14,18 @@ import {
 } from 'ts-api-utils';
 import * as ts from 'typescript';
 
-import { isReferenceToGlobalFunction, isTypeFlagSet } from '../../util';
 import type { PreferOptionalChainOptions } from './PreferOptionalChainOptions';
 
+import { isReferenceToGlobalFunction, isTypeFlagSet } from '../../util';
+
 const enum ComparisonValueType {
   Null = 'Null', // eslint-disable-line @typescript-eslint/internal/prefer-ast-types-enum
   Undefined = 'Undefined',
   UndefinedStringLiteral = 'UndefinedStringLiteral',
 }
 export const enum OperandValidity {
-  Valid = 'Valid',
   Invalid = 'Invalid',
+  Valid = 'Valid',
 }
 export const enum NullishComparisonType {
   /** `x != null`, `x != undefined` */
@@ -47,16 +49,16 @@ export const enum NullishComparisonType {
   Boolean = 'Boolean', // eslint-disable-line @typescript-eslint/internal/prefer-ast-types-enum
 }
 export interface ValidOperand {
-  type: OperandValidity.Valid;
   comparedName: TSESTree.Node;
   comparisonType: NullishComparisonType;
   isYoda: boolean;
   node: TSESTree.Expression;
+  type: OperandValidity.Valid;
 }
 export interface InvalidOperand {
   type: OperandValidity.Invalid;
 }
-type Operand = ValidOperand | InvalidOperand;
+type Operand = InvalidOperand | ValidOperand;
 
 const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
 function isValidFalseBooleanCheckType(
@@ -118,11 +120,11 @@ export function gatherLogicalOperands(
   sourceCode: Readonly<SourceCode>,
   options: PreferOptionalChainOptions,
 ): {
-  operands: Operand[];
   newlySeenLogicals: Set<TSESTree.LogicalExpression>;
+  operands: Operand[];
 } {
   const result: Operand[] = [];
-  const { operands, newlySeenLogicals } = flattenLogicalOperands(node);
+  const { newlySeenLogicals, operands } = flattenLogicalOperands(node);
 
   for (const operand of operands) {
     const areMoreOperands = operand !== operands.at(-1);
@@ -164,13 +166,13 @@ export function gatherLogicalOperands(
 
             // typeof x.y === 'undefined'
             result.push({
-              type: OperandValidity.Valid,
               comparedName: comparedExpression.argument,
               comparisonType: operand.operator.startsWith('!')
                 ? NullishComparisonType.NotStrictEqualUndefined
                 : NullishComparisonType.StrictEqualUndefined,
               isYoda,
               node: operand,
+              type: OperandValidity.Valid,
             });
             continue;
           }
@@ -189,13 +191,13 @@ export function gatherLogicalOperands(
             ) {
               // x == null, x == undefined
               result.push({
-                type: OperandValidity.Valid,
                 comparedName: comparedExpression,
                 comparisonType: operand.operator.startsWith('!')
                   ? NullishComparisonType.NotEqualNullOrUndefined
                   : NullishComparisonType.EqualNullOrUndefined,
                 isYoda,
                 node: operand,
+                type: OperandValidity.Valid,
               });
               continue;
             }
@@ -209,25 +211,25 @@ export function gatherLogicalOperands(
             switch (comparedValue) {
               case ComparisonValueType.Null:
                 result.push({
-                  type: OperandValidity.Valid,
                   comparedName,
                   comparisonType: operand.operator.startsWith('!')
                     ? NullishComparisonType.NotStrictEqualNull
                     : NullishComparisonType.StrictEqualNull,
                   isYoda,
                   node: operand,
+                  type: OperandValidity.Valid,
                 });
                 continue;
 
               case ComparisonValueType.Undefined:
                 result.push({
-                  type: OperandValidity.Valid,
                   comparedName,
                   comparisonType: operand.operator.startsWith('!')
                     ? NullishComparisonType.NotStrictEqualUndefined
                     : NullishComparisonType.StrictEqualUndefined,
                   isYoda,
                   node: operand,
+                  type: OperandValidity.Valid,
                 });
                 continue;
 
@@ -254,11 +256,11 @@ export function gatherLogicalOperands(
           )
         ) {
           result.push({
-            type: OperandValidity.Valid,
             comparedName: operand.argument,
             comparisonType: NullishComparisonType.NotBoolean,
             isYoda: false,
             node: operand,
+            type: OperandValidity.Valid,
           });
           continue;
         }
@@ -280,11 +282,11 @@ export function gatherLogicalOperands(
           )
         ) {
           result.push({
-            type: OperandValidity.Valid,
             comparedName: operand,
             comparisonType: NullishComparisonType.Boolean,
             isYoda: false,
             node: operand,
+            type: OperandValidity.Valid,
           });
         } else {
           result.push({ type: OperandValidity.Invalid });
@@ -294,8 +296,8 @@ export function gatherLogicalOperands(
   }
 
   return {
-    operands: result,
     newlySeenLogicals,
+    operands: result,
   };
 
   /*
@@ -320,8 +322,8 @@ export function gatherLogicalOperands(
   like `foo || foo.bar && foo.bar.baz` - separate selector
   */
   function flattenLogicalOperands(node: TSESTree.LogicalExpression): {
-    operands: TSESTree.Expression[];
     newlySeenLogicals: Set<TSESTree.LogicalExpression>;
+    operands: TSESTree.Expression[];
   } {
     const operands: TSESTree.Expression[] = [];
     const newlySeenLogicals = new Set<TSESTree.LogicalExpression>([node]);
@@ -342,8 +344,8 @@ export function gatherLogicalOperands(
     }
 
     return {
-      operands,
       newlySeenLogicals,
+      operands,
     };
   }
 
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 1e979e47a4c8..8bbae4fe808f 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -1,8 +1,15 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { RuleFix } from '@typescript-eslint/utils/ts-eslint';
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
+import type { ValidOperand } from './prefer-optional-chain-utils/gatherLogicalOperands';
+import type {
+  PreferOptionalChainMessageIds,
+  PreferOptionalChainOptions,
+} from './prefer-optional-chain-utils/PreferOptionalChainOptions';
+
 import {
   createRule,
   getOperatorPrecedence,
@@ -11,97 +18,15 @@ import {
 } from '../util';
 import { analyzeChain } from './prefer-optional-chain-utils/analyzeChain';
 import { checkNullishAndReport } from './prefer-optional-chain-utils/checkNullishAndReport';
-import type { ValidOperand } from './prefer-optional-chain-utils/gatherLogicalOperands';
 import {
   gatherLogicalOperands,
   OperandValidity,
 } from './prefer-optional-chain-utils/gatherLogicalOperands';
-import type {
-  PreferOptionalChainMessageIds,
-  PreferOptionalChainOptions,
-} from './prefer-optional-chain-utils/PreferOptionalChainOptions';
 
 export default createRule<
   [PreferOptionalChainOptions],
   PreferOptionalChainMessageIds
 >({
-  name: 'prefer-optional-chain',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      preferOptionalChain:
-        "Prefer using an optional chain expression instead, as it's more concise and easier to read.",
-      optionalChainSuggest: 'Change to an optional chain.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          checkAny: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
-          },
-          checkUnknown: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
-          },
-          checkString: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
-          },
-          checkNumber: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
-          },
-          checkBoolean: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
-          },
-          checkBigInt: {
-            type: 'boolean',
-            description:
-              'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
-          },
-          requireNullish: {
-            type: 'boolean',
-            description:
-              'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
-          },
-          allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
-            type: 'boolean',
-            description:
-              'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      checkAny: true,
-      checkUnknown: true,
-      checkString: true,
-      checkNumber: true,
-      checkBoolean: true,
-      checkBigInt: true,
-      requireNullish: false,
-      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
-    },
-  ],
   create(context, [options]) {
     const parserServices = getParserServices(context);
 
@@ -109,6 +34,53 @@ export default createRule<
 
     return {
       // specific handling for `(foo ?? {}).bar` / `(foo || {}).bar`
+      'LogicalExpression[operator!="??"]'(
+        node: TSESTree.LogicalExpression,
+      ): void {
+        if (seenLogicals.has(node)) {
+          return;
+        }
+
+        const { newlySeenLogicals, operands } = gatherLogicalOperands(
+          node,
+          parserServices,
+          context.sourceCode,
+          options,
+        );
+        for (const logical of newlySeenLogicals) {
+          seenLogicals.add(logical);
+        }
+
+        let currentChain: ValidOperand[] = [];
+        for (const operand of operands) {
+          if (operand.type === OperandValidity.Invalid) {
+            analyzeChain(
+              context,
+              parserServices,
+              options,
+              node,
+              node.operator,
+              currentChain,
+            );
+            currentChain = [];
+          } else {
+            currentChain.push(operand);
+          }
+        }
+
+        // make sure to check whatever's left
+        if (currentChain.length > 0) {
+          analyzeChain(
+            context,
+            parserServices,
+            options,
+            node,
+            node.operator,
+            currentChain,
+          );
+        }
+      },
+
       'LogicalExpression[operator="||"], LogicalExpression[operator="??"]'(
         node: TSESTree.LogicalExpression,
       ): void {
@@ -147,7 +119,6 @@ export default createRule<
           node: parentNode,
           suggest: [
             {
-              messageId: 'optionalChainSuggest',
               fix: (fixer): RuleFix => {
                 const leftNodeText = context.sourceCode.getText(leftNode);
                 // Any node that is made of an operator with higher or equal precedence,
@@ -165,57 +136,88 @@ export default createRule<
                   `${maybeWrappedLeftNode}?.${maybeWrappedProperty}`,
                 );
               },
+              messageId: 'optionalChainSuggest',
             },
           ],
         });
       },
-
-      'LogicalExpression[operator!="??"]'(
-        node: TSESTree.LogicalExpression,
-      ): void {
-        if (seenLogicals.has(node)) {
-          return;
-        }
-
-        const { operands, newlySeenLogicals } = gatherLogicalOperands(
-          node,
-          parserServices,
-          context.sourceCode,
-          options,
-        );
-        for (const logical of newlySeenLogicals) {
-          seenLogicals.add(logical);
-        }
-
-        let currentChain: ValidOperand[] = [];
-        for (const operand of operands) {
-          if (operand.type === OperandValidity.Invalid) {
-            analyzeChain(
-              context,
-              parserServices,
-              options,
-              node,
-              node.operator,
-              currentChain,
-            );
-            currentChain = [];
-          } else {
-            currentChain.push(operand);
-          }
-        }
-
-        // make sure to check whatever's left
-        if (currentChain.length > 0) {
-          analyzeChain(
-            context,
-            parserServices,
-            options,
-            node,
-            node.operator,
-            currentChain,
-          );
-        }
-      },
     };
   },
+  defaultOptions: [
+    {
+      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+      checkAny: true,
+      checkBigInt: true,
+      checkBoolean: true,
+      checkNumber: true,
+      checkString: true,
+      checkUnknown: true,
+      requireNullish: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      optionalChainSuggest: 'Change to an optional chain.',
+      preferOptionalChain:
+        "Prefer using an optional chain expression instead, as it's more concise and easier to read.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
+            description:
+              'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
+            type: 'boolean',
+          },
+          checkAny: {
+            description:
+              'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          checkBigInt: {
+            description:
+              'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          checkBoolean: {
+            description:
+              'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          checkNumber: {
+            description:
+              'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          checkString: {
+            description:
+              'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          checkUnknown: {
+            description:
+              'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+          requireNullish: {
+            description:
+              'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index ef15fe918c17..6feb3eaea2f8 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -21,35 +22,6 @@ export type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-promise-reject-errors',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require using Error objects as Promise rejection reasons',
-      recommended: 'recommended',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowEmptyReject: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      rejectAnError: 'Expected the Promise rejection reason to be an Error.',
-    },
-  },
-  defaultOptions: [
-    {
-      allowEmptyReject: false,
-    },
-  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -68,8 +40,8 @@ export default createRule<Options, MessageIds>({
       }
 
       context.report({
-        node: callExpression,
         messageId: 'rejectAnError',
+        node: callExpression,
       });
     }
 
@@ -150,4 +122,33 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowEmptyReject: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Require using Error objects as Promise rejection reasons',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      rejectAnError: 'Expected the Promise rejection reason to be an Error.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowEmptyReject: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-promise-reject-errors',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index 6cb935c1db9a..8909a250d1b4 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -1,7 +1,9 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type { TypeOrValueSpecifier } from '../util';
+
 import {
   createRule,
   getParserServices,
@@ -21,44 +23,6 @@ type Options = [
 type MessageIds = 'shouldBeReadonly';
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-readonly-parameter-types',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allow: readonlynessOptionsSchema.properties.allow,
-          checkParameterProperties: {
-            type: 'boolean',
-          },
-          ignoreInferredTypes: {
-            type: 'boolean',
-          },
-          treatMethodsAsReadonly:
-            readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
-        },
-      },
-    ],
-    messages: {
-      shouldBeReadonly: 'Parameter should be a read only type.',
-    },
-  },
-  defaultOptions: [
-    {
-      allow: readonlynessOptionsDefaults.allow,
-      checkParameterProperties: true,
-      ignoreInferredTypes: false,
-      treatMethodsAsReadonly:
-        readonlynessOptionsDefaults.treatMethodsAsReadonly,
-    },
-  ],
   create(
     context,
     [
@@ -114,18 +78,56 @@ export default createRule<Options, MessageIds>({
 
           const type = services.getTypeAtLocation(actualParam);
           const isReadOnly = isTypeReadonly(services.program, type, {
-            treatMethodsAsReadonly: !!treatMethodsAsReadonly,
             allow,
+            treatMethodsAsReadonly: !!treatMethodsAsReadonly,
           });
 
           if (!isReadOnly) {
             context.report({
-              node: actualParam,
               messageId: 'shouldBeReadonly',
+              node: actualParam,
             });
           }
         }
       },
     };
   },
+  defaultOptions: [
+    {
+      allow: readonlynessOptionsDefaults.allow,
+      checkParameterProperties: true,
+      ignoreInferredTypes: false,
+      treatMethodsAsReadonly:
+        readonlynessOptionsDefaults.treatMethodsAsReadonly,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      shouldBeReadonly: 'Parameter should be a read only type.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: readonlynessOptionsSchema.properties.allow,
+          checkParameterProperties: {
+            type: 'boolean',
+          },
+          ignoreInferredTypes: {
+            type: 'boolean',
+          },
+          treatMethodsAsReadonly:
+            readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-readonly-parameter-types',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index f163b1aaab34..b347e0563b4d 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -29,32 +30,6 @@ const functionScopeBoundaries = [
 ].join(', ');
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-readonly',
-  meta: {
-    docs: {
-      description:
-        "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferReadonly:
-        "Member '{{name}}' is never reassigned; mark it as `readonly`.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          onlyInlineLambdas: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  defaultOptions: [{ onlyInlineLambdas: false }],
   create(context, [{ onlyInlineLambdas }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -171,6 +146,19 @@ export default createRule<Options, MessageIds>({
     }
 
     return {
+      [`${functionScopeBoundaries}:exit`](
+        node:
+          | TSESTree.ArrowFunctionExpression
+          | TSESTree.FunctionDeclaration
+          | TSESTree.FunctionExpression
+          | TSESTree.MethodDefinition,
+      ): void {
+        if (ASTUtils.isConstructor(node)) {
+          classScopeStack[classScopeStack.length - 1].exitConstructor();
+        } else if (isFunctionScopeBoundaryInStack(node)) {
+          classScopeStack[classScopeStack.length - 1].exitNonConstructor();
+        }
+      },
       'ClassDeclaration, ClassExpression'(
         node: TSESTree.ClassDeclaration | TSESTree.ClassExpression,
       ): void {
@@ -193,8 +181,8 @@ export default createRule<Options, MessageIds>({
             getEsNodesFromViolatingNode(violatingNode);
 
           const reportNodeOrLoc:
-            | { node: TSESTree.Node }
-            | { loc: TSESTree.SourceLocation } = (() => {
+            | { loc: TSESTree.SourceLocation }
+            | { node: TSESTree.Node } = (() => {
             switch (esNode.type) {
               case AST_NODE_TYPES.MethodDefinition:
               case AST_NODE_TYPES.PropertyDefinition:
@@ -223,18 +211,6 @@ export default createRule<Options, MessageIds>({
           });
         }
       },
-      MemberExpression(node): void {
-        if (classScopeStack.length !== 0 && !node.computed) {
-          const tsNode = services.esTreeNodeToTSNodeMap.get(
-            node,
-          ) as ts.PropertyAccessExpression;
-          handlePropertyAccessExpression(
-            tsNode,
-            tsNode.parent,
-            classScopeStack[classScopeStack.length - 1],
-          );
-        }
-      },
       [functionScopeBoundaries](
         node:
           | TSESTree.ArrowFunctionExpression
@@ -250,21 +226,46 @@ export default createRule<Options, MessageIds>({
           classScopeStack[classScopeStack.length - 1].enterNonConstructor();
         }
       },
-      [`${functionScopeBoundaries}:exit`](
-        node:
-          | TSESTree.ArrowFunctionExpression
-          | TSESTree.FunctionDeclaration
-          | TSESTree.FunctionExpression
-          | TSESTree.MethodDefinition,
-      ): void {
-        if (ASTUtils.isConstructor(node)) {
-          classScopeStack[classScopeStack.length - 1].exitConstructor();
-        } else if (isFunctionScopeBoundaryInStack(node)) {
-          classScopeStack[classScopeStack.length - 1].exitNonConstructor();
+      MemberExpression(node): void {
+        if (classScopeStack.length !== 0 && !node.computed) {
+          const tsNode = services.esTreeNodeToTSNodeMap.get(
+            node,
+          ) as ts.PropertyAccessExpression;
+          handlePropertyAccessExpression(
+            tsNode,
+            tsNode.parent,
+            classScopeStack[classScopeStack.length - 1],
+          );
         }
       },
     };
   },
+  defaultOptions: [{ onlyInlineLambdas: false }],
+  meta: {
+    docs: {
+      description:
+        "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferReadonly:
+        "Member '{{name}}' is never reassigned; mark it as `readonly`.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          onlyInlineLambdas: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'prefer-readonly',
 });
 
 type ParameterOrPropertyDeclaration =
@@ -282,20 +283,20 @@ enum TypeToClassRelation {
 }
 
 class ClassScope {
+  private readonly classType: ts.Type;
+  private constructorScopeDepth = OUTSIDE_CONSTRUCTOR;
+  private readonly memberVariableModifications = new Set<string>();
   private readonly privateModifiableMembers = new Map<
     string,
     ParameterOrPropertyDeclaration
   >();
+
   private readonly privateModifiableStatics = new Map<
     string,
     ParameterOrPropertyDeclaration
   >();
-  private readonly memberVariableModifications = new Set<string>();
-  private readonly staticVariableModifications = new Set<string>();
-
-  private readonly classType: ts.Type;
 
-  private constructorScopeDepth = OUTSIDE_CONSTRUCTOR;
+  private readonly staticVariableModifications = new Set<string>();
 
   public constructor(
     private readonly checker: ts.TypeChecker,
@@ -345,50 +346,6 @@ class ClassScope {
     ).set(node.name.getText(), node);
   }
 
-  public getTypeToClassRelation(type: ts.Type): TypeToClassRelation {
-    if (type.isIntersection()) {
-      let result: TypeToClassRelation = TypeToClassRelation.None;
-      for (const subType of type.types) {
-        const subTypeResult = this.getTypeToClassRelation(subType);
-        switch (subTypeResult) {
-          case TypeToClassRelation.Class:
-            if (result === TypeToClassRelation.Instance) {
-              return TypeToClassRelation.ClassAndInstance;
-            }
-            result = TypeToClassRelation.Class;
-            break;
-          case TypeToClassRelation.Instance:
-            if (result === TypeToClassRelation.Class) {
-              return TypeToClassRelation.ClassAndInstance;
-            }
-            result = TypeToClassRelation.Instance;
-            break;
-        }
-      }
-      return result;
-    }
-    if (type.isUnion()) {
-      // any union of class/instance and something else will prevent access to
-      // private members, so we assume that union consists only of classes
-      // or class instances, because otherwise tsc will report an error
-      return this.getTypeToClassRelation(type.types[0]);
-    }
-
-    if (!type.getSymbol() || !typeIsOrHasBaseType(type, this.classType)) {
-      return TypeToClassRelation.None;
-    }
-
-    const typeIsClass =
-      tsutils.isObjectType(type) &&
-      tsutils.isObjectFlagSet(type, ts.ObjectFlags.Anonymous);
-
-    if (typeIsClass) {
-      return TypeToClassRelation.Class;
-    }
-
-    return TypeToClassRelation.Instance;
-  }
-
   public addVariableModification(node: ts.PropertyAccessExpression): void {
     const modifierType = this.checker.getTypeAtLocation(node.expression);
 
@@ -432,16 +389,16 @@ class ClassScope {
     }
   }
 
-  public exitConstructor(): void {
-    this.constructorScopeDepth = OUTSIDE_CONSTRUCTOR;
-  }
-
   public enterNonConstructor(): void {
     if (this.constructorScopeDepth !== OUTSIDE_CONSTRUCTOR) {
       this.constructorScopeDepth += 1;
     }
   }
 
+  public exitConstructor(): void {
+    this.constructorScopeDepth = OUTSIDE_CONSTRUCTOR;
+  }
+
   public exitNonConstructor(): void {
     if (this.constructorScopeDepth !== OUTSIDE_CONSTRUCTOR) {
       this.constructorScopeDepth -= 1;
@@ -462,4 +419,48 @@ class ClassScope {
       ...Array.from(this.privateModifiableStatics.values()),
     ];
   }
+
+  public getTypeToClassRelation(type: ts.Type): TypeToClassRelation {
+    if (type.isIntersection()) {
+      let result: TypeToClassRelation = TypeToClassRelation.None;
+      for (const subType of type.types) {
+        const subTypeResult = this.getTypeToClassRelation(subType);
+        switch (subTypeResult) {
+          case TypeToClassRelation.Class:
+            if (result === TypeToClassRelation.Instance) {
+              return TypeToClassRelation.ClassAndInstance;
+            }
+            result = TypeToClassRelation.Class;
+            break;
+          case TypeToClassRelation.Instance:
+            if (result === TypeToClassRelation.Class) {
+              return TypeToClassRelation.ClassAndInstance;
+            }
+            result = TypeToClassRelation.Instance;
+            break;
+        }
+      }
+      return result;
+    }
+    if (type.isUnion()) {
+      // any union of class/instance and something else will prevent access to
+      // private members, so we assume that union consists only of classes
+      // or class instances, because otherwise tsc will report an error
+      return this.getTypeToClassRelation(type.types[0]);
+    }
+
+    if (!type.getSymbol() || !typeIsOrHasBaseType(type, this.classType)) {
+      return TypeToClassRelation.None;
+    }
+
+    const typeIsClass =
+      tsutils.isObjectType(type) &&
+      tsutils.isObjectFlagSet(type, ts.ObjectFlags.Anonymous);
+
+    if (typeIsClass) {
+      return TypeToClassRelation.Class;
+    }
+
+    return TypeToClassRelation.Instance;
+  }
 }
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 7eb781ed0d18..58e2ec5e384c 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type * as ts from 'typescript';
 
 import {
   createRule,
@@ -10,9 +11,9 @@ import {
   isTypeAssertion,
 } from '../util';
 
-type MemberExpressionWithCallExpressionParent = TSESTree.MemberExpression & {
+type MemberExpressionWithCallExpressionParent = {
   parent: TSESTree.CallExpression;
-};
+} & TSESTree.MemberExpression;
 
 const getMemberExpressionName = (
   member: TSESTree.MemberExpression,
@@ -32,23 +33,6 @@ const getMemberExpressionName = (
 };
 
 export default createRule({
-  name: 'prefer-reduce-type-parameter',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce using type parameter when calling `Array#reduce` instead of casting',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      preferTypeParameter:
-        'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -86,8 +70,6 @@ export default createRule({
         // Check the owner type of the `reduce` method.
         if (isArrayType(calleeObjType)) {
           context.report({
-            messageId: 'preferTypeParameter',
-            node: secondArg,
             fix: fixer => {
               const fixes = [
                 fixer.removeRange([
@@ -111,6 +93,8 @@ export default createRule({
 
               return fixes;
             },
+            messageId: 'preferTypeParameter',
+            node: secondArg,
           });
 
           return;
@@ -118,4 +102,21 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Enforce using type parameter when calling `Array#reduce` instead of casting',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferTypeParameter:
+        'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'prefer-reduce-type-parameter',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index b19e0305c7bb..921308ab1c8e 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -1,7 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
-import type * as ts from 'typescript';
 
 import {
   createRule,
@@ -12,31 +13,13 @@ import {
 } from '../util';
 
 enum ArgumentType {
+  Both = String | RegExp,
   Other = 0,
-  String = 1 << 0,
   RegExp = 1 << 1,
-  Both = String | RegExp,
+  String = 1 << 0,
 }
 
 export default createRule({
-  name: 'prefer-regexp-exec',
-  defaultOptions: [],
-
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description:
-        'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
-    },
-    schema: [],
-  },
-
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
@@ -132,14 +115,14 @@ export default createRule({
             return;
           }
           return context.report({
-            node: memberNode.property,
-            messageId: 'regExpExecOverStringMatch',
             fix: getWrappingFixer({
-              sourceCode: context.sourceCode,
-              node: callNode,
               innerNode: [objectNode],
+              node: callNode,
+              sourceCode: context.sourceCode,
               wrap: objectCode => `${regExp.toString()}.exec(${objectCode})`,
             }),
+            messageId: 'regExpExecOverStringMatch',
+            node: memberNode.property,
           });
         }
 
@@ -150,31 +133,49 @@ export default createRule({
         switch (argumentTypes) {
           case ArgumentType.RegExp:
             return context.report({
-              node: memberNode.property,
-              messageId: 'regExpExecOverStringMatch',
               fix: getWrappingFixer({
-                sourceCode: context.sourceCode,
-                node: callNode,
                 innerNode: [objectNode, argumentNode],
+                node: callNode,
+                sourceCode: context.sourceCode,
                 wrap: (objectCode, argumentCode) =>
                   `${argumentCode}.exec(${objectCode})`,
               }),
+              messageId: 'regExpExecOverStringMatch',
+              node: memberNode.property,
             });
 
           case ArgumentType.String:
             return context.report({
-              node: memberNode.property,
-              messageId: 'regExpExecOverStringMatch',
               fix: getWrappingFixer({
-                sourceCode: context.sourceCode,
-                node: callNode,
                 innerNode: [objectNode, argumentNode],
+                node: callNode,
+                sourceCode: context.sourceCode,
                 wrap: (objectCode, argumentCode) =>
                   `RegExp(${argumentCode}).exec(${objectCode})`,
               }),
+              messageId: 'regExpExecOverStringMatch',
+              node: memberNode.property,
             });
         }
       },
     };
   },
+  defaultOptions: [],
+
+  meta: {
+    docs: {
+      description:
+        'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'prefer-regexp-exec',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 80e55427078d..4e1099a7fe42 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -13,24 +14,6 @@ type FunctionLike =
   | TSESTree.MethodDefinition['value'];
 
 export default createRule({
-  name: 'prefer-return-this-type',
-  defaultOptions: [],
-
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce that `this` is used when only `this` type is returned',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      useThisType: 'Use `this` type instead.',
-    },
-    schema: [],
-    fixable: 'code',
-  },
-
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -140,9 +123,9 @@ export default createRule({
 
       if (isFunctionReturningThis(originalFunc, originalClass)) {
         context.report({
-          node,
-          messageId: 'useThisType',
           fix: fixer => fixer.replaceText(node, 'this'),
+          messageId: 'useThisType',
+          node,
         });
       }
     }
@@ -167,4 +150,22 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+
+  meta: {
+    docs: {
+      description:
+        'Enforce that `this` is used when only `this` type is returned',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      useThisType: 'Use `this` type instead.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'prefer-return-this-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index f6a22152043c..72ed3ae365f5 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -1,5 +1,6 @@
-import { RegExpParser } from '@eslint-community/regexpp';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import { RegExpParser } from '@eslint-community/regexpp';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import {
@@ -27,38 +28,6 @@ export type Options = [
 type MessageIds = 'preferEndsWith' | 'preferStartsWith';
 
 export default createRule<Options, MessageIds>({
-  name: 'prefer-string-starts-ends-with',
-  defaultOptions: [{ allowSingleElementEquality: 'never' }],
-
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      preferStartsWith: "Use 'String#startsWith' method instead.",
-      preferEndsWith: "Use the 'String#endsWith' method instead.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowSingleElementEquality: {
-            description:
-              'Whether to allow equality checks against the first or last element of a string.',
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    fixable: 'code',
-  },
-
   create(context, [{ allowSingleElementEquality }]) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
 
@@ -278,13 +247,13 @@ export default createRule<Options, MessageIds>({
      */
     function parseRegExp(
       node: TSESTree.Node,
-    ): { isStartsWith: boolean; isEndsWith: boolean; text: string } | null {
+    ): { isEndsWith: boolean; isStartsWith: boolean; text: string } | null {
       const evaluated = getStaticValue(node, globalScope);
       if (evaluated == null || !(evaluated.value instanceof RegExp)) {
         return null;
       }
 
-      const { source, flags } = evaluated.value;
+      const { flags, source } = evaluated.value;
       const isStartsWith = source.startsWith('^');
       const isEndsWith = source.endsWith('$');
       if (
@@ -435,8 +404,6 @@ export default createRule<Options, MessageIds>({
 
         const eqNode = parentNode;
         context.report({
-          node: parentNode,
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           fix(fixer) {
             // Don't fix if it can change the behavior.
             if (!isCharacter(eqNode.right)) {
@@ -450,6 +417,8 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          node: parentNode,
         });
       },
 
@@ -471,8 +440,6 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node: parentNode,
-          messageId: 'preferStartsWith',
           fix(fixer) {
             return fixWithArgument(
               fixer,
@@ -484,6 +451,8 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
+          messageId: 'preferStartsWith',
+          node: parentNode,
         });
       },
 
@@ -509,8 +478,6 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          node: parentNode,
-          messageId: 'preferEndsWith',
           fix(fixer) {
             return fixWithArgument(
               fixer,
@@ -522,6 +489,8 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
+          messageId: 'preferEndsWith',
+          node: parentNode,
         });
       },
 
@@ -552,8 +521,6 @@ export default createRule<Options, MessageIds>({
 
         const { isStartsWith, text } = parsed;
         context.report({
-          node: callNode,
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           *fix(fixer) {
             if (!parentNode.operator.startsWith('!')) {
               yield fixer.insertTextBefore(parentNode, '!');
@@ -570,6 +537,8 @@ export default createRule<Options, MessageIds>({
             );
             yield fixer.removeRange([callNode.range[1], parentNode.range[1]]);
           },
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          node: callNode,
         });
       },
 
@@ -638,8 +607,6 @@ export default createRule<Options, MessageIds>({
         const negativeIndexSupported =
           (node.property as TSESTree.Identifier).name === 'slice';
         context.report({
-          node: parentNode,
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           fix(fixer) {
             // Don't fix if it can change the behavior.
             if (
@@ -680,6 +647,8 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          node: parentNode,
         });
       },
 
@@ -699,8 +668,6 @@ export default createRule<Options, MessageIds>({
         const messageId = isStartsWith ? 'preferStartsWith' : 'preferEndsWith';
         const methodName = isStartsWith ? 'startsWith' : 'endsWith';
         context.report({
-          node: callNode,
-          messageId,
           *fix(fixer) {
             const argNode = callNode.arguments[0];
             const needsParen =
@@ -722,8 +689,42 @@ export default createRule<Options, MessageIds>({
               )}`,
             );
           },
+          messageId,
+          node: callNode,
         });
       },
     };
   },
+  defaultOptions: [{ allowSingleElementEquality: 'never' }],
+
+  meta: {
+    docs: {
+      description:
+        'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferEndsWith: "Use the 'String#endsWith' method instead.",
+      preferStartsWith: "Use 'String#startsWith' method instead.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowSingleElementEquality: {
+            description:
+              'Whether to allow equality checks against the first or last element of a string.',
+            enum: ['always', 'never'],
+            type: 'string',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+
+  name: 'prefer-string-starts-ends-with',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 6ae1f11720e1..836719a2b725 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -1,28 +1,13 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import type { RuleFix, RuleFixer } from '@typescript-eslint/utils/ts-eslint';
 
+import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+
 import { createRule } from '../util';
 
 type MessageIds = 'preferExpectErrorComment';
 
 export default createRule<[], MessageIds>({
-  name: 'prefer-ts-expect-error',
-  meta: {
-    type: 'problem',
-    deprecated: true,
-    replacedBy: ['@typescript-eslint/ban-ts-comment'],
-    docs: {
-      description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
-    },
-    fixable: 'code',
-    messages: {
-      preferExpectErrorComment:
-        'Use "@ts-expect-error" to ensure an error is actually being suppressed.',
-    },
-    schema: [],
-  },
-  defaultOptions: [],
   create(context) {
     const tsIgnoreRegExpSingleLine = /^\s*\/?\s*@ts-ignore/;
     const tsIgnoreRegExpMultiLine = /^\s*(?:\/|\*)*\s*@ts-ignore/;
@@ -69,15 +54,31 @@ export default createRule<[], MessageIds>({
               );
 
             context.report({
-              node: comment,
-              messageId: 'preferExpectErrorComment',
               fix: isLineComment(comment)
                 ? lineCommentRuleFixer
                 : blockCommentRuleFixer,
+              messageId: 'preferExpectErrorComment',
+              node: comment,
             });
           }
         });
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
+    },
+    fixable: 'code',
+    messages: {
+      preferExpectErrorComment:
+        'Use "@ts-expect-error" to ensure an error is actually being suppressed.',
+    },
+    replacedBy: ['@typescript-eslint/ban-ts-comment'],
+    schema: [],
+    type: 'problem',
+  },
+  name: 'prefer-ts-expect-error',
 });
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index c191ce45b0db..8642d77063e7 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -25,62 +26,6 @@ type Options = [
 type MessageIds = 'missingAsync';
 
 export default createRule<Options, MessageIds>({
-  name: 'promise-function-async',
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description:
-        'Require any function or method that returns a Promise to be marked async',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      missingAsync: 'Functions that return promises must be async.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowAny: {
-            description:
-              'Whether to consider `any` and `unknown` to be Promises.',
-            type: 'boolean',
-          },
-          allowedPromiseNames: {
-            description:
-              'Any extra names of classes or interfaces to be considered Promises.',
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-          checkArrowFunctions: {
-            type: 'boolean',
-          },
-          checkFunctionDeclarations: {
-            type: 'boolean',
-          },
-          checkFunctionExpressions: {
-            type: 'boolean',
-          },
-          checkMethodDeclarations: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowedPromiseNames: [],
-      checkArrowFunctions: true,
-      checkFunctionDeclarations: true,
-      checkFunctionExpressions: true,
-      checkMethodDeclarations: true,
-    },
-  ],
   create(
     context,
     [
@@ -146,16 +91,13 @@ export default createRule<Options, MessageIds>({
       if (isTypeFlagSet(returnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
         // Report without auto fixer because the return type is unknown
         return context.report({
+          loc: getFunctionHeadLoc(node, context.sourceCode),
           messageId: 'missingAsync',
           node,
-          loc: getFunctionHeadLoc(node, context.sourceCode),
         });
       }
 
       context.report({
-        messageId: 'missingAsync',
-        node,
-        loc: getFunctionHeadLoc(node, context.sourceCode),
         fix: fixer => {
           if (
             node.parent.type === AST_NODE_TYPES.MethodDefinition ||
@@ -212,6 +154,9 @@ export default createRule<Options, MessageIds>({
 
           return fixer.insertTextBefore(node, 'async ');
         },
+        loc: getFunctionHeadLoc(node, context.sourceCode),
+        messageId: 'missingAsync',
+        node,
       });
     }
 
@@ -248,4 +193,60 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowedPromiseNames: [],
+      checkArrowFunctions: true,
+      checkFunctionDeclarations: true,
+      checkFunctionExpressions: true,
+      checkMethodDeclarations: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require any function or method that returns a Promise to be marked async',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      missingAsync: 'Functions that return promises must be async.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowAny: {
+            description:
+              'Whether to consider `any` and `unknown` to be Promises.',
+            type: 'boolean',
+          },
+          allowedPromiseNames: {
+            description:
+              'Any extra names of classes or interfaces to be considered Promises.',
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          checkArrowFunctions: {
+            type: 'boolean',
+          },
+          checkFunctionDeclarations: {
+            type: 'boolean',
+          },
+          checkFunctionExpressions: {
+            type: 'boolean',
+          },
+          checkMethodDeclarations: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'promise-function-async',
 });
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index e6f83e800bbb..dea7e1009985 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -16,38 +16,6 @@ export type Options = [
 export type MessageIds = 'requireCompare';
 
 export default createRule<Options, MessageIds>({
-  name: 'require-array-sort-compare',
-  defaultOptions: [
-    {
-      ignoreStringArrays: true,
-    },
-  ],
-
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      requireCompare: "Require 'compare' argument.",
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          ignoreStringArrays: {
-            description:
-              'Whether to ignore arrays in which all elements are strings.',
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-  },
-
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -76,7 +44,7 @@ export default createRule<Options, MessageIds>({
       }
 
       if (isTypeArrayTypeOrUnionOfArrayTypes(calleeObjType, checker)) {
-        context.report({ node: callee.parent, messageId: 'requireCompare' });
+        context.report({ messageId: 'requireCompare', node: callee.parent });
       }
     }
 
@@ -87,4 +55,36 @@ export default createRule<Options, MessageIds>({
         checkSortArgument,
     };
   },
+  defaultOptions: [
+    {
+      ignoreStringArrays: true,
+    },
+  ],
+
+  meta: {
+    docs: {
+      description:
+        'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      requireCompare: "Require 'compare' argument.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreStringArrays: {
+            description:
+              'Whether to ignore arrays in which all elements are strings.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+
+  name: 'require-array-sort-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index e08b4a895a43..33af3017a3a4 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -1,9 +1,10 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import type { AST, RuleFix } from '@typescript-eslint/utils/ts-eslint';
-import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+import * as tsutils from 'ts-api-utils';
+
 import {
   createRule,
   getFunctionHeadLoc,
@@ -16,11 +17,11 @@ import {
 } from '../util';
 
 interface ScopeInfo {
-  upper: ScopeInfo | null;
-  hasAwait: boolean;
   hasAsync: boolean;
-  isGen: boolean;
+  hasAwait: boolean;
   isAsyncYield: boolean;
+  isGen: boolean;
+  upper: ScopeInfo | null;
 }
 type FunctionNode =
   | TSESTree.ArrowFunctionExpression
@@ -28,24 +29,6 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule({
-  name: 'require-await',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow async functions which do not return promises and have no `await` expression',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-      extendsBaseRule: true,
-    },
-    schema: [],
-    messages: {
-      missingAwait: "{{name}} has no 'await' expression.",
-      removeAsync: "Remove 'async'.",
-    },
-    hasSuggestions: true,
-  },
-  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -57,11 +40,11 @@ export default createRule({
      */
     function enterFunction(node: FunctionNode): void {
       scopeInfo = {
-        upper: scopeInfo,
-        hasAwait: false,
         hasAsync: node.async,
-        isGen: node.generator || false,
+        hasAwait: false,
         isAsyncYield: false,
+        isGen: node.generator || false,
+        upper: scopeInfo,
       };
     }
 
@@ -186,21 +169,21 @@ export default createRule({
         }
 
         context.report({
-          node,
-          loc: getFunctionHeadLoc(node, context.sourceCode),
-          messageId: 'missingAwait',
           data: {
             name: upperCaseFirst(getFunctionNameWithKind(node)),
           },
+          loc: getFunctionHeadLoc(node, context.sourceCode),
+          messageId: 'missingAwait',
+          node,
           suggest: [
             {
-              messageId: 'removeAsync',
               fix: (fixer): RuleFix[] =>
                 changes.map(change =>
                   change.replacement !== undefined
                     ? fixer.replaceTextRange(change.range, change.replacement)
                     : fixer.removeRange(change.range),
                 ),
+              messageId: 'removeAsync',
             },
           ],
         });
@@ -268,16 +251,16 @@ export default createRule({
     }
 
     return {
-      FunctionDeclaration: enterFunction,
-      FunctionExpression: enterFunction,
       ArrowFunctionExpression: enterFunction,
-      'FunctionDeclaration:exit': exitFunction,
-      'FunctionExpression:exit': exitFunction,
       'ArrowFunctionExpression:exit': exitFunction,
-
       AwaitExpression: markAsHasAwait,
-      'VariableDeclaration[kind = "await using"]': markAsHasAwait,
       'ForOfStatement[await = true]': markAsHasAwait,
+      FunctionDeclaration: enterFunction,
+      'FunctionDeclaration:exit': exitFunction,
+
+      FunctionExpression: enterFunction,
+      'FunctionExpression:exit': exitFunction,
+      'VariableDeclaration[kind = "await using"]': markAsHasAwait,
       YieldExpression: visitYieldExpression,
 
       // check body-less async arrow function.
@@ -306,6 +289,24 @@ export default createRule({
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Disallow async functions which do not return promises and have no `await` expression',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      missingAwait: "{{name}} has no 'await' expression.",
+      removeAsync: "Remove 'async'.",
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  name: 'require-await',
 });
 
 function isEmptyFunction(node: FunctionNode): boolean {
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index 1953c15c70cb..f60ebde2fce6 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -25,79 +26,6 @@ type Options = [
 type MessageIds = 'bigintAndNumber' | 'invalid' | 'mismatched';
 
 export default createRule<Options, MessageIds>({
-  name: 'restrict-plus-operands',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
-      recommended: {
-        recommended: true,
-        strict: [
-          {
-            allowAny: false,
-            allowBoolean: false,
-            allowNullish: false,
-            allowNumberAndString: false,
-            allowRegExp: false,
-          },
-        ],
-      },
-      requiresTypeChecking: true,
-    },
-    messages: {
-      bigintAndNumber:
-        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
-      invalid:
-        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
-      mismatched:
-        "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          allowAny: {
-            description: 'Whether to allow `any` typed values.',
-            type: 'boolean',
-          },
-          allowBoolean: {
-            description: 'Whether to allow `boolean` typed values.',
-            type: 'boolean',
-          },
-          allowNullish: {
-            description:
-              'Whether to allow potentially `null` or `undefined` typed values.',
-            type: 'boolean',
-          },
-          allowNumberAndString: {
-            description:
-              'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
-            type: 'boolean',
-          },
-          allowRegExp: {
-            description: 'Whether to allow `regexp` typed values.',
-            type: 'boolean',
-          },
-          skipCompoundAssignments: {
-            description: 'Whether to skip compound assignments such as `+=`.',
-            type: 'boolean',
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumberAndString: true,
-      allowRegExp: true,
-      skipCompoundAssignments: false,
-    },
-  ],
   create(
     context,
     [
@@ -221,9 +149,9 @@ export default createRule<Options, MessageIds>({
         ) {
           return context.report({
             data: {
-              stringLike,
               left: typeChecker.typeToString(leftType),
               right: typeChecker.typeToString(rightType),
+              stringLike,
             },
             messageId: 'mismatched',
             node,
@@ -255,6 +183,79 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumberAndString: true,
+      allowRegExp: true,
+      skipCompoundAssignments: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
+      recommended: {
+        recommended: true,
+        strict: [
+          {
+            allowAny: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumberAndString: false,
+            allowRegExp: false,
+          },
+        ],
+      },
+      requiresTypeChecking: true,
+    },
+    messages: {
+      bigintAndNumber:
+        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
+      invalid:
+        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
+      mismatched:
+        "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowAny: {
+            description: 'Whether to allow `any` typed values.',
+            type: 'boolean',
+          },
+          allowBoolean: {
+            description: 'Whether to allow `boolean` typed values.',
+            type: 'boolean',
+          },
+          allowNullish: {
+            description:
+              'Whether to allow potentially `null` or `undefined` typed values.',
+            type: 'boolean',
+          },
+          allowNumberAndString: {
+            description:
+              'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
+            type: 'boolean',
+          },
+          allowRegExp: {
+            description: 'Whether to allow `regexp` typed values.',
+            type: 'boolean',
+          },
+          skipCompoundAssignments: {
+            description: 'Whether to skip compound assignments such as `+=`.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'restrict-plus-operands',
 });
 
 function isDeeplyObjectType(type: ts.Type): boolean {
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index 5aa90084ac63..c733d4f5b9fc 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -1,6 +1,7 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { Type, TypeChecker } from 'typescript';
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { TypeFlags } from 'typescript';
 
 import {
@@ -45,9 +46,9 @@ const optionTesters = (
     ['Never', isTypeNeverType],
   ] satisfies [string, OptionTester][]
 ).map(([type, tester]) => ({
-  type,
   option: `allow${type}` as const,
   tester,
+  type,
 }));
 type Options = [
   { [Type in (typeof optionTesters)[number]['option']]?: boolean },
@@ -56,55 +57,6 @@ type Options = [
 type MessageId = 'invalidType';
 
 export default createRule<Options, MessageId>({
-  name: 'restrict-template-expressions',
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce template literal expressions to be of `string` type',
-      recommended: {
-        recommended: true,
-        strict: [
-          {
-            allowAny: false,
-            allowBoolean: false,
-            allowNullish: false,
-            allowNumber: false,
-            allowRegExp: false,
-            allowNever: false,
-          },
-        ],
-      },
-      requiresTypeChecking: true,
-    },
-    messages: {
-      invalidType: 'Invalid type "{{type}}" of template literal expression.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: Object.fromEntries(
-          optionTesters.map(({ option, type }) => [
-            option,
-            {
-              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
-              type: 'boolean',
-            },
-          ]),
-        ),
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumber: true,
-      allowRegExp: true,
-    },
-  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -127,9 +79,9 @@ export default createRule<Options, MessageId>({
 
           if (!recursivelyCheckType(expressionType)) {
             context.report({
-              node: expression,
-              messageId: 'invalidType',
               data: { type: checker.typeToString(expressionType) },
+              messageId: 'invalidType',
+              node: expression,
             });
           }
         }
@@ -153,4 +105,53 @@ export default createRule<Options, MessageId>({
       );
     }
   },
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumber: true,
+      allowRegExp: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Enforce template literal expressions to be of `string` type',
+      recommended: {
+        recommended: true,
+        strict: [
+          {
+            allowAny: false,
+            allowBoolean: false,
+            allowNever: false,
+            allowNullish: false,
+            allowNumber: false,
+            allowRegExp: false,
+          },
+        ],
+      },
+      requiresTypeChecking: true,
+    },
+    messages: {
+      invalidType: 'Invalid type "{{type}}" of template literal expression.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: Object.fromEntries(
+          optionTesters.map(({ option, type }) => [
+            option,
+            {
+              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
+              type: 'boolean',
+            },
+          ]),
+        ),
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'restrict-template-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index 716962a8a11b..1562a58a80d9 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -25,51 +26,12 @@ interface ScopeInfo {
 }
 
 type Option =
-  | 'in-try-catch'
   | 'always'
-  | 'never'
-  | 'error-handling-correctness-only';
+  | 'error-handling-correctness-only'
+  | 'in-try-catch'
+  | 'never';
 
 export default createRule({
-  name: 'return-await',
-  meta: {
-    docs: {
-      description: 'Enforce consistent awaiting of returned promises',
-      requiresTypeChecking: true,
-      extendsBaseRule: 'no-return-await',
-      recommended: {
-        strict: ['error-handling-correctness-only'],
-      },
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    type: 'problem',
-    messages: {
-      nonPromiseAwait:
-        'Returning an awaited value that is not a promise is not allowed.',
-      disallowedPromiseAwait:
-        'Returning an awaited promise is not allowed in this context.',
-      requiredPromiseAwait:
-        'Returning an awaited promise is required in this context.',
-      requiredPromiseAwaitSuggestion:
-        'Add `await` before the expression. Use caution as this may impact control flow.',
-      disallowedPromiseAwaitSuggestion:
-        'Remove `await` before the expression. Use caution as this may impact control flow.',
-    },
-    schema: [
-      {
-        type: 'string',
-        enum: [
-          'in-try-catch',
-          'always',
-          'never',
-          'error-handling-correctness-only',
-        ] satisfies Option[],
-      },
-    ],
-  },
-  defaultOptions: ['in-try-catch'],
-
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -108,7 +70,7 @@ export default createRule({
           // if it's a using/await using declaration, and it comes _before_ the
           // node we're checking, it affects control flow for that node.
           if (
-            ['using', 'await using'].includes(declarationNode.kind) &&
+            ['await using', 'using'].includes(declarationNode.kind) &&
             declaratorNode.range[1] < node.range[0]
           ) {
             return true;
@@ -149,13 +111,9 @@ export default createRule({
         return false;
       }
 
-      const { tryStatement, block } = tryAncestorResult;
+      const { block, tryStatement } = tryAncestorResult;
 
       switch (block) {
-        case 'try':
-          // Try blocks are always followed by either a catch or finally,
-          // so exceptions thrown here always affect control flow.
-          return true;
         case 'catch':
           // Exceptions thrown in catch blocks followed by a finally block affect
           // control flow.
@@ -167,6 +125,10 @@ export default createRule({
           return affectsExplicitErrorHandling(tryStatement);
         case 'finally':
           return affectsExplicitErrorHandling(tryStatement);
+        case 'try':
+          // Try blocks are always followed by either a catch or finally,
+          // so exceptions thrown here always affect control flow.
+          return true;
         default: {
           const __never: never = block;
           throw new Error(`Unexpected block type: ${String(__never)}`);
@@ -175,8 +137,8 @@ export default createRule({
     }
 
     interface FindContainingTryStatementResult {
+      block: 'catch' | 'finally' | 'try';
       tryStatement: ts.TryStatement;
-      block: 'try' | 'catch' | 'finally';
     }
 
     /**
@@ -193,7 +155,7 @@ export default createRule({
 
       while (ancestor && !ts.isFunctionLike(ancestor)) {
         if (ts.isTryStatement(ancestor)) {
-          let block: 'try' | 'catch' | 'finally' | undefined;
+          let block: 'catch' | 'finally' | 'try' | undefined;
           if (child === ancestor.tryBlock) {
             block = 'try';
           } else if (child === ancestor.catchClause) {
@@ -203,11 +165,11 @@ export default createRule({
           }
 
           return {
-            tryStatement: ancestor,
             block: nullThrows(
               block,
               'Child of a try statement must be a try block, catch clause, or finally block',
             ),
+            tryStatement: ancestor,
           };
         }
         child = ancestor;
@@ -296,8 +258,8 @@ export default createRule({
             messageId: 'nonPromiseAwait',
             node,
             ...fixOrSuggest(useAutoFix, {
-              messageId: 'nonPromiseAwait',
               fix: fixer => removeAwait(fixer, node),
+              messageId: 'nonPromiseAwait',
             }),
           });
         }
@@ -318,33 +280,33 @@ export default createRule({
         : ruleConfiguration.ordinaryContext;
 
       switch (shouldAwaitInCurrentContext) {
-        case "don't-care":
-          break;
         case 'await':
           if (!isAwait) {
             context.report({
               messageId: 'requiredPromiseAwait',
               node,
               ...fixOrSuggest(useAutoFix, {
-                messageId: 'requiredPromiseAwaitSuggestion',
                 fix: fixer =>
                   insertAwait(
                     fixer,
                     node,
                     isHigherPrecedenceThanAwait(expression),
                   ),
+                messageId: 'requiredPromiseAwaitSuggestion',
               }),
             });
           }
           break;
+        case "don't-care":
+          break;
         case 'no-await':
           if (isAwait) {
             context.report({
               messageId: 'disallowedPromiseAwait',
               node,
               ...fixOrSuggest(useAutoFix, {
-                messageId: 'disallowedPromiseAwaitSuggestion',
                 fix: fixer => removeAwait(fixer, node),
+                messageId: 'disallowedPromiseAwaitSuggestion',
               }),
             });
           }
@@ -365,13 +327,13 @@ export default createRule({
     }
 
     return {
-      FunctionDeclaration: enterFunction,
-      FunctionExpression: enterFunction,
       ArrowFunctionExpression: enterFunction,
+      'ArrowFunctionExpression:exit': exitFunction,
+      FunctionDeclaration: enterFunction,
 
       'FunctionDeclaration:exit': exitFunction,
+      FunctionExpression: enterFunction,
       'FunctionExpression:exit': exitFunction,
-      'ArrowFunctionExpression:exit': exitFunction,
 
       // executes after less specific handler, so exitFunction is called
       'ArrowFunctionExpression[async = true]:exit'(
@@ -396,36 +358,75 @@ export default createRule({
       },
     };
   },
+  defaultOptions: ['in-try-catch'],
+  meta: {
+    docs: {
+      description: 'Enforce consistent awaiting of returned promises',
+      extendsBaseRule: 'no-return-await',
+      recommended: {
+        strict: ['error-handling-correctness-only'],
+      },
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      disallowedPromiseAwait:
+        'Returning an awaited promise is not allowed in this context.',
+      disallowedPromiseAwaitSuggestion:
+        'Remove `await` before the expression. Use caution as this may impact control flow.',
+      nonPromiseAwait:
+        'Returning an awaited value that is not a promise is not allowed.',
+      requiredPromiseAwait:
+        'Returning an awaited promise is required in this context.',
+      requiredPromiseAwaitSuggestion:
+        'Add `await` before the expression. Use caution as this may impact control flow.',
+    },
+    schema: [
+      {
+        enum: [
+          'in-try-catch',
+          'always',
+          'never',
+          'error-handling-correctness-only',
+        ] satisfies Option[],
+        type: 'string',
+      },
+    ],
+    type: 'problem',
+  },
+
+  name: 'return-await',
 });
 
-type WhetherToAwait = 'await' | 'no-await' | "don't-care";
+type WhetherToAwait = "don't-care" | 'await' | 'no-await';
 
 interface RuleConfiguration {
-  ordinaryContext: WhetherToAwait;
   errorHandlingContext: WhetherToAwait;
+  ordinaryContext: WhetherToAwait;
 }
 
 function getConfiguration(option: Option): RuleConfiguration {
   switch (option) {
     case 'always':
       return {
-        ordinaryContext: 'await',
         errorHandlingContext: 'await',
-      };
-    case 'never':
-      return {
-        ordinaryContext: 'no-await',
-        errorHandlingContext: 'no-await',
+        ordinaryContext: 'await',
       };
     case 'error-handling-correctness-only':
       return {
-        ordinaryContext: "don't-care",
         errorHandlingContext: 'await',
+        ordinaryContext: "don't-care",
       };
     case 'in-try-catch':
       return {
-        ordinaryContext: 'no-await',
         errorHandlingContext: 'await',
+        ordinaryContext: 'no-await',
+      };
+    case 'never':
+      return {
+        errorHandlingContext: 'no-await',
+        ordinaryContext: 'no-await',
       };
   }
 }
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index de87dc2aa962..d73887909d6d 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule, getEnumNames, typeNodeRequiresParentheses } from '../util';
@@ -9,9 +10,9 @@ enum Group {
   import = 'import',
   intersection = 'intersection',
   keyword = 'keyword',
-  nullish = 'nullish',
   literal = 'literal',
   named = 'named',
+  nullish = 'nullish',
   object = 'object',
   operator = 'operator',
   tuple = 'tuple',
@@ -106,91 +107,22 @@ function caseSensitiveSort(a: string, b: string): number {
 
 export type Options = [
   {
+    caseSensitive?: boolean;
     checkIntersections?: boolean;
     checkUnions?: boolean;
-    caseSensitive?: boolean;
     groupOrder?: string[];
   },
 ];
 export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix';
 
 export default createRule<Options, MessageIds>({
-  name: 'sort-type-constituents',
-  meta: {
-    deprecated: true,
-    replacedBy: [
-      'perfectionist/sort-intersection-types',
-      'perfectionist/sort-union-types',
-    ],
-    type: 'suggestion',
-    docs: {
-      description:
-        'Enforce constituents of a type union/intersection to be sorted alphabetically',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      notSorted: '{{type}} type constituents must be sorted.',
-      notSortedNamed: '{{type}} type {{name}} constituents must be sorted.',
-      suggestFix: 'Sort constituents of type (removes all comments).',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          checkIntersections: {
-            description: 'Whether to check intersection types.',
-            type: 'boolean',
-          },
-          checkUnions: {
-            description: 'Whether to check union types.',
-            type: 'boolean',
-          },
-          caseSensitive: {
-            description: 'Whether to sort using case sensitive sorting.',
-            type: 'boolean',
-          },
-          groupOrder: {
-            description: 'Ordering of the groups.',
-            type: 'array',
-            items: {
-              type: 'string',
-              enum: getEnumNames(Group),
-            },
-          },
-        },
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      checkIntersections: true,
-      checkUnions: true,
-      caseSensitive: false,
-      groupOrder: [
-        Group.named,
-        Group.keyword,
-        Group.operator,
-        Group.literal,
-        Group.function,
-        Group.import,
-        Group.conditional,
-        Group.object,
-        Group.tuple,
-        Group.intersection,
-        Group.union,
-        Group.nullish,
-      ],
-    },
-  ],
   create(
     context,
-    [{ checkIntersections, checkUnions, caseSensitive, groupOrder }],
+    [{ caseSensitive, checkIntersections, checkUnions, groupOrder }],
   ) {
     const collator = new Intl.Collator('en', {
-      sensitivity: 'base',
       numeric: true,
+      sensitivity: 'base',
     });
 
     function checkSorting(
@@ -257,17 +189,17 @@ export default createRule<Options, MessageIds>({
             return fixer.replaceText(node, sorted);
           };
           return context.report({
-            node,
-            messageId,
             data,
+            messageId,
+            node,
             // don't autofix if any of the types have leading/trailing comments
             // the logic for preserving them correctly is a pain - we may implement this later
             ...(hasComments
               ? {
                   suggest: [
                     {
-                      messageId: 'suggestFix',
                       fix,
+                      messageId: 'suggestFix',
                     },
                   ],
                 }
@@ -290,4 +222,73 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
+  defaultOptions: [
+    {
+      caseSensitive: false,
+      checkIntersections: true,
+      checkUnions: true,
+      groupOrder: [
+        Group.named,
+        Group.keyword,
+        Group.operator,
+        Group.literal,
+        Group.function,
+        Group.import,
+        Group.conditional,
+        Group.object,
+        Group.tuple,
+        Group.intersection,
+        Group.union,
+        Group.nullish,
+      ],
+    },
+  ],
+  meta: {
+    deprecated: true,
+    docs: {
+      description:
+        'Enforce constituents of a type union/intersection to be sorted alphabetically',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      notSorted: '{{type}} type constituents must be sorted.',
+      notSortedNamed: '{{type}} type {{name}} constituents must be sorted.',
+      suggestFix: 'Sort constituents of type (removes all comments).',
+    },
+    replacedBy: [
+      'perfectionist/sort-intersection-types',
+      'perfectionist/sort-union-types',
+    ],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          caseSensitive: {
+            description: 'Whether to sort using case sensitive sorting.',
+            type: 'boolean',
+          },
+          checkIntersections: {
+            description: 'Whether to check intersection types.',
+            type: 'boolean',
+          },
+          checkUnions: {
+            description: 'Whether to check union types.',
+            type: 'boolean',
+          },
+          groupOrder: {
+            description: 'Ordering of the groups.',
+            items: {
+              enum: getEnumNames(Group),
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'sort-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index 3e01b5c15a1a..630925365333 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -2,6 +2,7 @@ import type {
   ParserServicesWithTypeInformation,
   TSESTree,
 } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -16,15 +17,15 @@ import {
 
 export type Options = [
   {
-    allowString?: boolean;
-    allowNumber?: boolean;
-    allowNullableObject?: boolean;
+    allowAny?: boolean;
     allowNullableBoolean?: boolean;
-    allowNullableString?: boolean;
-    allowNullableNumber?: boolean;
     allowNullableEnum?: boolean;
-    allowAny?: boolean;
+    allowNullableNumber?: boolean;
+    allowNullableObject?: boolean;
+    allowNullableString?: boolean;
+    allowNumber?: boolean;
     allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    allowString?: boolean;
   },
 ];
 
@@ -54,108 +55,6 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
-  name: 'strict-boolean-expressions',
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    hasSuggestions: true,
-    docs: {
-      description: 'Disallow certain types in boolean expressions',
-      requiresTypeChecking: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowString: { type: 'boolean' },
-          allowNumber: { type: 'boolean' },
-          allowNullableObject: { type: 'boolean' },
-          allowNullableBoolean: { type: 'boolean' },
-          allowNullableString: { type: 'boolean' },
-          allowNullableNumber: { type: 'boolean' },
-          allowNullableEnum: { type: 'boolean' },
-          allowAny: { type: 'boolean' },
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      conditionErrorOther:
-        'Unexpected value in conditional. ' +
-        'A boolean expression is required.',
-      conditionErrorAny:
-        'Unexpected any value in conditional. ' +
-        'An explicit comparison or type cast is required.',
-      conditionErrorNullish:
-        'Unexpected nullish value in conditional. ' +
-        'The condition is always false.',
-      conditionErrorNullableBoolean:
-        'Unexpected nullable boolean value in conditional. ' +
-        'Please handle the nullish case explicitly.',
-      conditionErrorString:
-        'Unexpected string value in conditional. ' +
-        'An explicit empty string check is required.',
-      conditionErrorNullableString:
-        'Unexpected nullable string value in conditional. ' +
-        'Please handle the nullish/empty cases explicitly.',
-      conditionErrorNumber:
-        'Unexpected number value in conditional. ' +
-        'An explicit zero/NaN check is required.',
-      conditionErrorNullableNumber:
-        'Unexpected nullable number value in conditional. ' +
-        'Please handle the nullish/zero/NaN cases explicitly.',
-      conditionErrorObject:
-        'Unexpected object value in conditional. ' +
-        'The condition is always true.',
-      conditionErrorNullableObject:
-        'Unexpected nullable object value in conditional. ' +
-        'An explicit null check is required.',
-      conditionErrorNullableEnum:
-        'Unexpected nullable enum value in conditional. ' +
-        'Please handle the nullish/zero/NaN cases explicitly.',
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-
-      conditionFixDefaultFalse:
-        'Explicitly treat nullish value the same as false (`value ?? false`)',
-      conditionFixDefaultEmptyString:
-        'Explicitly treat nullish value the same as an empty string (`value ?? ""`)',
-      conditionFixDefaultZero:
-        'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
-      conditionFixCompareNullish:
-        'Change condition to check for null/undefined (`value != null`)',
-      conditionFixCastBoolean:
-        'Explicitly cast value to a boolean (`Boolean(value)`)',
-      conditionFixCompareTrue:
-        'Change condition to check if true (`value === true`)',
-      conditionFixCompareFalse:
-        'Change condition to check if false (`value === false`)',
-      conditionFixCompareStringLength:
-        "Change condition to check string's length (`value.length !== 0`)",
-      conditionFixCompareEmptyString:
-        'Change condition to check for empty string (`value !== ""`)',
-      conditionFixCompareZero:
-        'Change condition to check for 0 (`value !== 0`)',
-      conditionFixCompareNaN:
-        'Change condition to check for NaN (`!Number.isNaN(value)`)',
-    },
-  },
-  defaultOptions: [
-    {
-      allowString: true,
-      allowNumber: true,
-      allowNullableObject: true,
-      allowNullableBoolean: false,
-      allowNullableString: false,
-      allowNullableNumber: false,
-      allowNullableEnum: false,
-      allowAny: false,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-    },
-  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -172,8 +71,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          start: { line: 0, column: 0 },
-          end: { line: 0, column: 0 },
+          end: { column: 0, line: 0 },
+          start: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
@@ -182,14 +81,14 @@ export default createRule<Options, MessageId>({
     const traversedNodes = new Set<TSESTree.Node>();
 
     return {
+      CallExpression: traverseCallExpression,
       ConditionalExpression: traverseTestExpression,
       DoWhileStatement: traverseTestExpression,
       ForStatement: traverseTestExpression,
       IfStatement: traverseTestExpression,
-      WhileStatement: traverseTestExpression,
       'LogicalExpression[operator!="??"]': traverseLogicalExpression,
       'UnaryExpression[operator="!"]': traverseUnaryLogicalExpression,
-      CallExpression: traverseCallExpression,
+      WhileStatement: traverseTestExpression,
     };
 
     type TestExpression =
@@ -428,7 +327,7 @@ export default createRule<Options, MessageId>({
       // nullish
       if (is('nullish')) {
         // condition is always false
-        context.report({ node, messageId: 'conditionErrorNullish' });
+        context.report({ messageId: 'conditionErrorNullish', node });
         return;
       }
 
@@ -443,49 +342,49 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableBoolean)
             context.report({
-              node,
               messageId: 'conditionErrorNullableBoolean',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixDefaultFalse',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? false`,
                   }),
+                  messageId: 'conditionFixDefaultFalse',
                 },
                 {
-                  messageId: 'conditionFixCompareFalse',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} === false`,
                   }),
+                  messageId: 'conditionFixCompareFalse',
                 },
               ],
             });
           } else {
             // if (nullableBoolean)
             context.report({
-              node,
               messageId: 'conditionErrorNullableBoolean',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixDefaultFalse',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? false`,
                   }),
+                  messageId: 'conditionFixDefaultFalse',
                 },
                 {
-                  messageId: 'conditionFixCompareTrue',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} === true`,
                   }),
+                  messageId: 'conditionFixCompareTrue',
                 },
               ],
             });
@@ -508,67 +407,67 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!string)
             context.report({
-              node,
               messageId: 'conditionErrorString',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareStringLength',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code}.length === 0`,
                   }),
+                  messageId: 'conditionFixCompareStringLength',
                 },
                 {
-                  messageId: 'conditionFixCompareEmptyString',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} === ""`,
                   }),
+                  messageId: 'conditionFixCompareEmptyString',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (string)
             context.report({
-              node,
               messageId: 'conditionErrorString',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareStringLength',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code}.length > 0`,
                   }),
+                  messageId: 'conditionFixCompareStringLength',
                 },
                 {
-                  messageId: 'conditionFixCompareEmptyString',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} !== ""`,
                   }),
+                  messageId: 'conditionFixCompareEmptyString',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -583,66 +482,66 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableString)
             context.report({
-              node,
               messageId: 'conditionErrorNullableString',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
                 {
-                  messageId: 'conditionFixDefaultEmptyString',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? ""`,
                   }),
+                  messageId: 'conditionFixDefaultEmptyString',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (nullableString)
             context.report({
-              node,
               messageId: 'conditionErrorNullableString',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
                 {
-                  messageId: 'conditionFixDefaultEmptyString',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? ""`,
                   }),
+                  messageId: 'conditionFixDefaultEmptyString',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -658,93 +557,93 @@ export default createRule<Options, MessageId>({
             if (isLogicalNegationExpression(node.parent)) {
               // if (!array.length)
               context.report({
-                node,
-                messageId: 'conditionErrorNumber',
                 fix: getWrappingFixer({
-                  sourceCode: context.sourceCode,
-                  node: node.parent,
                   innerNode: node,
+                  node: node.parent,
+                  sourceCode: context.sourceCode,
                   wrap: code => `${code} === 0`,
                 }),
+                messageId: 'conditionErrorNumber',
+                node,
               });
             } else {
               // if (array.length)
               context.report({
-                node,
-                messageId: 'conditionErrorNumber',
                 fix: getWrappingFixer({
-                  sourceCode: context.sourceCode,
                   node,
+                  sourceCode: context.sourceCode,
                   wrap: code => `${code} > 0`,
                 }),
+                messageId: 'conditionErrorNumber',
+                node,
               });
             }
           } else if (isLogicalNegationExpression(node.parent)) {
             // if (!number)
             context.report({
-              node,
               messageId: 'conditionErrorNumber',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareZero',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     // TODO: we have to compare to 0n if the type is bigint
                     wrap: code => `${code} === 0`,
                   }),
+                  messageId: 'conditionFixCompareZero',
                 },
                 {
                   // TODO: don't suggest this for bigint because it can't be NaN
-                  messageId: 'conditionFixCompareNaN',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `Number.isNaN(${code})`,
                   }),
+                  messageId: 'conditionFixCompareNaN',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (number)
             context.report({
-              node,
               messageId: 'conditionErrorNumber',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareZero',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} !== 0`,
                   }),
+                  messageId: 'conditionFixCompareZero',
                 },
                 {
-                  messageId: 'conditionFixCompareNaN',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `!Number.isNaN(${code})`,
                   }),
+                  messageId: 'conditionFixCompareNaN',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -759,66 +658,66 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableNumber)
             context.report({
-              node,
               messageId: 'conditionErrorNullableNumber',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
                 {
-                  messageId: 'conditionFixDefaultZero',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? 0`,
                   }),
+                  messageId: 'conditionFixDefaultZero',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (nullableNumber)
             context.report({
-              node,
               messageId: 'conditionErrorNullableNumber',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
                 {
-                  messageId: 'conditionFixDefaultZero',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? 0`,
                   }),
+                  messageId: 'conditionFixDefaultZero',
                 },
                 {
-                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
+                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -830,7 +729,7 @@ export default createRule<Options, MessageId>({
       // object
       if (is('object')) {
         // condition is always true
-        context.report({ node, messageId: 'conditionErrorObject' });
+        context.report({ messageId: 'conditionErrorObject', node });
         return;
       }
 
@@ -840,33 +739,33 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableObject)
             context.report({
-              node,
               messageId: 'conditionErrorNullableObject',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
-                    node: node.parent,
                     innerNode: node,
+                    node: node.parent,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
               ],
             });
           } else {
             // if (nullableObject)
             context.report({
-              node,
               messageId: 'conditionErrorNullableObject',
+              node,
               suggest: [
                 {
-                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    sourceCode: context.sourceCode,
                     node,
+                    sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
+                  messageId: 'conditionFixCompareNullish',
                 },
               ],
             });
@@ -890,24 +789,24 @@ export default createRule<Options, MessageId>({
         if (!options.allowNullableEnum) {
           if (isLogicalNegationExpression(node.parent)) {
             context.report({
-              node,
-              messageId: 'conditionErrorNullableEnum',
               fix: getWrappingFixer({
-                sourceCode: context.sourceCode,
-                node: node.parent,
                 innerNode: node,
+                node: node.parent,
+                sourceCode: context.sourceCode,
                 wrap: code => `${code} == null`,
               }),
+              messageId: 'conditionErrorNullableEnum',
+              node,
             });
           } else {
             context.report({
-              node,
-              messageId: 'conditionErrorNullableEnum',
               fix: getWrappingFixer({
-                sourceCode: context.sourceCode,
                 node,
+                sourceCode: context.sourceCode,
                 wrap: code => `${code} != null`,
               }),
+              messageId: 'conditionErrorNullableEnum',
+              node,
             });
           }
         }
@@ -918,16 +817,16 @@ export default createRule<Options, MessageId>({
       if (is('any')) {
         if (!options.allowAny) {
           context.report({
-            node,
             messageId: 'conditionErrorAny',
+            node,
             suggest: [
               {
-                messageId: 'conditionFixCastBoolean',
                 fix: getWrappingFixer({
-                  sourceCode: context.sourceCode,
                   node,
+                  sourceCode: context.sourceCode,
                   wrap: code => `Boolean(${code})`,
                 }),
+                messageId: 'conditionFixCastBoolean',
               },
             ],
           });
@@ -936,7 +835,7 @@ export default createRule<Options, MessageId>({
       }
 
       // other
-      context.report({ node, messageId: 'conditionErrorOther' });
+      context.report({ messageId: 'conditionErrorOther', node });
     }
 
     /** The types we care about */
@@ -1062,6 +961,108 @@ export default createRule<Options, MessageId>({
       return variantTypes;
     }
   },
+  defaultOptions: [
+    {
+      allowAny: false,
+      allowNullableBoolean: false,
+      allowNullableEnum: false,
+      allowNullableNumber: false,
+      allowNullableObject: true,
+      allowNullableString: false,
+      allowNumber: true,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      allowString: true,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Disallow certain types in boolean expressions',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      conditionErrorAny:
+        'Unexpected any value in conditional. ' +
+        'An explicit comparison or type cast is required.',
+      conditionErrorNullableBoolean:
+        'Unexpected nullable boolean value in conditional. ' +
+        'Please handle the nullish case explicitly.',
+      conditionErrorNullableEnum:
+        'Unexpected nullable enum value in conditional. ' +
+        'Please handle the nullish/zero/NaN cases explicitly.',
+      conditionErrorNullableNumber:
+        'Unexpected nullable number value in conditional. ' +
+        'Please handle the nullish/zero/NaN cases explicitly.',
+      conditionErrorNullableObject:
+        'Unexpected nullable object value in conditional. ' +
+        'An explicit null check is required.',
+      conditionErrorNullableString:
+        'Unexpected nullable string value in conditional. ' +
+        'Please handle the nullish/empty cases explicitly.',
+      conditionErrorNullish:
+        'Unexpected nullish value in conditional. ' +
+        'The condition is always false.',
+      conditionErrorNumber:
+        'Unexpected number value in conditional. ' +
+        'An explicit zero/NaN check is required.',
+      conditionErrorObject:
+        'Unexpected object value in conditional. ' +
+        'The condition is always true.',
+      conditionErrorOther:
+        'Unexpected value in conditional. ' +
+        'A boolean expression is required.',
+      conditionErrorString:
+        'Unexpected string value in conditional. ' +
+        'An explicit empty string check is required.',
+      conditionFixCastBoolean:
+        'Explicitly cast value to a boolean (`Boolean(value)`)',
+
+      conditionFixCompareEmptyString:
+        'Change condition to check for empty string (`value !== ""`)',
+      conditionFixCompareFalse:
+        'Change condition to check if false (`value === false`)',
+      conditionFixCompareNaN:
+        'Change condition to check for NaN (`!Number.isNaN(value)`)',
+      conditionFixCompareNullish:
+        'Change condition to check for null/undefined (`value != null`)',
+      conditionFixCompareStringLength:
+        "Change condition to check string's length (`value.length !== 0`)",
+      conditionFixCompareTrue:
+        'Change condition to check if true (`value === true`)',
+      conditionFixCompareZero:
+        'Change condition to check for 0 (`value !== 0`)',
+      conditionFixDefaultEmptyString:
+        'Explicitly treat nullish value the same as an empty string (`value ?? ""`)',
+      conditionFixDefaultFalse:
+        'Explicitly treat nullish value the same as false (`value ?? false`)',
+      conditionFixDefaultZero:
+        'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowAny: { type: 'boolean' },
+          allowNullableBoolean: { type: 'boolean' },
+          allowNullableEnum: { type: 'boolean' },
+          allowNullableNumber: { type: 'boolean' },
+          allowNullableObject: { type: 'boolean' },
+          allowNullableString: { type: 'boolean' },
+          allowNumber: { type: 'boolean' },
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+          },
+          allowString: { type: 'boolean' },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'strict-boolean-expressions',
 });
 
 function isLogicalNegationExpression(
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index 1452d7de6cdb..abce22923154 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -14,10 +15,10 @@ import {
 } from '../util';
 
 interface SwitchMetadata {
-  readonly symbolName: string | undefined;
+  readonly containsNonLiteralType: boolean;
   readonly defaultCase: TSESTree.SwitchCase | undefined;
   readonly missingLiteralBranchTypes: ts.Type[];
-  readonly containsNonLiteralType: boolean;
+  readonly symbolName: string | undefined;
 }
 
 type Options = [
@@ -40,49 +41,11 @@ type Options = [
 ];
 
 type MessageIds =
-  | 'switchIsNotExhaustive'
+  | 'addMissingCases'
   | 'dangerousDefaultCase'
-  | 'addMissingCases';
+  | 'switchIsNotExhaustive';
 
 export default createRule<Options, MessageIds>({
-  name: 'switch-exhaustiveness-check',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require switch-case statements to be exhaustive',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowDefaultCaseForExhaustiveSwitch: {
-            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
-            type: 'boolean',
-          },
-          requireDefaultForNonUnion: {
-            description: `If 'true', require a 'default' clause for switches on non-union types.`,
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      switchIsNotExhaustive:
-        'Switch is not exhaustive. Cases not matched: {{missingBranches}}',
-      dangerousDefaultCase:
-        'The switch statement is exhaustive, so the default case is unnecessary.',
-      addMissingCases: 'Add branches for missing cases.',
-    },
-  },
-  defaultOptions: [
-    {
-      allowDefaultCaseForExhaustiveSwitch: true,
-      requireDefaultForNonUnion: false,
-    },
-  ],
   create(
     context,
     [{ allowDefaultCaseForExhaustiveSwitch, requireDefaultForNonUnion }],
@@ -141,10 +104,10 @@ export default createRule<Options, MessageIds>({
       }
 
       return {
-        symbolName,
-        missingLiteralBranchTypes,
-        defaultCase,
         containsNonLiteralType,
+        defaultCase,
+        missingLiteralBranchTypes,
+        symbolName,
       };
     }
 
@@ -152,7 +115,7 @@ export default createRule<Options, MessageIds>({
       node: TSESTree.SwitchStatement,
       switchMetadata: SwitchMetadata,
     ): void {
-      const { missingLiteralBranchTypes, symbolName, defaultCase } =
+      const { defaultCase, missingLiteralBranchTypes, symbolName } =
         switchMetadata;
 
       // We only trigger the rule if a `default` case does not exist, since that
@@ -160,8 +123,6 @@ export default createRule<Options, MessageIds>({
       // match the members of a union.
       if (missingLiteralBranchTypes.length > 0 && defaultCase === undefined) {
         context.report({
-          node: node.discriminant,
-          messageId: 'switchIsNotExhaustive',
           data: {
             missingBranches: missingLiteralBranchTypes
               .map(missingType =>
@@ -171,9 +132,10 @@ export default createRule<Options, MessageIds>({
               )
               .join(' | '),
           },
+          messageId: 'switchIsNotExhaustive',
+          node: node.discriminant,
           suggest: [
             {
-              messageId: 'addMissingCases',
               fix(fixer): TSESLint.RuleFix | null {
                 return fixSwitch(
                   fixer,
@@ -182,6 +144,7 @@ export default createRule<Options, MessageIds>({
                   symbolName?.toString(),
                 );
               },
+              messageId: 'addMissingCases',
             },
           ],
         });
@@ -275,7 +238,7 @@ export default createRule<Options, MessageIds>({
         return;
       }
 
-      const { missingLiteralBranchTypes, defaultCase, containsNonLiteralType } =
+      const { containsNonLiteralType, defaultCase, missingLiteralBranchTypes } =
         switchMetadata;
 
       if (
@@ -284,8 +247,8 @@ export default createRule<Options, MessageIds>({
         !containsNonLiteralType
       ) {
         context.report({
-          node: defaultCase,
           messageId: 'dangerousDefaultCase',
+          node: defaultCase,
         });
       }
     }
@@ -298,19 +261,19 @@ export default createRule<Options, MessageIds>({
         return;
       }
 
-      const { defaultCase, containsNonLiteralType } = switchMetadata;
+      const { containsNonLiteralType, defaultCase } = switchMetadata;
 
       if (containsNonLiteralType && defaultCase === undefined) {
         context.report({
-          node: node.discriminant,
-          messageId: 'switchIsNotExhaustive',
           data: { missingBranches: 'default' },
+          messageId: 'switchIsNotExhaustive',
+          node: node.discriminant,
           suggest: [
             {
-              messageId: 'addMissingCases',
               fix(fixer): TSESLint.RuleFix {
                 return fixSwitch(fixer, node, [null]);
               },
+              messageId: 'addMissingCases',
             },
           ],
         });
@@ -327,6 +290,44 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      allowDefaultCaseForExhaustiveSwitch: true,
+      requireDefaultForNonUnion: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Require switch-case statements to be exhaustive',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      addMissingCases: 'Add branches for missing cases.',
+      dangerousDefaultCase:
+        'The switch statement is exhaustive, so the default case is unnecessary.',
+      switchIsNotExhaustive:
+        'Switch is not exhaustive. Cases not matched: {{missingBranches}}',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowDefaultCaseForExhaustiveSwitch: {
+            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
+            type: 'boolean',
+          },
+          requireDefaultForNonUnion: {
+            description: `If 'true', require a 'default' clause for switches on non-union types.`,
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'switch-exhaustiveness-check',
 });
 
 function isTypeLiteralLikeType(type: ts.Type): boolean {
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index a45662c33d4c..371ce0f38545 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -13,46 +14,6 @@ type Options = [
 type MessageIds = 'tripleSlashReference';
 
 export default createRule<Options, MessageIds>({
-  name: 'triple-slash-reference',
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow certain triple slash directives in favor of ES6-style import declarations',
-      recommended: 'recommended',
-    },
-    messages: {
-      tripleSlashReference:
-        'Do not use a triple slash reference for {{module}}, use `import` style instead.',
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          lib: {
-            type: 'string',
-            enum: ['always', 'never'],
-          },
-          path: {
-            type: 'string',
-            enum: ['always', 'never'],
-          },
-          types: {
-            type: 'string',
-            enum: ['always', 'never', 'prefer-import'],
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      lib: 'always',
-      path: 'never',
-      types: 'prefer-import',
-    },
-  ],
   create(context, [{ lib, path, types }]) {
     let programNode: TSESTree.Node | undefined;
 
@@ -65,11 +26,11 @@ export default createRule<Options, MessageIds>({
       references.forEach(reference => {
         if (reference.importName === source.value) {
           context.report({
-            node: reference.comment,
-            messageId: 'tripleSlashReference',
             data: {
               module: reference.importName,
             },
+            messageId: 'tripleSlashReference',
+            node: reference.comment,
           });
         }
       });
@@ -80,15 +41,6 @@ export default createRule<Options, MessageIds>({
           hasMatchingReference(node.source);
         }
       },
-      TSImportEqualsDeclaration(node): void {
-        if (programNode) {
-          const reference = node.moduleReference;
-
-          if (reference.type === AST_NODE_TYPES.TSExternalModuleReference) {
-            hasMatchingReference(reference.expression as TSESTree.Literal);
-          }
-        }
-      },
       Program(node): void {
         if (lib === 'always' && path === 'always' && types === 'always') {
           return;
@@ -112,11 +64,11 @@ export default createRule<Options, MessageIds>({
               (referenceResult[1] === 'lib' && lib === 'never')
             ) {
               context.report({
-                node: comment,
-                messageId: 'tripleSlashReference',
                 data: {
                   module: referenceResult[2],
                 },
+                messageId: 'tripleSlashReference',
+                node: comment,
               });
               return;
             }
@@ -126,6 +78,55 @@ export default createRule<Options, MessageIds>({
           }
         });
       },
+      TSImportEqualsDeclaration(node): void {
+        if (programNode) {
+          const reference = node.moduleReference;
+
+          if (reference.type === AST_NODE_TYPES.TSExternalModuleReference) {
+            hasMatchingReference(reference.expression as TSESTree.Literal);
+          }
+        }
+      },
     };
   },
+  defaultOptions: [
+    {
+      lib: 'always',
+      path: 'never',
+      types: 'prefer-import',
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow certain triple slash directives in favor of ES6-style import declarations',
+      recommended: 'recommended',
+    },
+    messages: {
+      tripleSlashReference:
+        'Do not use a triple slash reference for {{module}}, use `import` style instead.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          lib: {
+            enum: ['always', 'never'],
+            type: 'string',
+          },
+          path: {
+            enum: ['always', 'never'],
+            type: 'string',
+          },
+          types: {
+            enum: ['always', 'never', 'prefer-import'],
+            type: 'string',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'triple-slash-reference',
 });
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index 187f4d620365..91e0259fb25c 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { createRule } from '../util';
@@ -19,45 +20,6 @@ type Options = { [k in OptionKeys]?: boolean };
 type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed';
 
 export default createRule<[Options], MessageIds>({
-  name: 'typedef',
-  meta: {
-    docs: {
-      description: 'Require type annotations in certain places',
-    },
-    messages: {
-      expectedTypedef: 'Expected a type annotation.',
-      expectedTypedefNamed: 'Expected {{name}} to have a type annotation.',
-    },
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
-          [OptionKeys.ArrowParameter]: { type: 'boolean' },
-          [OptionKeys.MemberVariableDeclaration]: { type: 'boolean' },
-          [OptionKeys.ObjectDestructuring]: { type: 'boolean' },
-          [OptionKeys.Parameter]: { type: 'boolean' },
-          [OptionKeys.PropertyDeclaration]: { type: 'boolean' },
-          [OptionKeys.VariableDeclaration]: { type: 'boolean' },
-          [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
-        },
-      },
-    ],
-    type: 'suggestion',
-  },
-  defaultOptions: [
-    {
-      [OptionKeys.ArrayDestructuring]: false,
-      [OptionKeys.ArrowParameter]: false,
-      [OptionKeys.MemberVariableDeclaration]: false,
-      [OptionKeys.ObjectDestructuring]: false,
-      [OptionKeys.Parameter]: false,
-      [OptionKeys.PropertyDeclaration]: false,
-      [OptionKeys.VariableDeclaration]: false,
-      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
-    },
-  ],
   create(
     context,
     [
@@ -75,9 +37,9 @@ export default createRule<[Options], MessageIds>({
   ) {
     function report(location: TSESTree.Node, name?: string): void {
       context.report({
-        node: location,
-        messageId: name ? 'expectedTypedefNamed' : 'expectedTypedef',
         data: { name },
+        messageId: name ? 'expectedTypedefNamed' : 'expectedTypedef',
+        node: location,
       });
     }
 
@@ -275,4 +237,43 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      [OptionKeys.ArrayDestructuring]: false,
+      [OptionKeys.ArrowParameter]: false,
+      [OptionKeys.MemberVariableDeclaration]: false,
+      [OptionKeys.ObjectDestructuring]: false,
+      [OptionKeys.Parameter]: false,
+      [OptionKeys.PropertyDeclaration]: false,
+      [OptionKeys.VariableDeclaration]: false,
+      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description: 'Require type annotations in certain places',
+    },
+    messages: {
+      expectedTypedef: 'Expected a type annotation.',
+      expectedTypedefNamed: 'Expected {{name}} to have a type annotation.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
+          [OptionKeys.ArrowParameter]: { type: 'boolean' },
+          [OptionKeys.MemberVariableDeclaration]: { type: 'boolean' },
+          [OptionKeys.ObjectDestructuring]: { type: 'boolean' },
+          [OptionKeys.Parameter]: { type: 'boolean' },
+          [OptionKeys.PropertyDeclaration]: { type: 'boolean' },
+          [OptionKeys.VariableDeclaration]: { type: 'boolean' },
+          [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'typedef',
 });
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 6e2c34d94b72..33b984972b62 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
@@ -103,38 +104,6 @@ const BASE_MESSAGE =
   'Avoid referencing unbound methods which may cause unintentional scoping of `this`.';
 
 export default createRule<Options, MessageIds>({
-  name: 'unbound-method',
-  meta: {
-    docs: {
-      description:
-        'Enforce unbound methods are called with their expected scope',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unbound: BASE_MESSAGE,
-      unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          ignoreStatic: {
-            description:
-              'Whether to skip checking whether `static` methods are correctly bound.',
-            type: 'boolean',
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    type: 'problem',
-  },
-  defaultOptions: [
-    {
-      ignoreStatic: false,
-    },
-  ],
   create(context, [{ ignoreStatic }]) {
     const services = getParserServices(context);
     const currentSourceFile = services.program.getSourceFile(context.filename);
@@ -272,6 +241,38 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
+  defaultOptions: [
+    {
+      ignoreStatic: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Enforce unbound methods are called with their expected scope',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unbound: BASE_MESSAGE,
+      unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreStatic: {
+            description:
+              'Whether to skip checking whether `static` methods are correctly bound.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'problem',
+  },
+  name: 'unbound-method',
 });
 
 function isNodeInsideTypeDeclaration(node: TSESTree.Node): boolean {
@@ -337,9 +338,9 @@ function checkIfMethod(
 
 function checkMethod(
   valueDeclaration:
+    | ts.FunctionExpression
     | ts.MethodDeclaration
-    | ts.MethodSignature
-    | ts.FunctionExpression,
+    | ts.MethodSignature,
   ignoreStatic: boolean,
 ): CheckMethodResult {
   const firstParam = valueDeclaration.parameters.at(0);
@@ -389,10 +390,10 @@ function isSafeUse(node: TSESTree.Node): boolean {
       // the first case is safe for obvious
       // reasons. The second one is also fine
       // since we're returning something falsy
-      return ['typeof', '!', 'void', 'delete'].includes(parent.operator);
+      return ['!', 'delete', 'typeof', 'void'].includes(parent.operator);
 
     case AST_NODE_TYPES.BinaryExpression:
-      return ['instanceof', '==', '!=', '===', '!=='].includes(parent.operator);
+      return ['!=', '!==', '==', '===', 'instanceof'].includes(parent.operator);
 
     case AST_NODE_TYPES.AssignmentExpression:
       return (
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 9a6705576ed4..80f983a727d5 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -1,18 +1,20 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type { Equal } from '../util';
+
 import { arraysAreEqual, createRule, nullThrows } from '../util';
 
 interface Failure {
-  unify: Unify;
   only2: boolean;
+  unify: Unify;
 }
 
 type Unify =
   | {
-      kind: 'extra-parameter';
       extraParameter: TSESTree.Parameter;
+      kind: 'extra-parameter';
       otherSignature: SignatureDefinition;
     }
   | {
@@ -63,41 +65,6 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  name: 'unified-signatures',
-  meta: {
-    docs: {
-      description:
-        'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
-      // too opinionated to be recommended
-      recommended: 'strict',
-    },
-    type: 'suggestion',
-    messages: {
-      omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
-      omittingSingleParameter:
-        '{{failureStringStart}} with an optional parameter.',
-      singleParameterDifference:
-        '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreDifferentlyNamedParameters: {
-            description:
-              'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-  },
-  defaultOptions: [
-    {
-      ignoreDifferentlyNamedParameters: false,
-    },
-  ],
   create(context, [{ ignoreDifferentlyNamedParameters }]) {
     //----------------------------------------------------------------------
     // Helpers
@@ -114,7 +81,7 @@ export default createRule<Options, MessageIds>({
 
     function addFailures(failures: Failure[]): void {
       for (const failure of failures) {
-        const { unify, only2 } = failure;
+        const { only2, unify } = failure;
         switch (unify.kind) {
           case 'single-parameter-difference': {
             const { p0, p1 } = unify;
@@ -128,8 +95,6 @@ export default createRule<Options, MessageIds>({
               : p1.typeAnnotation;
 
             context.report({
-              loc: p1.loc,
-              messageId: 'singleParameterDifference',
               data: {
                 failureStringStart: failureStringStart(lineOfOtherOverload),
                 type1: context.sourceCode.getText(
@@ -139,6 +104,8 @@ export default createRule<Options, MessageIds>({
                   typeAnnotation1?.typeAnnotation,
                 ),
               },
+              loc: p1.loc,
+              messageId: 'singleParameterDifference',
               node: p1,
             });
             break;
@@ -150,14 +117,14 @@ export default createRule<Options, MessageIds>({
               : otherSignature.loc.start.line;
 
             context.report({
+              data: {
+                failureStringStart: failureStringStart(lineOfOtherOverload),
+              },
               loc: extraParameter.loc,
               messageId:
                 extraParameter.type === AST_NODE_TYPES.RestElement
                   ? 'omittingRestParameter'
                   : 'omittingSingleParameter',
-              data: {
-                failureStringStart: failureStringStart(lineOfOtherOverload),
-              },
               node: extraParameter,
             });
           }
@@ -182,7 +149,7 @@ export default createRule<Options, MessageIds>({
             isTypeParameter,
           );
           if (unify !== undefined) {
-            result.push({ unify, only2: overloads.length === 2 });
+            result.push({ only2: overloads.length === 2, unify });
           }
         });
       }
@@ -546,43 +513,78 @@ export default createRule<Options, MessageIds>({
     //----------------------------------------------------------------------
 
     return {
-      Program: createScope,
-      TSModuleBlock: createScope,
-      TSInterfaceDeclaration(node): void {
+      ClassDeclaration(node): void {
         createScope(node.body, node.typeParameters);
       },
-      ClassDeclaration(node): void {
+      Program: createScope,
+      TSInterfaceDeclaration(node): void {
         createScope(node.body, node.typeParameters);
       },
+      TSModuleBlock: createScope,
       TSTypeLiteral: createScope,
 
       // collect overloads
-      TSDeclareFunction(node): void {
-        const exportingNode = getExportingNode(node);
-        addOverload(node, node.id?.name ?? exportingNode?.type, exportingNode);
-      },
-      TSCallSignatureDeclaration: addOverload,
-      TSConstructSignatureDeclaration: addOverload,
-      TSMethodSignature: addOverload,
-      TSAbstractMethodDefinition(node): void {
+      MethodDefinition(node): void {
         if (!node.value.body) {
           addOverload(node);
         }
       },
-      MethodDefinition(node): void {
+      TSAbstractMethodDefinition(node): void {
         if (!node.value.body) {
           addOverload(node);
         }
       },
+      TSCallSignatureDeclaration: addOverload,
+      TSConstructSignatureDeclaration: addOverload,
+      TSDeclareFunction(node): void {
+        const exportingNode = getExportingNode(node);
+        addOverload(node, node.id?.name ?? exportingNode?.type, exportingNode);
+      },
+      TSMethodSignature: addOverload,
 
       // validate scopes
+      'ClassDeclaration:exit': checkScope,
       'Program:exit': checkScope,
-      'TSModuleBlock:exit': checkScope,
       'TSInterfaceDeclaration:exit': checkScope,
-      'ClassDeclaration:exit': checkScope,
+      'TSModuleBlock:exit': checkScope,
       'TSTypeLiteral:exit': checkScope,
     };
   },
+  defaultOptions: [
+    {
+      ignoreDifferentlyNamedParameters: false,
+    },
+  ],
+  meta: {
+    docs: {
+      description:
+        'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
+      // too opinionated to be recommended
+      recommended: 'strict',
+    },
+    messages: {
+      omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
+      omittingSingleParameter:
+        '{{failureStringStart}} with an optional parameter.',
+      singleParameterDifference:
+        '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreDifferentlyNamedParameters: {
+            description:
+              'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+  name: 'unified-signatures',
 });
 
 function getExportingNode(
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index 0c9cf63adf2b..a593693d2210 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -1,10 +1,11 @@
 import type { Scope } from '@typescript-eslint/scope-manager';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { ReportDescriptor } from '@typescript-eslint/utils/ts-eslint';
-import * as tsutils from 'ts-api-utils';
 import type * as ts from 'typescript';
 
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as tsutils from 'ts-api-utils';
+
 import {
   createRule,
   getParserServices,
@@ -15,13 +16,13 @@ import {
 } from '../util';
 
 type MessageIds =
+  | 'addUnknownRestTypeAnnotationSuggestion'
+  | 'addUnknownTypeAnnotationSuggestion'
   | 'useUnknown'
   | 'useUnknownArrayDestructuringPattern'
   | 'useUnknownObjectDestructuringPattern'
-  | 'addUnknownTypeAnnotationSuggestion'
-  | 'addUnknownRestTypeAnnotationSuggestion'
-  | 'wrongTypeAnnotationSuggestion'
-  | 'wrongRestTypeAnnotationSuggestion';
+  | 'wrongRestTypeAnnotationSuggestion'
+  | 'wrongTypeAnnotationSuggestion';
 
 const useUnknownMessageBase =
   'Prefer the safe `: unknown` for a `{{method}}`{{append}} callback variable.';
@@ -40,39 +41,8 @@ const getStaticMemberAccessKey = (
   computed ? getStaticValue(property, scope) : { value: property.name };
 
 export default createRule<[], MessageIds>({
-  name: 'use-unknown-in-catch-callback-variable',
-  meta: {
-    docs: {
-      description:
-        'Enforce typing arguments in Promise rejection callbacks as `unknown`',
-      requiresTypeChecking: true,
-      recommended: 'strict',
-    },
-    type: 'suggestion',
-    messages: {
-      useUnknown: useUnknownMessageBase,
-      useUnknownArrayDestructuringPattern: `${useUnknownMessageBase} The thrown error may not be iterable.`,
-      useUnknownObjectDestructuringPattern: `${
-        useUnknownMessageBase
-      } The thrown error may be nullable, or may not have the expected shape.`,
-      addUnknownTypeAnnotationSuggestion:
-        'Add an explicit `: unknown` type annotation to the rejection callback variable.',
-      addUnknownRestTypeAnnotationSuggestion:
-        'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',
-      wrongTypeAnnotationSuggestion:
-        'Change existing type annotation to `: unknown`.',
-      wrongRestTypeAnnotationSuggestion:
-        'Change existing type annotation to `: [unknown]`.',
-    },
-    fixable: 'code',
-    schema: [],
-    hasSuggestions: true,
-  },
-
-  defaultOptions: [],
-
   create(context) {
-    const { program, esTreeNodeToTSNodeMap } = getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program } = getParserServices(context);
     const checker = program.getTypeChecker();
 
     function isFlaggableHandlerType(type: ts.Type): boolean {
@@ -128,7 +98,7 @@ export default createRule<[], MessageIds>({
      */
     function refineReportIfPossible(
       argument: TSESTree.Expression,
-    ): undefined | Partial<ReportDescriptor<MessageIds>> {
+    ): Partial<ReportDescriptor<MessageIds>> | undefined {
       // Only know how to be helpful if a function literal has been provided.
       if (
         !(
@@ -163,7 +133,6 @@ export default createRule<[], MessageIds>({
               node: catchVariableOuter,
               suggest: [
                 {
-                  messageId: 'addUnknownTypeAnnotationSuggestion',
                   fix: (fixer: TSESLint.RuleFixer): TSESLint.RuleFix[] => {
                     if (
                       argument.type ===
@@ -180,6 +149,7 @@ export default createRule<[], MessageIds>({
                       fixer.insertTextAfter(catchVariableInner, ': unknown'),
                     ];
                   },
+                  messageId: 'addUnknownTypeAnnotationSuggestion',
                 },
               ],
             };
@@ -189,23 +159,23 @@ export default createRule<[], MessageIds>({
             node: catchVariableOuter,
             suggest: [
               {
-                messageId: 'wrongTypeAnnotationSuggestion',
                 fix: (fixer: TSESLint.RuleFixer): TSESLint.RuleFix =>
                   fixer.replaceText(catchVariableTypeAnnotation, ': unknown'),
+                messageId: 'wrongTypeAnnotationSuggestion',
               },
             ],
           };
         }
         case AST_NODE_TYPES.ArrayPattern: {
           return {
-            node: catchVariableOuter,
             messageId: 'useUnknownArrayDestructuringPattern',
+            node: catchVariableOuter,
           };
         }
         case AST_NODE_TYPES.ObjectPattern: {
           return {
-            node: catchVariableOuter,
             messageId: 'useUnknownObjectDestructuringPattern',
+            node: catchVariableOuter,
           };
         }
         case AST_NODE_TYPES.RestElement: {
@@ -215,9 +185,9 @@ export default createRule<[], MessageIds>({
               node: catchVariableOuter,
               suggest: [
                 {
-                  messageId: 'addUnknownRestTypeAnnotationSuggestion',
                   fix: (fixer): TSESLint.RuleFix =>
                     fixer.insertTextAfter(catchVariableInner, ': [unknown]'),
+                  messageId: 'addUnknownRestTypeAnnotationSuggestion',
                 },
               ],
             };
@@ -226,9 +196,9 @@ export default createRule<[], MessageIds>({
             node: catchVariableOuter,
             suggest: [
               {
-                messageId: 'wrongRestTypeAnnotationSuggestion',
                 fix: (fixer): TSESLint.RuleFix =>
                   fixer.replaceText(catchVariableTypeAnnotation, ': [unknown]'),
+                messageId: 'wrongRestTypeAnnotationSuggestion',
               },
             ],
           };
@@ -252,12 +222,12 @@ export default createRule<[], MessageIds>({
 
         const promiseMethodInfo = (
           [
-            { method: 'catch', append: '', argIndexToCheck: 0 },
-            { method: 'then', append: ' rejection', argIndexToCheck: 1 },
+            { append: '', argIndexToCheck: 0, method: 'catch' },
+            { append: ' rejection', argIndexToCheck: 1, method: 'then' },
           ] satisfies {
-            method: string;
             append: string;
             argIndexToCheck: number;
+            method: string;
           }[]
         ).find(({ method }) => staticMemberAccessKey.value === method);
         if (!promiseMethodInfo) {
@@ -299,13 +269,44 @@ export default createRule<[], MessageIds>({
           // to determine exactly where, and whether we can fix it.
           const overrides = refineReportIfPossible(node);
           context.report({
-            node,
-            messageId: 'useUnknown',
             data,
+            messageId: 'useUnknown',
+            node,
             ...overrides,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+
+  meta: {
+    docs: {
+      description:
+        'Enforce typing arguments in Promise rejection callbacks as `unknown`',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      addUnknownRestTypeAnnotationSuggestion:
+        'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',
+      addUnknownTypeAnnotationSuggestion:
+        'Add an explicit `: unknown` type annotation to the rejection callback variable.',
+      useUnknown: useUnknownMessageBase,
+      useUnknownArrayDestructuringPattern: `${useUnknownMessageBase} The thrown error may not be iterable.`,
+      useUnknownObjectDestructuringPattern: `${
+        useUnknownMessageBase
+      } The thrown error may be nullable, or may not have the expected shape.`,
+      wrongRestTypeAnnotationSuggestion:
+        'Change existing type annotation to `: [unknown]`.',
+      wrongTypeAnnotationSuggestion:
+        'Change existing type annotation to `: unknown`.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'use-unknown-in-catch-callback-variable',
 });
diff --git a/packages/eslint-plugin/src/util/astUtils.ts b/packages/eslint-plugin/src/util/astUtils.ts
index daa69bc85831..c2450ae30130 100644
--- a/packages/eslint-plugin/src/util/astUtils.ts
+++ b/packages/eslint-plugin/src/util/astUtils.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import * as ts from 'typescript';
 
 import { escapeRegExp } from './escapeRegExp';
@@ -37,11 +38,11 @@ export function getNameLocationInGlobalDirectiveComment(
     comment.range[0] + '/*'.length + (match ? match.index + 1 : 0),
   );
   const end = {
-    line: start.line,
     column: start.column + (match ? name.length : 1),
+    line: start.line,
   };
 
-  return { start, end };
+  return { end, start };
 }
 
 // Copied from typescript https://github.com/microsoft/TypeScript/blob/42b0e3c4630c129ca39ce0df9fff5f0d1b4dd348/src/compiler/utilities.ts#L1335
diff --git a/packages/eslint-plugin/src/util/collectUnusedVariables.ts b/packages/eslint-plugin/src/util/collectUnusedVariables.ts
index f5602f52e2e7..074a986a00a3 100644
--- a/packages/eslint-plugin/src/util/collectUnusedVariables.ts
+++ b/packages/eslint-plugin/src/util/collectUnusedVariables.ts
@@ -2,12 +2,13 @@ import type {
   ScopeManager,
   ScopeVariable,
 } from '@typescript-eslint/scope-manager';
+import type { TSESTree } from '@typescript-eslint/utils';
+
 import {
   ImplicitLibVariable,
   ScopeType,
   Visitor,
 } from '@typescript-eslint/scope-manager';
-import type { TSESTree } from '@typescript-eslint/utils';
 import {
   AST_NODE_TYPES,
   ASTUtils,
@@ -40,6 +41,41 @@ class UnusedVarsVisitor extends Visitor {
     VariableAnalysis
   >();
 
+  protected ClassDeclaration = this.visitClass;
+
+  protected ClassExpression = this.visitClass;
+
+  protected ForInStatement = this.visitForInForOf;
+
+  protected ForOfStatement = this.visitForInForOf;
+
+  //#region HELPERS
+
+  protected FunctionDeclaration = this.visitFunction;
+
+  protected FunctionExpression = this.visitFunction;
+  protected MethodDefinition = this.visitSetter;
+  protected Property = this.visitSetter;
+
+  protected TSCallSignatureDeclaration = this.visitFunctionTypeSignature;
+
+  protected TSConstructorType = this.visitFunctionTypeSignature;
+
+  protected TSConstructSignatureDeclaration = this.visitFunctionTypeSignature;
+
+  protected TSDeclareFunction = this.visitFunctionTypeSignature;
+
+  protected TSEmptyBodyFunctionExpression = this.visitFunctionTypeSignature;
+
+  //#endregion HELPERS
+
+  //#region VISITORS
+  // NOTE - This is a simple visitor - meaning it does not support selectors
+
+  protected TSFunctionType = this.visitFunctionTypeSignature;
+
+  protected TSMethodSignature = this.visitFunctionTypeSignature;
+
   readonly #scopeManager: TSESLint.Scope.ScopeManager;
 
   private constructor(scopeManager: ScopeManager) {
@@ -69,6 +105,60 @@ class UnusedVarsVisitor extends Visitor {
     return unusedVars;
   }
 
+  protected Identifier(node: TSESTree.Identifier): void {
+    const scope = this.getScope(node);
+    if (
+      scope.type === TSESLint.Scope.ScopeType.function &&
+      node.name === 'this'
+    ) {
+      // this parameters should always be considered used as they're pseudo-parameters
+      if ('params' in scope.block && scope.block.params.includes(node)) {
+        this.markVariableAsUsed(node);
+      }
+    }
+  }
+
+  protected TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
+    // enum members create variables because they can be referenced within the enum,
+    // but they obviously aren't unused variables for the purposes of this rule.
+    const scope = this.getScope(node);
+    for (const variable of scope.variables) {
+      this.markVariableAsUsed(variable);
+    }
+  }
+
+  protected TSMappedType(node: TSESTree.TSMappedType): void {
+    // mapped types create a variable for their type name, but it's not necessary to reference it,
+    // so we shouldn't consider it as unused for the purpose of this rule.
+    this.markVariableAsUsed(node.key);
+  }
+
+  protected TSModuleDeclaration(node: TSESTree.TSModuleDeclaration): void {
+    // -- global augmentation can be in any file, and they do not need exports
+    if (node.kind === 'global') {
+      this.markVariableAsUsed('global', node.parent);
+    }
+  }
+
+  protected TSParameterProperty(node: TSESTree.TSParameterProperty): void {
+    let identifier: TSESTree.Identifier | null = null;
+    switch (node.parameter.type) {
+      case AST_NODE_TYPES.AssignmentPattern:
+        if (node.parameter.left.type === AST_NODE_TYPES.Identifier) {
+          identifier = node.parameter.left;
+        }
+        break;
+
+      case AST_NODE_TYPES.Identifier:
+        identifier = node.parameter;
+        break;
+    }
+
+    if (identifier) {
+      this.markVariableAsUsed(identifier);
+    }
+  }
+
   private collectUnusedVariables(
     scope: TSESLint.Scope.Scope,
     variables: MutableVariableAnalysis = {
@@ -116,8 +206,6 @@ class UnusedVarsVisitor extends Visitor {
     return variables;
   }
 
-  //#region HELPERS
-
   private getScope(currentNode: TSESTree.Node): TSESLint.Scope.Scope {
     // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
     const inner = currentNode.type !== AST_NODE_TYPES.Program;
@@ -142,7 +230,9 @@ class UnusedVarsVisitor extends Visitor {
   private markVariableAsUsed(
     variableOrIdentifier: ScopeVariable | TSESTree.Identifier,
   ): void;
+
   private markVariableAsUsed(name: string, parent: TSESTree.Node): void;
+
   private markVariableAsUsed(
     variableOrIdentifierOrName: ScopeVariable | TSESTree.Identifier | string,
     parent?: TSESTree.Node,
@@ -194,49 +284,6 @@ class UnusedVarsVisitor extends Visitor {
     }
   }
 
-  private visitFunction(
-    node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression,
-  ): void {
-    const scope = this.getScope(node);
-    // skip implicit "arguments" variable
-    const variable = scope.set.get('arguments');
-    if (variable?.defs.length === 0) {
-      this.markVariableAsUsed(variable);
-    }
-  }
-
-  private visitFunctionTypeSignature(
-    node:
-      | TSESTree.TSCallSignatureDeclaration
-      | TSESTree.TSConstructorType
-      | TSESTree.TSConstructSignatureDeclaration
-      | TSESTree.TSDeclareFunction
-      | TSESTree.TSEmptyBodyFunctionExpression
-      | TSESTree.TSFunctionType
-      | TSESTree.TSMethodSignature,
-  ): void {
-    // function type signature params create variables because they can be referenced within the signature,
-    // but they obviously aren't unused variables for the purposes of this rule.
-    for (const param of node.params) {
-      this.visitPattern(param, name => {
-        this.markVariableAsUsed(name);
-      });
-    }
-  }
-
-  private visitSetter(
-    node: TSESTree.MethodDefinition | TSESTree.Property,
-  ): void {
-    if (node.kind === 'set') {
-      // ignore setter parameters because they're syntactically required to exist
-      for (const param of (node.value as TSESTree.FunctionLike).params) {
-        this.visitPattern(param, id => {
-          this.markVariableAsUsed(id);
-        });
-      }
-    }
-  }
-
   private visitForInForOf(
     node: TSESTree.ForInStatement | TSESTree.ForOfStatement,
   ): void {
@@ -288,92 +335,46 @@ class UnusedVarsVisitor extends Visitor {
     this.markVariableAsUsed(idOrVariable);
   }
 
-  //#endregion HELPERS
-
-  //#region VISITORS
-  // NOTE - This is a simple visitor - meaning it does not support selectors
-
-  protected ClassDeclaration = this.visitClass;
-
-  protected ClassExpression = this.visitClass;
-
-  protected FunctionDeclaration = this.visitFunction;
-
-  protected FunctionExpression = this.visitFunction;
-
-  protected ForInStatement = this.visitForInForOf;
-
-  protected ForOfStatement = this.visitForInForOf;
-
-  protected Identifier(node: TSESTree.Identifier): void {
-    const scope = this.getScope(node);
-    if (
-      scope.type === TSESLint.Scope.ScopeType.function &&
-      node.name === 'this'
-    ) {
-      // this parameters should always be considered used as they're pseudo-parameters
-      if ('params' in scope.block && scope.block.params.includes(node)) {
-        this.markVariableAsUsed(node);
-      }
-    }
-  }
-
-  protected MethodDefinition = this.visitSetter;
-
-  protected Property = this.visitSetter;
-
-  protected TSCallSignatureDeclaration = this.visitFunctionTypeSignature;
-
-  protected TSConstructorType = this.visitFunctionTypeSignature;
-
-  protected TSConstructSignatureDeclaration = this.visitFunctionTypeSignature;
-
-  protected TSDeclareFunction = this.visitFunctionTypeSignature;
-
-  protected TSEmptyBodyFunctionExpression = this.visitFunctionTypeSignature;
-
-  protected TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
-    // enum members create variables because they can be referenced within the enum,
-    // but they obviously aren't unused variables for the purposes of this rule.
+  private visitFunction(
+    node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression,
+  ): void {
     const scope = this.getScope(node);
-    for (const variable of scope.variables) {
+    // skip implicit "arguments" variable
+    const variable = scope.set.get('arguments');
+    if (variable?.defs.length === 0) {
       this.markVariableAsUsed(variable);
     }
   }
 
-  protected TSFunctionType = this.visitFunctionTypeSignature;
-
-  protected TSMappedType(node: TSESTree.TSMappedType): void {
-    // mapped types create a variable for their type name, but it's not necessary to reference it,
-    // so we shouldn't consider it as unused for the purpose of this rule.
-    this.markVariableAsUsed(node.key);
-  }
-
-  protected TSMethodSignature = this.visitFunctionTypeSignature;
-
-  protected TSModuleDeclaration(node: TSESTree.TSModuleDeclaration): void {
-    // -- global augmentation can be in any file, and they do not need exports
-    if (node.kind === 'global') {
-      this.markVariableAsUsed('global', node.parent);
+  private visitFunctionTypeSignature(
+    node:
+      | TSESTree.TSCallSignatureDeclaration
+      | TSESTree.TSConstructorType
+      | TSESTree.TSConstructSignatureDeclaration
+      | TSESTree.TSDeclareFunction
+      | TSESTree.TSEmptyBodyFunctionExpression
+      | TSESTree.TSFunctionType
+      | TSESTree.TSMethodSignature,
+  ): void {
+    // function type signature params create variables because they can be referenced within the signature,
+    // but they obviously aren't unused variables for the purposes of this rule.
+    for (const param of node.params) {
+      this.visitPattern(param, name => {
+        this.markVariableAsUsed(name);
+      });
     }
   }
 
-  protected TSParameterProperty(node: TSESTree.TSParameterProperty): void {
-    let identifier: TSESTree.Identifier | null = null;
-    switch (node.parameter.type) {
-      case AST_NODE_TYPES.AssignmentPattern:
-        if (node.parameter.left.type === AST_NODE_TYPES.Identifier) {
-          identifier = node.parameter.left;
-        }
-        break;
-
-      case AST_NODE_TYPES.Identifier:
-        identifier = node.parameter;
-        break;
-    }
-
-    if (identifier) {
-      this.markVariableAsUsed(identifier);
+  private visitSetter(
+    node: TSESTree.MethodDefinition | TSESTree.Property,
+  ): void {
+    if (node.kind === 'set') {
+      // ignore setter parameters because they're syntactically required to exist
+      for (const param of (node.value as TSESTree.FunctionLike).params) {
+        this.visitPattern(param, id => {
+          this.markVariableAsUsed(id);
+        });
+      }
     }
   }
 
diff --git a/packages/eslint-plugin/src/util/explicitReturnTypeUtils.ts b/packages/eslint-plugin/src/util/explicitReturnTypeUtils.ts
index f65273a502ef..4adbe38132c2 100644
--- a/packages/eslint-plugin/src/util/explicitReturnTypeUtils.ts
+++ b/packages/eslint-plugin/src/util/explicitReturnTypeUtils.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import {
   AST_NODE_TYPES,
   ASTUtils,
@@ -199,10 +200,10 @@ function returnsConstAssertionDirectly(
 }
 
 interface Options {
+  allowDirectConstAssertionInArrowFunctions?: boolean;
   allowExpressions?: boolean;
-  allowTypedFunctionExpressions?: boolean;
   allowHigherOrderFunctions?: boolean;
-  allowDirectConstAssertionInArrowFunctions?: boolean;
+  allowTypedFunctionExpressions?: boolean;
 }
 
 /**
@@ -362,6 +363,7 @@ function ancestorHasReturnType(node: FunctionNode): boolean {
 }
 
 export {
+  ancestorHasReturnType,
   checkFunctionExpressionReturnType,
   checkFunctionReturnType,
   doesImmediatelyReturnFunctionExpression,
@@ -369,5 +371,4 @@ export {
   FunctionNode,
   isTypedFunctionExpression,
   isValidFunctionExpressionReturnType,
-  ancestorHasReturnType,
 };
diff --git a/packages/eslint-plugin/src/util/getESLintCoreRule.ts b/packages/eslint-plugin/src/util/getESLintCoreRule.ts
index 59b22c7292fd..97bc8620b01d 100644
--- a/packages/eslint-plugin/src/util/getESLintCoreRule.ts
+++ b/packages/eslint-plugin/src/util/getESLintCoreRule.ts
@@ -16,11 +16,11 @@ interface RuleMap {
   'no-loop-func': typeof import('eslint/lib/rules/no-loop-func');
   'no-loss-of-precision': typeof import('eslint/lib/rules/no-loss-of-precision');
   'no-magic-numbers': typeof import('eslint/lib/rules/no-magic-numbers');
+  'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals');
   'no-restricted-imports': typeof import('eslint/lib/rules/no-restricted-imports');
   'no-undef': typeof import('eslint/lib/rules/no-undef');
   'no-unused-expressions': typeof import('eslint/lib/rules/no-unused-expressions');
   'no-useless-constructor': typeof import('eslint/lib/rules/no-useless-constructor');
-  'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals');
   'prefer-const': typeof import('eslint/lib/rules/prefer-const');
   'prefer-destructuring': typeof import('eslint/lib/rules/prefer-destructuring');
   strict: typeof import('eslint/lib/rules/strict');
diff --git a/packages/eslint-plugin/src/util/getFixOrSuggest.ts b/packages/eslint-plugin/src/util/getFixOrSuggest.ts
index 9e67075aa126..50ad7d2779a1 100644
--- a/packages/eslint-plugin/src/util/getFixOrSuggest.ts
+++ b/packages/eslint-plugin/src/util/getFixOrSuggest.ts
@@ -1,11 +1,11 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 
 export function getFixOrSuggest<MessageId extends string>({
-  useFix,
   suggestion,
+  useFix,
 }: {
-  useFix: boolean;
   suggestion: TSESLint.SuggestionReportDescriptor<MessageId>;
+  useFix: boolean;
 }):
   | { fix: TSESLint.ReportFixFunction }
   | { suggest: TSESLint.SuggestionReportDescriptor<MessageId>[] } {
diff --git a/packages/eslint-plugin/src/util/getForStatementHeadLoc.ts b/packages/eslint-plugin/src/util/getForStatementHeadLoc.ts
index 8a7711fbe0b6..5a0a8fbc53a9 100644
--- a/packages/eslint-plugin/src/util/getForStatementHeadLoc.ts
+++ b/packages/eslint-plugin/src/util/getForStatementHeadLoc.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { nullThrows } from '@typescript-eslint/utils/eslint-utils';
 
 /**
@@ -28,7 +29,7 @@ export function getForStatementHeadLoc(
     'for statement must have a closing parenthesis.',
   );
   return {
-    start: structuredClone(node.loc.start),
     end: structuredClone(closingParens.loc.end),
+    start: structuredClone(node.loc.start),
   };
 }
diff --git a/packages/eslint-plugin/src/util/getFunctionHeadLoc.ts b/packages/eslint-plugin/src/util/getFunctionHeadLoc.ts
index 56227d7ed11d..49ab2b742dd9 100644
--- a/packages/eslint-plugin/src/util/getFunctionHeadLoc.ts
+++ b/packages/eslint-plugin/src/util/getFunctionHeadLoc.ts
@@ -1,6 +1,7 @@
 // adapted from https://github.com/eslint/eslint/blob/5bdaae205c3a0089ea338b382df59e21d5b06436/lib/rules/utils/ast-utils.js#L1668-L1787
 
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 
 import { isArrowToken, isOpeningParenToken } from './astUtils';
@@ -197,7 +198,7 @@ export function getFunctionHeadLoc(
   }
 
   return {
-    start: { ...start },
     end: { ...end },
+    start: { ...start },
   };
 }
diff --git a/packages/eslint-plugin/src/util/getMemberHeadLoc.ts b/packages/eslint-plugin/src/util/getMemberHeadLoc.ts
index 19401230e235..d28058d45691 100644
--- a/packages/eslint-plugin/src/util/getMemberHeadLoc.ts
+++ b/packages/eslint-plugin/src/util/getMemberHeadLoc.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import {
   nullThrows,
   NullThrowsReasons,
@@ -30,8 +31,8 @@ export function getMemberHeadLoc(
   sourceCode: Readonly<TSESLint.SourceCode>,
   node:
     | TSESTree.MethodDefinition
-    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.PropertyDefinition
+    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.TSAbstractPropertyDefinition,
 ): TSESTree.SourceLocation {
   let start: TSESTree.Position;
@@ -60,8 +61,8 @@ export function getMemberHeadLoc(
   }
 
   return {
-    start: structuredClone(start),
     end: structuredClone(end),
+    start: structuredClone(start),
   };
 }
 
@@ -102,7 +103,7 @@ export function getParameterPropertyHeadLoc(
   );
 
   return {
-    start,
     end,
+    start,
   };
 }
diff --git a/packages/eslint-plugin/src/util/getOperatorPrecedence.ts b/packages/eslint-plugin/src/util/getOperatorPrecedence.ts
index 8aac3d6fbd2d..950708015d89 100644
--- a/packages/eslint-plugin/src/util/getOperatorPrecedence.ts
+++ b/packages/eslint-plugin/src/util/getOperatorPrecedence.ts
@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/prefer-literal-enum-member -- the enums come from TS so to make merging upstream easier we purposely avoid adding literal values. */
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { SyntaxKind } from 'typescript';
 
@@ -320,27 +321,27 @@ export function getOperatorPrecedence(
 
     case SyntaxKind.BinaryExpression:
       switch (operatorKind) {
-        case SyntaxKind.CommaToken:
-          return OperatorPrecedence.Comma;
-
-        case SyntaxKind.EqualsToken:
-        case SyntaxKind.PlusEqualsToken:
-        case SyntaxKind.MinusEqualsToken:
+        case SyntaxKind.AmpersandAmpersandEqualsToken:
+        case SyntaxKind.AmpersandEqualsToken:
         case SyntaxKind.AsteriskAsteriskEqualsToken:
         case SyntaxKind.AsteriskEqualsToken:
-        case SyntaxKind.SlashEqualsToken:
-        case SyntaxKind.PercentEqualsToken:
-        case SyntaxKind.LessThanLessThanEqualsToken:
+        case SyntaxKind.BarBarEqualsToken:
+        case SyntaxKind.BarEqualsToken:
+        case SyntaxKind.CaretEqualsToken:
+        case SyntaxKind.EqualsToken:
         case SyntaxKind.GreaterThanGreaterThanEqualsToken:
         case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
-        case SyntaxKind.AmpersandEqualsToken:
-        case SyntaxKind.CaretEqualsToken:
-        case SyntaxKind.BarEqualsToken:
-        case SyntaxKind.BarBarEqualsToken:
-        case SyntaxKind.AmpersandAmpersandEqualsToken:
+        case SyntaxKind.LessThanLessThanEqualsToken:
+        case SyntaxKind.MinusEqualsToken:
+        case SyntaxKind.PercentEqualsToken:
+        case SyntaxKind.PlusEqualsToken:
         case SyntaxKind.QuestionQuestionEqualsToken:
+        case SyntaxKind.SlashEqualsToken:
           return OperatorPrecedence.Assignment;
 
+        case SyntaxKind.CommaToken:
+          return OperatorPrecedence.Comma;
+
         default:
           return getBinaryOperatorPrecedence(operatorKind);
       }
@@ -410,81 +411,81 @@ export function getBinaryOperatorPrecedence(
   kind: SyntaxKind | TSESTreeOperatorKind,
 ): OperatorPrecedence {
   switch (kind) {
-    case SyntaxKind.QuestionQuestionToken:
+    case '-':
+    case '+':
+    case SyntaxKind.MinusToken:
+    case SyntaxKind.PlusToken:
+      return OperatorPrecedence.Additive;
+
+    case '!=':
+    case '!==':
+    case '==':
+    case '===':
+    case SyntaxKind.EqualsEqualsEqualsToken:
+    case SyntaxKind.EqualsEqualsToken:
+    case SyntaxKind.ExclamationEqualsEqualsToken:
+    case SyntaxKind.ExclamationEqualsToken:
+      return OperatorPrecedence.Equality;
+
     case '??':
+    case SyntaxKind.QuestionQuestionToken:
       return OperatorPrecedence.Coalesce;
 
-    case SyntaxKind.BarBarToken:
-    case '||':
-      return OperatorPrecedence.LogicalOR;
+    case '*':
+    case '/':
+    case '%':
+    case SyntaxKind.AsteriskToken:
+    case SyntaxKind.PercentToken:
+    case SyntaxKind.SlashToken:
+      return OperatorPrecedence.Multiplicative;
+
+    case '**':
+    case SyntaxKind.AsteriskAsteriskToken:
+      return OperatorPrecedence.Exponentiation;
+
+    case '&':
+    case SyntaxKind.AmpersandToken:
+      return OperatorPrecedence.BitwiseAND;
 
-    case SyntaxKind.AmpersandAmpersandToken:
     case '&&':
+    case SyntaxKind.AmpersandAmpersandToken:
       return OperatorPrecedence.LogicalAND;
 
-    case SyntaxKind.BarToken:
-    case '|':
-      return OperatorPrecedence.BitwiseOR;
-
-    case SyntaxKind.CaretToken:
     case '^':
+    case SyntaxKind.CaretToken:
       return OperatorPrecedence.BitwiseXOR;
 
-    case SyntaxKind.AmpersandToken:
-    case '&':
-      return OperatorPrecedence.BitwiseAND;
-
-    case SyntaxKind.EqualsEqualsToken:
-    case '==':
-    case SyntaxKind.ExclamationEqualsToken:
-    case '!=':
-    case SyntaxKind.EqualsEqualsEqualsToken:
-    case '===':
-    case SyntaxKind.ExclamationEqualsEqualsToken:
-    case '!==':
-      return OperatorPrecedence.Equality;
-
-    case SyntaxKind.LessThanToken:
     case '<':
-    case SyntaxKind.GreaterThanToken:
-    case '>':
-    case SyntaxKind.LessThanEqualsToken:
     case '<=':
-    case SyntaxKind.GreaterThanEqualsToken:
+    case '>':
     case '>=':
-    case SyntaxKind.InstanceOfKeyword:
-    case 'instanceof':
-    case SyntaxKind.InKeyword:
     case 'in':
+    case 'instanceof':
     case SyntaxKind.AsKeyword:
+    case SyntaxKind.GreaterThanEqualsToken:
+    case SyntaxKind.GreaterThanToken:
+    case SyntaxKind.InKeyword:
+    case SyntaxKind.InstanceOfKeyword:
+    case SyntaxKind.LessThanEqualsToken:
+    case SyntaxKind.LessThanToken:
       // case 'as': -- we don't have a token for this
       return OperatorPrecedence.Relational;
 
-    case SyntaxKind.LessThanLessThanToken:
     case '<<':
-    case SyntaxKind.GreaterThanGreaterThanToken:
     case '>>':
-    case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
     case '>>>':
+    case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+    case SyntaxKind.GreaterThanGreaterThanToken:
+    case SyntaxKind.LessThanLessThanToken:
       return OperatorPrecedence.Shift;
 
-    case SyntaxKind.PlusToken:
-    case '+':
-    case SyntaxKind.MinusToken:
-    case '-':
-      return OperatorPrecedence.Additive;
-
-    case SyntaxKind.AsteriskToken:
-    case '*':
-    case SyntaxKind.SlashToken:
-    case '/':
-    case SyntaxKind.PercentToken:
-    case '%':
-      return OperatorPrecedence.Multiplicative;
+    case '|':
+    case SyntaxKind.BarToken:
+      return OperatorPrecedence.BitwiseOR;
 
-    case SyntaxKind.AsteriskAsteriskToken:
-    case '**':
-      return OperatorPrecedence.Exponentiation;
+    case '||':
+    case SyntaxKind.BarBarToken:
+      return OperatorPrecedence.LogicalOR;
   }
 
   // -1 is lower than all other precedences.  Returning it will cause binary expression
diff --git a/packages/eslint-plugin/src/util/getStaticStringValue.ts b/packages/eslint-plugin/src/util/getStaticStringValue.ts
index 6eeaf9af8ce3..103e53154ba2 100644
--- a/packages/eslint-plugin/src/util/getStaticStringValue.ts
+++ b/packages/eslint-plugin/src/util/getStaticStringValue.ts
@@ -1,6 +1,7 @@
 // adapted from https://github.com/eslint/eslint/blob/5bdaae205c3a0089ea338b382df59e21d5b06436/lib/rules/utils/ast-utils.js#L191-L230
 
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import { isNullLiteral } from './isNullLiteral';
diff --git a/packages/eslint-plugin/src/util/getThisExpression.ts b/packages/eslint-plugin/src/util/getThisExpression.ts
index 196254c35f96..5bcd33bdf089 100644
--- a/packages/eslint-plugin/src/util/getThisExpression.ts
+++ b/packages/eslint-plugin/src/util/getThisExpression.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 export function getThisExpression(
diff --git a/packages/eslint-plugin/src/util/getWrappingFixer.ts b/packages/eslint-plugin/src/util/getWrappingFixer.ts
index cb45f1cdfc3d..64c76337c7f9 100644
--- a/packages/eslint-plugin/src/util/getWrappingFixer.ts
+++ b/packages/eslint-plugin/src/util/getWrappingFixer.ts
@@ -1,4 +1,5 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
 import {
   AST_NODE_TYPES,
   ASTUtils,
@@ -6,10 +7,6 @@ import {
 } from '@typescript-eslint/utils';
 
 interface WrappingFixerParams {
-  /** Source code. */
-  sourceCode: Readonly<TSESLint.SourceCode>;
-  /** The node we want to modify. */
-  node: TSESTree.Node;
   /**
    * Descendant of `node` we want to preserve.
    * Use this to replace some code with another.
@@ -17,6 +14,10 @@ interface WrappingFixerParams {
    * You can pass multiple nodes as an array.
    */
   innerNode?: TSESTree.Node | TSESTree.Node[];
+  /** The node we want to modify. */
+  node: TSESTree.Node;
+  /** Source code. */
+  sourceCode: Readonly<TSESLint.SourceCode>;
   /**
    * The function which gets the code of the `innerNode` and returns some code around it.
    * Receives multiple arguments if there are multiple innerNodes.
@@ -32,7 +33,7 @@ interface WrappingFixerParams {
 export function getWrappingFixer(
   params: WrappingFixerParams,
 ): TSESLint.ReportFixFunction {
-  const { sourceCode, node, innerNode = node, wrap } = params;
+  const { node, innerNode = node, sourceCode, wrap } = params;
   const innerNodes = Array.isArray(innerNode) ? innerNode : [innerNode];
 
   return (fixer): TSESLint.RuleFix => {
@@ -82,11 +83,11 @@ export function getWrappingFixer(
  * @returns If parentheses are required, code for the nodeToMove node is returned with parentheses at both ends of the code.
  */
 export function getMovedNodeCode(params: {
-  sourceCode: Readonly<TSESLint.SourceCode>;
-  nodeToMove: TSESTree.Node;
   destinationNode: TSESTree.Node;
+  nodeToMove: TSESTree.Node;
+  sourceCode: Readonly<TSESLint.SourceCode>;
 }): string {
-  const { sourceCode, nodeToMove: existingNode, destinationNode } = params;
+  const { destinationNode, nodeToMove: existingNode, sourceCode } = params;
   const code = sourceCode.getText(existingNode);
   if (isStrongPrecedenceNode(existingNode)) {
     // Moved node never needs parens
diff --git a/packages/eslint-plugin/src/util/index.ts b/packages/eslint-plugin/src/util/index.ts
index 4ceb0b42f2ce..4c7f791c4af7 100644
--- a/packages/eslint-plugin/src/util/index.ts
+++ b/packages/eslint-plugin/src/util/index.ts
@@ -3,6 +3,7 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 export * from './astUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
+export * from './getFixOrSuggest';
 export * from './getFunctionHeadLoc';
 export * from './getOperatorPrecedence';
 export * from './getStaticStringValue';
@@ -10,6 +11,7 @@ export * from './getStringLength';
 export * from './getTextWithParentheses';
 export * from './getThisExpression';
 export * from './getWrappingFixer';
+export * from './isAssignee';
 export * from './isNodeEqual';
 export * from './isNullLiteral';
 export * from './isStartOfExpressionStatement';
@@ -19,16 +21,14 @@ export * from './needsPrecedingSemiColon';
 export * from './objectIterators';
 export * from './scopeUtils';
 export * from './types';
-export * from './isAssignee';
-export * from './getFixOrSuggest';
 
 // this is done for convenience - saves migrating all of the old rules
 export * from '@typescript-eslint/type-utils';
 const {
   applyDefault,
   deepMerge,
-  isObjectNotArray,
   getParserServices,
+  isObjectNotArray,
   nullThrows,
   NullThrowsReasons,
 } = ESLintUtils;
@@ -39,10 +39,10 @@ type InferOptionsTypeFromRule<T> = ESLintUtils.InferOptionsTypeFromRule<T>;
 export {
   applyDefault,
   deepMerge,
-  isObjectNotArray,
   getParserServices,
-  nullThrows,
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
+  isObjectNotArray,
+  nullThrows,
   NullThrowsReasons,
 };
diff --git a/packages/eslint-plugin/src/util/isAssignee.ts b/packages/eslint-plugin/src/util/isAssignee.ts
index 390243152503..9bf694827722 100644
--- a/packages/eslint-plugin/src/util/isAssignee.ts
+++ b/packages/eslint-plugin/src/util/isAssignee.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 export function isAssignee(node: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/util/isNodeEqual.ts b/packages/eslint-plugin/src/util/isNodeEqual.ts
index d783d8184285..729b38b58888 100644
--- a/packages/eslint-plugin/src/util/isNodeEqual.ts
+++ b/packages/eslint-plugin/src/util/isNodeEqual.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 export function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/util/isNullLiteral.ts b/packages/eslint-plugin/src/util/isNullLiteral.ts
index d59a926c5aaa..a54aec1725a8 100644
--- a/packages/eslint-plugin/src/util/isNullLiteral.ts
+++ b/packages/eslint-plugin/src/util/isNullLiteral.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 export function isNullLiteral(i: TSESTree.Node): i is TSESTree.NullLiteral {
diff --git a/packages/eslint-plugin/src/util/isStartOfExpressionStatement.ts b/packages/eslint-plugin/src/util/isStartOfExpressionStatement.ts
index 76f920dfbeb8..f5d39061c23c 100644
--- a/packages/eslint-plugin/src/util/isStartOfExpressionStatement.ts
+++ b/packages/eslint-plugin/src/util/isStartOfExpressionStatement.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 // The following is copied from `eslint`'s source code.
diff --git a/packages/eslint-plugin/src/util/isTypeImport.ts b/packages/eslint-plugin/src/util/isTypeImport.ts
index 6e8af22d751c..b1c88d813a7d 100644
--- a/packages/eslint-plugin/src/util/isTypeImport.ts
+++ b/packages/eslint-plugin/src/util/isTypeImport.ts
@@ -2,6 +2,7 @@ import type {
   Definition,
   ImportBindingDefinition,
 } from '@typescript-eslint/scope-manager';
+
 import { DefinitionType } from '@typescript-eslint/scope-manager';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
diff --git a/packages/eslint-plugin/src/util/isUndefinedIdentifier.ts b/packages/eslint-plugin/src/util/isUndefinedIdentifier.ts
index 75c301a1ea49..4436ead15d68 100644
--- a/packages/eslint-plugin/src/util/isUndefinedIdentifier.ts
+++ b/packages/eslint-plugin/src/util/isUndefinedIdentifier.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 export function isUndefinedIdentifier(i: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/util/misc.ts b/packages/eslint-plugin/src/util/misc.ts
index 46ad05c3a0e1..34b5c1ae29e5 100644
--- a/packages/eslint-plugin/src/util/misc.ts
+++ b/packages/eslint-plugin/src/util/misc.ts
@@ -2,8 +2,9 @@
  * @fileoverview Really small utility functions that didn't deserve their own files
  */
 
-import { requiresQuoting } from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+
+import { requiresQuoting } from '@typescript-eslint/type-utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
@@ -97,10 +98,10 @@ function getNameFromIndexSignature(node: TSESTree.TSIndexSignature): string {
 }
 
 enum MemberNameType {
+  Expression = 4,
+  Normal = 3,
   Private = 1,
   Quoted = 2,
-  Normal = 3,
-  Expression = 4,
 }
 
 /**
@@ -109,46 +110,46 @@ enum MemberNameType {
  */
 function getNameFromMember(
   member:
-    | TSESTree.MethodDefinition
     | TSESTree.AccessorProperty
+    | TSESTree.MethodDefinition
     | TSESTree.Property
     | TSESTree.PropertyDefinition
-    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.TSAbstractAccessorProperty
+    | TSESTree.TSAbstractMethodDefinition
     | TSESTree.TSAbstractPropertyDefinition
     | TSESTree.TSMethodSignature
     | TSESTree.TSPropertySignature,
   sourceCode: TSESLint.SourceCode,
-): { type: MemberNameType; name: string } {
+): { name: string; type: MemberNameType } {
   if (member.key.type === AST_NODE_TYPES.Identifier) {
     return {
-      type: MemberNameType.Normal,
       name: member.key.name,
+      type: MemberNameType.Normal,
     };
   }
   if (member.key.type === AST_NODE_TYPES.PrivateIdentifier) {
     return {
-      type: MemberNameType.Private,
       name: `#${member.key.name}`,
+      type: MemberNameType.Private,
     };
   }
   if (member.key.type === AST_NODE_TYPES.Literal) {
     const name = `${member.key.value}`;
     if (requiresQuoting(name)) {
       return {
-        type: MemberNameType.Quoted,
         name: `"${name}"`,
+        type: MemberNameType.Quoted,
       };
     }
     return {
-      type: MemberNameType.Normal,
       name,
+      type: MemberNameType.Normal,
     };
   }
 
   return {
-    type: MemberNameType.Expression,
     name: sourceCode.text.slice(...member.key.range),
+    type: MemberNameType.Expression,
   };
 }
 
@@ -159,7 +160,7 @@ type ExcludeKeys<
 type RequireKeys<
   Obj extends Record<string, unknown>,
   Keys extends keyof Obj,
-> = ExcludeKeys<Obj, Keys> & { [k in Keys]-?: Exclude<Obj[k], undefined> };
+> = { [k in Keys]-?: Exclude<Obj[k], undefined> } & ExcludeKeys<Obj, Keys>;
 
 function getEnumNames<T extends string>(myEnum: Record<T, unknown>): T[] {
   return Object.keys(myEnum).filter(x => isNaN(Number(x))) as T[];
@@ -238,16 +239,16 @@ export {
   Equal,
   ExcludeKeys,
   findFirstResult,
+  findLastIndex,
   formatWordList,
   getEnumNames,
   getNameFromIndexSignature,
   getNameFromMember,
   isDefinitionFile,
-  isRestParameterDeclaration,
   isParenlessArrowFunction,
+  isRestParameterDeclaration,
   MemberNameType,
   RequireKeys,
   typeNodeRequiresParentheses,
   upperCaseFirst,
-  findLastIndex,
 };
diff --git a/packages/eslint-plugin/src/util/needsPrecedingSemiColon.ts b/packages/eslint-plugin/src/util/needsPrecedingSemiColon.ts
index 5f9a94f551f4..84d0901a35c0 100644
--- a/packages/eslint-plugin/src/util/needsPrecedingSemiColon.ts
+++ b/packages/eslint-plugin/src/util/needsPrecedingSemiColon.ts
@@ -1,10 +1,11 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
+
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import {
   isClosingBraceToken,
   isClosingParenToken,
 } from '@typescript-eslint/utils/ast-utils';
-import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
 
 // The following is adapted from `eslint`'s source code.
 // https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/lib/rules/utils/ast-utils.js#L1043-L1132
diff --git a/packages/eslint-plugin/src/util/referenceContainsTypeQuery.ts b/packages/eslint-plugin/src/util/referenceContainsTypeQuery.ts
index 60872beeddb5..2d5a42a102e2 100644
--- a/packages/eslint-plugin/src/util/referenceContainsTypeQuery.ts
+++ b/packages/eslint-plugin/src/util/referenceContainsTypeQuery.ts
@@ -1,4 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/utils';
+
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 /**
diff --git a/packages/eslint-plugin/src/util/types.ts b/packages/eslint-plugin/src/util/types.ts
index 84991966a237..0765b2683d6e 100644
--- a/packages/eslint-plugin/src/util/types.ts
+++ b/packages/eslint-plugin/src/util/types.ts
@@ -1,5 +1,5 @@
-export type MakeRequired<Base, Key extends keyof Base> = Omit<Base, Key> & {
+export type MakeRequired<Base, Key extends keyof Base> = {
   [K in Key]-?: NonNullable<Base[Key]>;
-};
+} & Omit<Base, Key>;
 
 export type ValueOf<T> = T[keyof T];
diff --git a/packages/eslint-plugin/tests/RuleTester.ts b/packages/eslint-plugin/tests/RuleTester.ts
index 12511185f9ae..bc0317c8a466 100644
--- a/packages/eslint-plugin/tests/RuleTester.ts
+++ b/packages/eslint-plugin/tests/RuleTester.ts
@@ -1,10 +1,10 @@
-import * as path from 'node:path';
-
 import type {
   InvalidTestCase,
   ValidTestCase,
 } from '@typescript-eslint/rule-tester';
 
+import * as path from 'node:path';
+
 export function getFixturesRootDir(): string {
   return path.join(__dirname, 'fixtures');
 }
@@ -46,9 +46,9 @@ export function batchedSingleLineTests<
   Options extends readonly unknown[],
 >(
   options:
-    | (Omit<InvalidTestCase<MessageIds, Options>, 'output'> & {
+    | ({
         output?: string | null;
-      })
+      } & Omit<InvalidTestCase<MessageIds, Options>, 'output'>)
     | ValidTestCase<Options>,
 ): (InvalidTestCase<MessageIds, Options> | ValidTestCase<Options>)[] {
   // -- eslint counts lines from 1
diff --git a/packages/eslint-plugin/tests/areOptionsValid.test.ts b/packages/eslint-plugin/tests/areOptionsValid.test.ts
index 1908acf1460f..dd5ddfabc12d 100644
--- a/packages/eslint-plugin/tests/areOptionsValid.test.ts
+++ b/packages/eslint-plugin/tests/areOptionsValid.test.ts
@@ -2,19 +2,19 @@ import { createRule } from '../src/util';
 import { areOptionsValid } from './areOptionsValid';
 
 const exampleRule = createRule<['value-a' | 'value-b'], never>({
-  name: 'my-example-rule',
+  create() {
+    return {};
+  },
+  defaultOptions: ['value-a'],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Detects something or other',
     },
-    schema: [{ type: 'string', enum: ['value-a', 'value-b'] }],
     messages: {},
+    schema: [{ enum: ['value-a', 'value-b'], type: 'string' }],
+    type: 'suggestion',
   },
-  defaultOptions: ['value-a'],
-  create() {
-    return {};
-  },
+  name: 'my-example-rule',
 });
 
 test('returns true for valid options', () => {
diff --git a/packages/eslint-plugin/tests/areOptionsValid.ts b/packages/eslint-plugin/tests/areOptionsValid.ts
index 807653deb2ff..177d000e0ac8 100644
--- a/packages/eslint-plugin/tests/areOptionsValid.ts
+++ b/packages/eslint-plugin/tests/areOptionsValid.ts
@@ -1,8 +1,9 @@
-import { TSUtils } from '@typescript-eslint/utils';
 import type { RuleModule } from '@typescript-eslint/utils/ts-eslint';
-import Ajv from 'ajv';
 import type { JSONSchema4 } from 'json-schema';
 
+import { TSUtils } from '@typescript-eslint/utils';
+import Ajv from 'ajv';
+
 const ajv = new Ajv({ async: false });
 
 export function areOptionsValid(
@@ -29,16 +30,16 @@ function normalizeSchema(
 
   if (schema.length === 0) {
     return {
-      type: 'array',
-      minItems: 0,
       maxItems: 0,
+      minItems: 0,
+      type: 'array',
     };
   }
 
   return {
-    type: 'array',
     items: schema as JSONSchema4[],
-    minItems: 0,
     maxItems: schema.length,
+    minItems: 0,
+    type: 'array',
   };
 }
diff --git a/packages/eslint-plugin/tests/configs.test.ts b/packages/eslint-plugin/tests/configs.test.ts
index 22da970a907d..ebb7f240193a 100644
--- a/packages/eslint-plugin/tests/configs.test.ts
+++ b/packages/eslint-plugin/tests/configs.test.ts
@@ -24,8 +24,8 @@ function entriesToObject<T = unknown>(value: [string, T][]): Record<string, T> {
 }
 
 function filterRules(
-  values: Record<string, string | unknown[]>,
-): [string, string | unknown[]][] {
+  values: Record<string, unknown[] | string>,
+): [string, unknown[] | string][] {
   return Object.entries(values).filter(([name]) =>
     name.startsWith(RULE_NAME_PREFIX),
   );
@@ -33,14 +33,14 @@ function filterRules(
 
 interface FilterAndMapRuleConfigsSettings {
   excludeDeprecated?: boolean;
-  typeChecked?: 'exclude' | 'include-only';
   recommendations?: (RuleRecommendation | undefined)[];
+  typeChecked?: 'exclude' | 'include-only';
 }
 
 function filterAndMapRuleConfigs({
   excludeDeprecated,
-  typeChecked,
   recommendations,
+  typeChecked,
 }: FilterAndMapRuleConfigsSettings = {}): [string, unknown][] {
   let result = Object.entries(rules);
 
@@ -91,7 +91,7 @@ function filterAndMapRuleConfigs({
 }
 
 function itHasBaseRulesOverriden(
-  unfilteredConfigRules: Record<string, string | unknown[]>,
+  unfilteredConfigRules: Record<string, unknown[] | string>,
 ): void {
   it('has the base rules overriden by the appropriate extension rules', () => {
     const ruleNames = new Set(Object.keys(unfilteredConfigRules));
@@ -147,8 +147,8 @@ describe('recommended.ts', () => {
     const configRules = filterRules(unfilteredConfigRules);
     // note: include deprecated rules so that the config doesn't change between major bumps
     const ruleConfigs = filterAndMapRuleConfigs({
-      typeChecked: 'exclude',
       recommendations: ['recommended'],
+      typeChecked: 'exclude',
     });
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
@@ -182,8 +182,8 @@ describe('recommended-type-checked-only.ts', () => {
     const configRules = filterRules(unfilteredConfigRules);
     // note: include deprecated rules so that the config doesn't change between major bumps
     const ruleConfigs = filterAndMapRuleConfigs({
-      typeChecked: 'include-only',
       recommendations: ['recommended'],
+      typeChecked: 'include-only',
     }).filter(([ruleName]) => ruleName);
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
@@ -193,7 +193,7 @@ describe('recommended-type-checked-only.ts', () => {
 });
 
 describe('strict.ts', () => {
-  const unfilteredConfigRules: Record<string, string | unknown[]> =
+  const unfilteredConfigRules: Record<string, unknown[] | string> =
     plugin.configs.strict.rules;
 
   it('contains all strict rules, excluding type checked ones', () => {
@@ -201,8 +201,8 @@ describe('strict.ts', () => {
     // note: exclude deprecated rules, this config is allowed to change between minor versions
     const ruleConfigs = filterAndMapRuleConfigs({
       excludeDeprecated: true,
-      typeChecked: 'exclude',
       recommendations: ['recommended', 'strict'],
+      typeChecked: 'exclude',
     });
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
@@ -212,7 +212,7 @@ describe('strict.ts', () => {
 });
 
 describe('strict-type-checked.ts', () => {
-  const unfilteredConfigRules: Record<string, string | unknown[]> =
+  const unfilteredConfigRules: Record<string, unknown[] | string> =
     plugin.configs['strict-type-checked'].rules;
 
   it('contains all strict rules', () => {
@@ -229,7 +229,7 @@ describe('strict-type-checked.ts', () => {
 });
 
 describe('strict-type-checked-only.ts', () => {
-  const unfilteredConfigRules: Record<string, string | unknown[]> =
+  const unfilteredConfigRules: Record<string, unknown[] | string> =
     plugin.configs['strict-type-checked-only'].rules;
 
   it('contains only type-checked strict rules', () => {
@@ -237,8 +237,8 @@ describe('strict-type-checked-only.ts', () => {
     // note: exclude deprecated rules, this config is allowed to change between minor versions
     const ruleConfigs = filterAndMapRuleConfigs({
       excludeDeprecated: true,
-      typeChecked: 'include-only',
       recommendations: ['recommended', 'strict'],
+      typeChecked: 'include-only',
     }).filter(([ruleName]) => ruleName);
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
@@ -248,15 +248,15 @@ describe('strict-type-checked-only.ts', () => {
 });
 
 describe('stylistic.ts', () => {
-  const unfilteredConfigRules: Record<string, string | unknown[]> =
+  const unfilteredConfigRules: Record<string, unknown[] | string> =
     plugin.configs.stylistic.rules;
 
   it('contains all stylistic rules, excluding deprecated or type checked ones', () => {
     const configRules = filterRules(unfilteredConfigRules);
     // note: include deprecated rules so that the config doesn't change between major bumps
     const ruleConfigs = filterAndMapRuleConfigs({
-      typeChecked: 'exclude',
       recommendations: ['stylistic'],
+      typeChecked: 'exclude',
     });
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
@@ -289,8 +289,8 @@ describe('stylistic-type-checked-only.ts', () => {
     const configRules = filterRules(unfilteredConfigRules);
     // note: include deprecated rules so that the config doesn't change between major bumps
     const ruleConfigs = filterAndMapRuleConfigs({
-      typeChecked: 'include-only',
       recommendations: ['stylistic'],
+      typeChecked: 'include-only',
     }).filter(([ruleName]) => ruleName);
 
     expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
diff --git a/packages/eslint-plugin/tests/docs.test.ts b/packages/eslint-plugin/tests/docs.test.ts
index ee518640efed..7b4855cb8167 100644
--- a/packages/eslint-plugin/tests/docs.test.ts
+++ b/packages/eslint-plugin/tests/docs.test.ts
@@ -1,19 +1,18 @@
-import 'jest-specific-snapshot';
-
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
+import type * as mdast from 'mdast';
+import type { fromMarkdown as FromMarkdown } from 'mdast-util-from-markdown' with { 'resolution-mode': 'import' };
+import type { mdxFromMarkdown as MdxFromMarkdown } from 'mdast-util-mdx' with { 'resolution-mode': 'import' };
+import type { mdxjs as Mdxjs } from 'micromark-extension-mdxjs' with { 'resolution-mode': 'import' };
+import type * as UnistUtilVisit from 'unist-util-visit' with { 'resolution-mode': 'import' };
 
 import { parseForESLint } from '@typescript-eslint/parser';
 import * as tseslintParser from '@typescript-eslint/parser';
 import { Linter } from '@typescript-eslint/utils/ts-eslint';
+import 'jest-specific-snapshot';
 import { marked } from 'marked';
-import type * as mdast from 'mdast';
-import type { fromMarkdown as FromMarkdown } from 'mdast-util-from-markdown' with { 'resolution-mode': 'import' };
-import type { mdxFromMarkdown as MdxFromMarkdown } from 'mdast-util-mdx' with { 'resolution-mode': 'import' };
-import type { mdxjs as Mdxjs } from 'micromark-extension-mdxjs' with { 'resolution-mode': 'import' };
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
 import { titleCase } from 'title-case';
-import type * as UnistUtilVisit from 'unist-util-visit' with { 'resolution-mode': 'import' };
 
 import rules from '../src/rules';
 import { areOptionsValid } from './areOptionsValid';
@@ -43,7 +42,7 @@ type TokenType = marked.Token['type'];
 function tokenIs<Type extends TokenType>(
   token: marked.Token,
   type: Type,
-): token is marked.Token & { type: Type } {
+): token is { type: Type } & marked.Token {
   return token.type === type;
 }
 
@@ -53,7 +52,7 @@ function tokenIsHeading(token: marked.Token): token is marked.Tokens.Heading {
 
 function tokenIsH2(
   token: marked.Token,
-): token is marked.Tokens.Heading & { depth: 2 } {
+): token is { depth: 2 } & marked.Tokens.Heading {
   return (
     tokenIsHeading(token) && token.depth === 2 && !/[a-z]+: /.test(token.text)
   );
@@ -228,10 +227,10 @@ describe('Validating rule docs', () => {
           type: 'hr',
         });
         expect(tokens[1]).toMatchObject({
+          depth: 2,
           text: description.includes("'")
             ? `description: "${description}."`
             : `description: '${description}.'`,
-          depth: 2,
           type: 'heading',
         });
       });
@@ -376,8 +375,8 @@ describe('Validating rule docs', () => {
                 jsx: /^tsx\b/i.test(lang),
               },
               ecmaVersion: 'latest',
-              sourceType: 'module',
               range: true,
+              sourceType: 'module',
             });
           } catch {
             throw new Error(`Parsing error:\n\n${token.text}`);
@@ -435,7 +434,7 @@ describe('Validating rule docs', () => {
 
         function lintCodeBlock(
           token: mdast.Code,
-          shouldContainLintErrors: boolean | 'skip-check',
+          shouldContainLintErrors: 'skip-check' | boolean,
         ): void {
           const lang = token.lang?.trim();
           if (!lang || !/^tsx?\b/i.test(lang)) {
@@ -467,8 +466,8 @@ describe('Validating rule docs', () => {
               parser: '@typescript-eslint/parser',
               parserOptions: {
                 disallowAutomaticSingleRunInference: true,
-                tsconfigRootDir: rootPath,
                 project: './tsconfig.json',
+                tsconfigRootDir: rootPath,
               },
               rules: {
                 [ruleName]: ruleConfig,
diff --git a/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts b/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts
index 9f27b18b35ec..2abf2dbb843b 100644
--- a/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts
@@ -7,6 +7,7 @@ const rule = getESLintCoreRule('arrow-parens');
 const ruleTester = new RuleTester();
 
 ruleTester.run('arrow-parens', rule, {
+  invalid: [],
   valid: [
     // https://github.com/typescript-eslint/typescript-eslint/issues/14
     noFormat`const foo = (t) => {};`,
@@ -40,5 +41,4 @@ const foo = <T,>(bar: any): void => {
       options: ['as-needed', { requireForBlockBody: true }],
     },
   ],
-  invalid: [],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/no-dupe-args.test.ts b/packages/eslint-plugin/tests/eslint-rules/no-dupe-args.test.ts
index 0050a131761b..6b51c17c048c 100644
--- a/packages/eslint-plugin/tests/eslint-rules/no-dupe-args.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/no-dupe-args.test.ts
@@ -7,6 +7,7 @@ const rule = getESLintCoreRule('no-dupe-args');
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-dupe-args', rule, {
+  invalid: [],
   valid: [
     // https://github.com/eslint/typescript-eslint-parser/issues/535
     `
@@ -15,5 +16,4 @@ function foo({ bar }: { bar: string }) {
 }
     `,
   ],
-  invalid: [],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/no-implicit-globals.test.ts b/packages/eslint-plugin/tests/eslint-rules/no-implicit-globals.test.ts
index ebac70b7d2f7..197c215230fb 100644
--- a/packages/eslint-plugin/tests/eslint-rules/no-implicit-globals.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/no-implicit-globals.test.ts
@@ -6,6 +6,7 @@ const rule = getESLintCoreRule('no-implicit-globals');
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-implicit-globals', rule, {
+  invalid: [],
   valid: [
     // https://github.com/typescript-eslint/typescript-eslint/issues/23
     `
@@ -16,5 +17,4 @@ function foo() {
 module.exports = foo;
     `,
   ],
-  invalid: [],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/no-restricted-globals.test.ts b/packages/eslint-plugin/tests/eslint-rules/no-restricted-globals.test.ts
index 2958d9d13cfd..ac03e65f49b9 100644
--- a/packages/eslint-plugin/tests/eslint-rules/no-restricted-globals.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/no-restricted-globals.test.ts
@@ -7,46 +7,6 @@ const rule = getESLintCoreRule('no-restricted-globals');
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-globals', rule, {
-  valid: [
-    // https://github.com/eslint/typescript-eslint-parser/issues/487
-    {
-      code: `
-export default class Test {
-  private status: string;
-  getStatus() {
-    return this.status;
-  }
-}
-      `,
-      options: ['status'],
-    },
-    {
-      code: `
-type Handler = (event: string) => any;
-      `,
-      options: ['event'],
-    },
-    {
-      code: `
-        const a = foo?.bar?.name;
-      `,
-    },
-    {
-      code: `
-        const a = foo?.bar?.name ?? 'foobar';
-      `,
-    },
-    {
-      code: `
-        const a = foo()?.bar;
-      `,
-    },
-    {
-      code: `
-        const a = foo()?.bar ?? true;
-      `,
-    },
-  ],
   invalid: [
     {
       code: `
@@ -56,43 +16,83 @@ function onClick() {
 
 fdescribe('foo', function () {});
       `,
-      options: ['event'],
       errors: [
         {
-          messageId: 'defaultMessage',
           data: {
             name: 'event',
           },
+          messageId: 'defaultMessage',
         },
       ],
+      options: ['event'],
     },
     {
       code: `
 confirm('TEST');
       `,
-      options: ['confirm'],
       errors: [
         {
-          messageId: 'defaultMessage',
           data: {
             name: 'confirm',
           },
+          messageId: 'defaultMessage',
         },
       ],
+      options: ['confirm'],
     },
     {
       code: `
 var a = confirm('TEST')?.a;
       `,
-      options: ['confirm'],
       errors: [
         {
-          messageId: 'defaultMessage',
           data: {
             name: 'confirm',
           },
+          messageId: 'defaultMessage',
         },
       ],
+      options: ['confirm'],
+    },
+  ],
+  valid: [
+    // https://github.com/eslint/typescript-eslint-parser/issues/487
+    {
+      code: `
+export default class Test {
+  private status: string;
+  getStatus() {
+    return this.status;
+  }
+}
+      `,
+      options: ['status'],
+    },
+    {
+      code: `
+type Handler = (event: string) => any;
+      `,
+      options: ['event'],
+    },
+    {
+      code: `
+        const a = foo?.bar?.name;
+      `,
+    },
+    {
+      code: `
+        const a = foo?.bar?.name ?? 'foobar';
+      `,
+    },
+    {
+      code: `
+        const a = foo()?.bar;
+      `,
+    },
+    {
+      code: `
+        const a = foo()?.bar ?? true;
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts b/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts
index 2180223d1eab..3668c6c98135 100644
--- a/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts
@@ -7,6 +7,183 @@ const rule = getESLintCoreRule('no-undef');
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-undef', rule, {
+  invalid: [
+    {
+      code: 'a = 5;',
+      errors: [
+        {
+          data: {
+            name: 'a',
+          },
+          messageId: 'undef',
+        },
+      ],
+    },
+    {
+      code: 'a?.b = 5;',
+      errors: [
+        {
+          data: {
+            name: 'a',
+          },
+          messageId: 'undef',
+        },
+      ],
+    },
+    {
+      code: 'a()?.b = 5;',
+      errors: [
+        {
+          data: {
+            name: 'a',
+          },
+          messageId: 'undef',
+        },
+      ],
+    },
+    {
+      code: '<Foo />;',
+      errors: [
+        {
+          column: 2,
+          data: {
+            name: 'Foo',
+          },
+          line: 1,
+          messageId: 'undef',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+function Foo() {}
+<Foo attr={x} />;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            name: 'x',
+          },
+          line: 3,
+          messageId: 'undef',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+function Foo() {}
+<Foo {...x} />;
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            name: 'x',
+          },
+          line: 3,
+          messageId: 'undef',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+function Foo() {}
+<Foo<T> />;
+      `,
+      errors: [
+        {
+          column: 6,
+          data: {
+            name: 'T',
+          },
+          line: 3,
+          messageId: 'undef',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+function Foo() {}
+<Foo>{x}</Foo>;
+      `,
+      errors: [
+        {
+          column: 7,
+          data: {
+            name: 'x',
+          },
+          line: 3,
+          messageId: 'undef',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+class Foo {
+  [x: Bar]: string;
+}
+      `,
+      errors: [
+        {
+          data: {
+            name: 'Bar',
+          },
+          messageId: 'undef',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  [x: string]: Bar;
+}
+      `,
+      errors: [
+        {
+          data: {
+            name: 'Bar',
+          },
+          messageId: 'undef',
+        },
+      ],
+    },
+  ],
   valid: [
     `
 import Beemo from './Beemo';
@@ -274,181 +451,4 @@ class Foo {
 }
     `,
   ],
-  invalid: [
-    {
-      code: 'a = 5;',
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'a',
-          },
-        },
-      ],
-    },
-    {
-      code: 'a?.b = 5;',
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'a',
-          },
-        },
-      ],
-    },
-    {
-      code: 'a()?.b = 5;',
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'a',
-          },
-        },
-      ],
-    },
-    {
-      code: '<Foo />;',
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'Foo',
-          },
-          line: 1,
-          column: 2,
-        },
-      ],
-    },
-    {
-      code: `
-function Foo() {}
-<Foo attr={x} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'x',
-          },
-          line: 3,
-          column: 12,
-        },
-      ],
-    },
-    {
-      code: `
-function Foo() {}
-<Foo {...x} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'x',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
-function Foo() {}
-<Foo<T> />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'T',
-          },
-          line: 3,
-          column: 6,
-        },
-      ],
-    },
-    {
-      code: `
-function Foo() {}
-<Foo>{x}</Foo>;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'x',
-          },
-          line: 3,
-          column: 7,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  [x: Bar]: string;
-}
-      `,
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'Bar',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  [x: string]: Bar;
-}
-      `,
-      errors: [
-        {
-          messageId: 'undef',
-          data: {
-            name: 'Bar',
-          },
-        },
-      ],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts b/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts
index 5223be374c4a..9bd707aedf20 100644
--- a/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts
@@ -7,6 +7,7 @@ const rule = getESLintCoreRule('prefer-const');
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-const', rule, {
+  invalid: [],
   valid: [
     `
 let x: number | undefined = 1;
@@ -21,5 +22,4 @@ let x: number | undefined = 1;
 (x as number) += 1;
     `,
   ],
-  invalid: [],
 });
diff --git a/packages/eslint-plugin/tests/eslint-rules/strict.test.ts b/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
index e25d6f7a44da..41bf41cb129f 100644
--- a/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
@@ -7,16 +7,6 @@ const rule = getESLintCoreRule('strict');
 const ruleTester = new RuleTester();
 
 ruleTester.run('strict', rule, {
-  valid: [
-    // https://github.com/typescript-eslint/typescript-eslint/issues/58
-    `
-window.whatevs = {
-  myFunc() {
-    console.log('yep');
-  },
-};
-    `,
-  ],
   invalid: [
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/58
@@ -27,20 +17,30 @@ window.whatevs = {
   },
 };
       `,
-      languageOptions: {
-        parserOptions: {
-          sourceType: 'script',
-        },
-      },
       errors: [
         {
-          message: "Use the function form of 'use strict'.",
-          line: 3,
           column: 9,
+          line: 3,
+          message: "Use the function form of 'use strict'.",
           // the base rule doesn't use messageId
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any,
       ],
+      languageOptions: {
+        parserOptions: {
+          sourceType: 'script',
+        },
+      },
     },
   ],
+  valid: [
+    // https://github.com/typescript-eslint/typescript-eslint/issues/58
+    `
+window.whatevs = {
+  myFunc() {
+    console.log('yep');
+  },
+};
+    `,
+  ],
 });
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 3839469351ce..e238eaf75dad 100644
--- a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
@@ -5,924 +5,924 @@ import rule from '../../src/rules/adjacent-overload-signatures';
 const ruleTester = new RuleTester();
 
 ruleTester.run('adjacent-overload-signatures', rule, {
-  valid: [
+  invalid: [
     {
       code: `
-function error(a: string);
-function error(b: number);
-function error(ab: string | number) {}
-export { error };
+function wrap() {
+  function foo(s: string);
+  function foo(n: number);
+  type bar = number;
+  function foo(sn: string | number) {}
+}
       `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
     },
     {
       code: `
-import { connect } from 'react-redux';
-export interface ErrorMessageModel {
-  message: string;
+if (true) {
+  function foo(s: string);
+  function foo(n: number);
+  let a = 1;
+  function foo(sn: string | number) {}
+  foo(a);
 }
-function mapStateToProps() {}
-function mapDispatchToProps() {}
-export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
       `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
     },
-    `
-export const foo = 'a',
-  bar = 'b';
-export interface Foo {}
-export class Foo {}
-    `,
-    `
-export interface Foo {}
-export const foo = 'a',
-  bar = 'b';
-export class Foo {}
-    `,
-    `
-const foo = 'a',
-  bar = 'b';
-interface Foo {}
-class Foo {}
-    `,
-    `
-interface Foo {}
-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;
-    `,
-    `
+    {
+      code: `
 export function foo(s: string);
 export function foo(n: number);
-export function foo(sn: string | number) {}
 export function bar(): void {}
 export function baz(): void {}
-    `,
-    `
+export function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+export function foo(s: string);
+export function foo(n: number);
+export type bar = number;
+export type baz = number | string;
+export function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 function foo(s: string);
 function foo(n: number);
-function foo(sn: string | number) {}
 function bar(): void {}
 function baz(): void {}
-    `,
-    `
+function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+function foo(s: string);
+function foo(n: number);
+type bar = number;
+type baz = number | string;
+function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+function foo(s: string) {}
+function foo(n: number) {}
+const a = '';
+const b = '';
+function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+function foo(s: string) {}
+function foo(n: number) {}
+class Bar {}
+function foo(sn: string | number) {}
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+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) {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 9,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 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 function foo(sn: string | number);
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+declare function foo(s: string);
+declare function foo(n: number);
+const a = '';
+const b = '';
+declare function foo(sn: string | number);
+      `,
+      errors: [
+        {
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 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;
+  export function foo(sn: string | number): void;
 }
-    `,
-    `
-declare namespace Foo {
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      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;
-  export function baz(): void;
-}
-    `,
-    `
-type Foo = {
-  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;
-};
-    `,
-    `
-interface Foo {
-  (s: string): void;
-  (n: number): void;
-  (sn: string | number): void;
-  foo(n: 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;
-  call(): void;
-}
-    `,
-    `
-interface Foo {
-  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;
-}
-    `,
-    `
-interface Foo {
-  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;
-}
-    `,
-    `
-class Foo {
-  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 {}
-}
-    `,
-    `
-class Foo {
-  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 {}
-}
-    `,
-    `
-class Foo {
-  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) {}',
-    `
-interface Foo {
-  [Symbol.toStringTag](): void;
-  [Symbol.iterator](): void;
-}
-    `,
-    // private members
-    `
-class Test {
-  #private(): void;
-  #private(arg: number): void {}
-
-  bar() {}
-
-  '#private'(): void;
-  '#private'(arg: number): void {}
-}
-    `,
-    // block statement
-    `
-function wrap() {
-  function foo(s: string);
-  function foo(n: number);
-  function foo(sn: string | number) {}
-}
-    `,
-    `
-if (true) {
-  function foo(s: string);
-  function foo(n: number);
-  function foo(sn: string | number) {}
+  function baz(n: number): void;
+  function baz(sn: string | number): void;
 }
-    `,
-  ],
-  invalid: [
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'baz' },
+          line: 8,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
     {
       code: `
-function wrap() {
-  function foo(s: string);
-  function foo(n: number);
-  type bar = number;
-  function foo(sn: string | number) {}
+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;
 }
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 6,
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      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;
+}
+      `,
+      errors: [
+        {
           column: 3,
+          data: { name: 'baz' },
+          line: 8,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-if (true) {
-  function foo(s: string);
-  function foo(n: number);
-  let a = 1;
-  function foo(sn: string | number) {}
-  foo(a);
-}
+type Foo = {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 6,
           column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-export function foo(s: string);
-export function foo(n: number);
-export function bar(): void {}
-export function baz(): void {}
-export function foo(sn: string | number) {}
+type Foo = {
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 6,
-          column: 1,
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-export function foo(s: string);
-export function foo(n: number);
-export type bar = number;
-export type baz = number | string;
-export function foo(sn: string | number) {}
+type Foo = {
+  foo(s: string): void;
+  name: string;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+};
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 6,
-          column: 1,
+          line: 5,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-function foo(s: string);
-function foo(n: number);
-function bar(): void {}
-function baz(): void {}
-function foo(sn: string | number) {}
+interface Foo {
+  (s: string): void;
+  foo(n: number): void;
+  (n: number): void;
+  (sn: string | number): void;
+  bar(): void;
+  baz(): void;
+  call(): void;
+}
       `,
       errors: [
         {
+          column: 3,
+          data: { name: 'call' },
+          line: 5,
           messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 6,
-          column: 1,
         },
       ],
     },
     {
       code: `
-function foo(s: string);
-function foo(n: number);
-type bar = number;
-type baz = number | string;
-function foo(sn: string | number) {}
+interface Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 6,
-          column: 1,
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-function foo(s: string) {}
-function foo(n: number) {}
-const a = '';
-const b = '';
-function foo(sn: string | number) {}
+interface Foo {
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 6,
-          column: 1,
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-function foo(s: string) {}
-function foo(n: number) {}
-class Bar {}
-function foo(sn: string | number) {}
+interface Foo {
+  foo(s: string): void;
+  'foo'(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
-          line: 5,
-          column: 1,
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-function foo(s: string) {}
-function foo(n: number) {}
-function foo(sn: string | number) {}
-class Bar {
-  foo(s: string);
-  foo(n: number);
+interface Foo {
+  foo(s: string): void;
   name: string;
-  foo(sn: string | number) {}
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
 }
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 9,
           column: 3,
+          data: { name: 'foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-declare function foo(s: string);
-declare function foo(n: number);
-declare function bar(): void;
-declare function baz(): void;
-declare function foo(sn: string | number);
+interface Foo {
+  foo(): void;
+  bar: {
+    baz(s: string): void;
+    baz(n: number): void;
+    foo(): void;
+    baz(sn: string | number): void;
+  };
+}
       `,
       errors: [
         {
+          column: 5,
+          data: { name: 'baz' },
+          line: 8,
           messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 6,
-          column: 1,
         },
       ],
     },
     {
       code: `
-declare function foo(s: string);
-declare function foo(n: number);
-const a = '';
-const b = '';
-declare function foo(sn: string | number);
+interface Foo {
+  new (s: string);
+  new (n: number);
+  foo(): void;
+  bar(): void;
+  new (sn: string | number);
+}
       `,
       errors: [
         {
+          column: 3,
+          data: { name: 'new' },
+          line: 7,
           messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 6,
-          column: 1,
         },
       ],
     },
     {
       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;
+interface Foo {
+  new (s: string);
+  foo(): void;
+  new (n: number);
+  bar(): void;
+  new (sn: string | number);
 }
       `,
       errors: [
         {
+          column: 3,
+          data: { name: 'new' },
+          line: 5,
           messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
+        },
+        {
           column: 3,
+          data: { name: 'new' },
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       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;
+class Foo {
+  constructor(s: string);
+  constructor(n: number);
+  bar(): void {}
+  baz(): void {}
+  constructor(sn: string | number) {}
 }
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'baz' },
-          line: 8,
           column: 3,
+          data: { name: 'constructor' },
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       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;
+class Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
 }
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
           line: 7,
-          column: 3,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       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;
+class Foo {
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
 }
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'baz' },
-          line: 8,
           column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-type Foo = {
-  foo(s: string): void;
+class Foo {
+  // prettier-ignore
+  "foo"(s: string): void;
   foo(n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-};
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
           column: 3,
+          data: { name: 'foo' },
+          line: 8,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-type Foo = {
-  foo(s: string): void;
-  ['foo'](n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-};
+class Foo {
+  constructor(s: string);
+  name: string;
+  constructor(n: number);
+  constructor(sn: string | number) {}
+  bar(): void {}
+  baz(): void {}
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
           column: 3,
+          data: { name: 'constructor' },
+          line: 5,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-type Foo = {
+class Foo {
   foo(s: string): void;
   name: string;
   foo(n: number): void;
-  foo(sn: string | number): void;
-  bar(): void;
-  baz(): void;
-};
+  foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
+}
       `,
       errors: [
         {
-          messageId: 'adjacentSignature',
+          column: 3,
           data: { name: 'foo' },
           line: 5,
-          column: 3,
+          messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  (s: string): void;
-  foo(n: number): void;
-  (n: number): void;
-  (sn: string | number): void;
-  bar(): void;
-  baz(): void;
-  call(): void;
+class Foo {
+  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: 'call' },
-          line: 5,
           column: 3,
+          data: { name: 'static foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
         },
       ],
     },
+    // private members
     {
       code: `
-interface Foo {
-  foo(s: string): void;
-  foo(n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
+class Test {
+  #private(): void;
+  '#private'(): void;
+  #private(arg: number): void {}
+  '#private'(arg: number): void {}
 }
       `,
       errors: [
         {
+          column: 3,
+          data: { name: '#private' },
+          line: 5,
           messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
+        },
+        {
           column: 3,
+          data: { name: '"#private"' },
+          line: 6,
+          messageId: 'adjacentSignature',
         },
       ],
     },
+  ],
+  valid: [
     {
       code: `
-interface Foo {
+function error(a: string);
+function error(b: number);
+function error(ab: string | number) {}
+export { error };
+      `,
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+    },
+    {
+      code: `
+import { connect } from 'react-redux';
+export interface ErrorMessageModel {
+  message: string;
+}
+function mapStateToProps() {}
+function mapDispatchToProps() {}
+export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
+      `,
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+    },
+    `
+export const foo = 'a',
+  bar = 'b';
+export interface Foo {}
+export class Foo {}
+    `,
+    `
+export interface Foo {}
+export const foo = 'a',
+  bar = 'b';
+export class Foo {}
+    `,
+    `
+const foo = 'a',
+  bar = 'b';
+interface Foo {}
+class Foo {}
+    `,
+    `
+interface Foo {}
+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 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;
+}
+    `,
+    `
+type Foo = {
   foo(s: string): void;
-  ['foo'](n: number): 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;
+};
+    `,
+    `
+interface Foo {
+  (s: string): void;
+  (n: number): void;
+  (sn: string | number): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
+interface Foo {
+  (s: string): void;
+  (n: number): void;
+  (sn: string | number): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  call(): void;
+}
+    `,
+    `
 interface Foo {
   foo(s: string): void;
-  'foo'(n: number): void;
+  foo(n: number): void;
+  foo(sn: string | number): void;
   bar(): void;
   baz(): void;
-  foo(sn: string | number): void;
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 interface Foo {
   foo(s: string): void;
-  name: string;
-  foo(n: number): void;
+  ['foo'](n: number): void;
   foo(sn: string | number): void;
   bar(): void;
   baz(): void;
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 5,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 interface Foo {
   foo(): void;
   bar: {
     baz(s: string): void;
     baz(n: number): void;
-    foo(): void;
     baz(sn: string | number): void;
   };
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'baz' },
-          line: 8,
-          column: 5,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 interface Foo {
   new (s: string);
   new (n: number);
-  foo(): void;
-  bar(): void;
   new (sn: string | number);
-}
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'new' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-interface Foo {
-  new (s: string);
   foo(): void;
-  new (n: number);
-  bar(): void;
-  new (sn: string | number);
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'new' },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'new' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   constructor(s: string);
   constructor(n: number);
+  constructor(sn: string | number) {}
   bar(): void {}
   baz(): void {}
-  constructor(sn: string | number) {}
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'constructor' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   foo(s: string): void;
   foo(n: number): void;
+  foo(sn: string | number): void {}
   bar(): void {}
   baz(): void {}
-  foo(sn: string | number): void {}
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: 'foo' },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   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: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  // 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: 8,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
-  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: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
   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: 3,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
-  static foo(s: string): void;
   name: string;
+  static foo(s: string): void;
   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: 3,
-        },
-      ],
-    },
+    `,
+    `
+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) {}',
+    `
+interface Foo {
+  [Symbol.toStringTag](): void;
+  [Symbol.iterator](): void;
+}
+    `,
     // private members
-    {
-      code: `
+    `
 class Test {
   #private(): void;
-  '#private'(): void;
   #private(arg: number): void {}
+
+  bar() {}
+
+  '#private'(): void;
   '#private'(arg: number): void {}
 }
-      `,
-      errors: [
-        {
-          messageId: 'adjacentSignature',
-          data: { name: '#private' },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'adjacentSignature',
-          data: { name: '"#private"' },
-          line: 6,
-          column: 3,
-        },
-      ],
-    },
+    `,
+    // block statement
+    `
+function wrap() {
+  function foo(s: string);
+  function foo(n: number);
+  function foo(sn: string | number) {}
+}
+    `,
+    `
+if (true) {
+  function foo(s: string);
+  function foo(n: number);
+  function foo(sn: string | number) {}
+}
+    `,
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/array-type.test.ts b/packages/eslint-plugin/tests/rules/array-type.test.ts
index 52ce7be67578..0bed905c68a8 100644
--- a/packages/eslint-plugin/tests/rules/array-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/array-type.test.ts
@@ -3,1770 +3,1857 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 import { TSESLint } from '@typescript-eslint/utils';
 
 import type { OptionString } from '../../src/rules/array-type';
+
 import rule from '../../src/rules/array-type';
 import { areOptionsValid } from '../areOptionsValid';
 
 const ruleTester = new RuleTester();
 
 ruleTester.run('array-type', rule, {
-  valid: [
+  invalid: [
     // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
+      code: 'let a: Array<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
+      code: 'let a: Array<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
+      code: 'let a: Array<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
+      code: 'let a: Array<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
+      code: 'let a: readonly number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
-    },
-    {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
+      code: 'let a: readonly number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
+      code: 'let a: number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
+      code: 'let a: readonly number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: 'let a: number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
       code: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-    },
-    {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-    },
-    {
-      code: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
-    },
-    {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
-    },
-    {
-      code: 'let a: readonly number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
+      code: 'let a: number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'let a: number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: readonly bigint[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly (string | bigint)[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'let a: readonly number[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: Array<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<string | bigint> = [];',
+      code: 'let a: bigint[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'bigint' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<bigint> = [];',
     },
     {
-      code: 'let a: readonly bigint[] = [];',
+      code: 'let a: (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<string | bigint> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | bigint> = [];',
+      code: 'let a: ReadonlyArray<bigint> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'bigint',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: readonly bigint[] = [];',
     },
-
-    // End of base cases
-
     {
-      code: 'let a = new Array();',
-      options: [{ default: 'array' }],
+      code: 'let a: (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<string | bigint> = [];',
     },
     {
-      code: 'let a: { foo: Bar[] }[] = [];',
-      options: [{ default: 'array' }],
+      code: 'let a: readonly bigint[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'bigint',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<bigint> = [];',
     },
     {
-      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
-      options: [{ default: 'generic' }],
+      code: 'let a: readonly (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | bigint> = [];',
     },
+
+    // End of base cases
+
     {
-      code: 'let yy: number[][] = [[4, 5], [6]];',
-      options: [{ default: 'array-simple' }],
+      code: 'let a: { foo: Array<Bar> }[] = [];',
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let a: { foo: Bar[] }[] = [];',
     },
     {
-      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);
-}
-      `,
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'let fooVar: Array<(c: number) => number>;',
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'type fooUnion = Array<string | number | boolean>;',
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'type fooIntersection = Array<string & number>;',
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: `
-namespace fooName {
-  type BarType = { bar: string };
-  type BazType<T> = Arr<T>;
-}
-      `,
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: `
-interface FooInterface {
-  '.bar': { baz: string[] };
-}
-      `,
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'let yy: number[][] = [[4, 5], [6]];',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: "let ya = [[1, '2']] as [number, string][];",
-      options: [{ default: 'array' }],
-    },
-    {
-      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);
-}
-      `,
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'let barVar: ((c: number) => number)[];',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'type barUnion = (string | number | boolean)[];',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'type barIntersection = (string & number)[];',
-      options: [{ default: 'array' }],
-    },
-    {
-      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;',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'let xx: Array<Array<number>> = [[1, 2], [3]];',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'type Arr<T> = Array<T>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      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);
-}
-      `,
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'let fooVar: Array<(c: number) => number>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'type fooUnion = Array<string | number | boolean>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'type fooIntersection = Array<string & number>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
-      options: [{ default: 'generic' }],
-    },
-
-    // nested readonly
-    {
-      code: 'let a: ReadonlyArray<number[]> = [[]];',
-      options: [{ default: 'array', readonly: 'generic' }],
-    },
-    {
-      code: 'let a: readonly Array<number>[] = [[]];',
-      options: [{ default: 'generic', readonly: 'array' }],
-    },
-    {
-      code: 'let a: Readonly = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
-    },
-    {
-      code: "const x: Readonly<string> = 'a';",
-      options: [{ default: 'array' }],
-    },
-  ],
-  invalid: [
-    // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
-    {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array' }],
+      code: 'let a: Array<{ foo: Bar[] }> = [];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          column: 21,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'let a: Array<{ foo: Array<Bar> }> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      output: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array' }],
+      code: 'let a: Array<{ foo: Foo | Bar[] }> = [];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array' }],
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
       errors: [
         {
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
           messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+        },
+        {
+          column: 30,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'function foo(a: Bar[]): Bar[] {}',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      output: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array' }],
+      code: 'let x: Array<undefined> = [undefined] as undefined[];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
+      code: "let y: string[] = <Array<string>>['2'];",
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          column: 20,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      output: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
+      code: "let z: Array = [3, '4'];",
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: "let z: any[] = [3, '4'];",
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
+      code: "let ya = [[1, '2']] as [number, string][];",
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      output: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      code: 'type Arr<T> = Array<T>;',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'type Arr<T> = T[];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      output: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
       errors: [
         {
-          messageId: 'errorStringArray',
+          column: 15,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 8,
+          line: 3,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
+      `,
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
       errors: [
         {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
           messageId: 'errorStringGenericSimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
+}
+      `,
     },
     {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      code: 'let barVar: ((c: number) => number)[];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          column: 13,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'let barVar: Array<(c: number) => number>;',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      output: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      code: 'type barUnion = (string | number | boolean)[];',
       errors: [
         {
-          messageId: 'errorStringArray',
+          column: 17,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'type barUnion = Array<string | number | boolean>;',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      output: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      code: 'type barIntersection = (string & number)[];',
       errors: [
         {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'type barIntersection = Array<string & number>;',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      code: "let v: Array<fooName.BarType> = [{ bar: 'bar' }];",
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 8,
           data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
+            className: 'Array',
+            readonlyPrefix: '',
+            type: 'fooName.BarType',
           },
           line: 1,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
           messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: "let v: fooName.BarType[] = [{ bar: 'bar' }];",
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple' }],
+      code: "let w: fooName.BazType<string>[] = [['baz']];",
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGenericSimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: "let w: Array<fooName.BazType<string>> = [['baz']];",
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple' }],
+      code: 'let x: Array<undefined> = [undefined] as undefined[];',
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
+          line: 1,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple' }],
+      code: "let y: string[] = <Array<string>>['2'];",
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
+          column: 20,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      code: "let z: Array = [3, '4'];",
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: "let z: any[] = [3, '4'];",
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      code: 'type Arr<T> = Array<T>;',
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
+          column: 15,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'type Arr<T> = T[];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
       errors: [
         {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
           messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'array' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Arr<string>[][]> = [[[['2']]]];
+      `,
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      output: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
-      errors: [
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
+      errors: [
         {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
     },
     {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 8,
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: `
+function fooFunction(foo: ArrayClass<string>[]) {
+  return foo.map(e => e.foo);
+}
+      `,
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'let fooVar: Array<(c: number) => number>;',
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
+          column: 13,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'let fooVar: ((c: number) => number)[];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'type fooUnion = Array<string | number | boolean>;',
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'type fooUnion = (string | number | boolean)[];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'type fooIntersection = Array<string & number>;',
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'type fooIntersection = (string & number)[];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      output: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let x: Array;',
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let x: Array<>;',
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      output: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let x: Array;',
       errors: [
         {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let x: Array<>;',
       errors: [
         {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
           column: 8,
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let a: number[] = [];',
-      output: 'let a: Array<number> = [];',
-      options: [{ default: 'generic' }],
+      code: 'let x: Array<number> = [1] as number[];',
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 31,
           data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'let x: Array<number> = [1] as Array<number>;',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic' }],
+      code: "let y: string[] = <Array<string>>['2'];",
       errors: [
         {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 1,
           messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: "let y: Array<string> = <Array<string>>['2'];",
+    },
+    {
+      code: "let ya = [[1, '2']] as [number, string][];",
+      errors: [
+        {
+          column: 24,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
     },
     {
-      code: 'let a: readonly number[] = [];',
-      output: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'generic' }],
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
       errors: [
         {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
           messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'generic' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
+      `,
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic' }],
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
       errors: [
         {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
           column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 4,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: Array<T>;
+  baz: Arr<T>;
+}
+      `,
     },
     {
-      code: 'let a: number[] = [];',
-      output: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
       errors: [
         {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
           messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'generic' }],
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
+}
+      `,
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'let barVar: ((c: number) => number)[];',
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 13,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'let barVar: Array<(c: number) => number>;',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'type barUnion = (string | number | boolean)[];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'type barUnion = Array<string | number | boolean>;',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      output: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'type barIntersection = (string & number)[];',
       errors: [
         {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'type barIntersection = Array<string & number>;',
     },
     {
-      code: 'let a: number[] = [];',
-      output: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: `
+interface FooInterface {
+  '.bar': { baz: string[] };
+}
+      `,
       errors: [
         {
+          column: 18,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 3,
           messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 8,
         },
       ],
+      options: [{ default: 'generic' }],
+      output: `
+interface FooInterface {
+  '.bar': { baz: Array<string> };
+}
+      `,
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 28,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      output: 'let a: readonly number[] = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
       errors: [
         {
-          messageId: 'errorStringArraySimple',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
+          column: 28,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringGeneric',
         },
       ],
+      options: [{ default: 'generic' }],
+      output: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'type Foo = ReadonlyArray<object>[];',
       errors: [
         {
-          messageId: 'errorStringGenericSimple',
+          column: 12,
           data: {
             className: 'ReadonlyArray',
             readonlyPrefix: 'readonly ',
-            type: 'T',
+            type: 'object',
           },
           line: 1,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: 'let a: number[] = [];',
-      output: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'type Foo = (readonly object[])[];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      output: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: 'const foo: Array<new (...args: any[]) => void> = [];',
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 12,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'const foo: (new (...args: any[]) => void)[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      output: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: 'const foo: ReadonlyArray<new (...args: any[]) => void> = [];',
       errors: [
         {
-          messageId: 'errorStringGeneric',
+          column: 12,
           data: {
             className: 'ReadonlyArray',
             readonlyPrefix: 'readonly ',
-            type: 'number',
+            type: 'T',
           },
           line: 1,
-          column: 8,
+          messageId: 'errorStringArray',
         },
       ],
+      options: [{ default: 'array' }],
+      output: 'const foo: readonly (new (...args: any[]) => void)[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      output: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: "const x: Readonly<string[]> = ['a', 'b'];",
       errors: [
         {
-          messageId: 'errorStringGeneric',
           data: {
-            className: 'ReadonlyArray',
+            className: 'Readonly',
             readonlyPrefix: 'readonly ',
-            type: 'T',
+            type: 'string[]',
           },
-          line: 1,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: 'let a: bigint[] = [];',
-      output: 'let a: Array<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'bigint' },
-          line: 1,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: 'let a: (string | bigint)[] = [];',
-      output: 'let a: Array<string | bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 8,
+          messageId: 'errorStringArrayReadonly',
         },
       ],
+      options: [{ default: 'array' }],
+      output: "const x: readonly string[] = ['a', 'b'];",
     },
     {
-      code: 'let a: ReadonlyArray<bigint> = [];',
-      output: 'let a: readonly bigint[] = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'declare function foo<E extends Readonly<string[]>>(extra: E): E;',
       errors: [
         {
-          messageId: 'errorStringArraySimple',
           data: {
-            className: 'ReadonlyArray',
+            className: 'Readonly',
             readonlyPrefix: 'readonly ',
-            type: 'bigint',
+            type: 'string[]',
           },
-          line: 1,
-          column: 8,
+          messageId: 'errorStringArraySimpleReadonly',
         },
       ],
+      options: [{ default: 'array-simple' }],
+      output: 'declare function foo<E extends readonly string[]>(extra: E): E;',
     },
+  ],
+  valid: [
+    // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
     {
-      code: 'let a: (string | bigint)[] = [];',
-      output: 'let a: Array<string | bigint> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array' }],
     },
     {
-      code: 'let a: readonly bigint[] = [];',
-      output: 'let a: ReadonlyArray<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'bigint',
-          },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
+      options: [{ default: 'array' }],
     },
     {
-      code: 'let a: readonly (string | bigint)[] = [];',
-      output: 'let a: ReadonlyArray<string | bigint> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'array' }],
     },
-
-    // End of base cases
-
     {
-      code: 'let a: { foo: Array<Bar> }[] = [];',
-      output: 'let a: { foo: Bar[] }[] = [];',
+      code: 'let a: readonly (string | number)[] = [];',
       options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          column: 15,
-        },
-      ],
     },
     {
-      code: 'let a: Array<{ foo: Bar[] }> = [];',
-      output: 'let a: Array<{ foo: Array<Bar> }> = [];',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          column: 21,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array', readonly: 'array' }],
     },
     {
-      code: 'let a: Array<{ foo: Foo | Bar[] }> = [];',
-      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = [];',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          column: 27,
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
+      options: [{ default: 'array', readonly: 'array' }],
     },
     {
-      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
-      output: 'function foo(a: Bar[]): Bar[] {}',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          column: 17,
-        },
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          column: 30,
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'array', readonly: 'array' }],
     },
     {
-      code: 'let x: Array<undefined> = [undefined] as undefined[];',
-      output: 'let x: undefined[] = [undefined] as undefined[];',
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: readonly (string | number)[] = [];',
+      options: [{ default: 'array', readonly: 'array' }],
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
-      output: "let y: string[] = <string[]>['2'];",
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 1,
-          column: 20,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
     },
     {
-      code: "let z: Array = [3, '4'];",
-      output: "let z: any[] = [3, '4'];",
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 24,
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
     },
     {
-      code: 'type Arr<T> = Array<T>;',
-      output: 'type Arr<T> = T[];',
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 15,
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          column: 15,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          column: 8,
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
+      options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
-          column: 27,
-        },
-      ],
+      code: 'let a: ReadonlyArray<number> = [];',
+      options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'let barVar: ((c: number) => number)[];',
-      output: 'let barVar: Array<(c: number) => number>;',
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGenericSimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 13,
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'type barUnion = (string | number | boolean)[];',
-      output: 'type barUnion = Array<string | number | boolean>;',
+      code: 'let a: number[] = [];',
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGenericSimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 17,
-        },
-      ],
     },
     {
-      code: 'type barIntersection = (string & number)[];',
-      output: 'type barIntersection = Array<string & number>;',
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGenericSimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 24,
-        },
-      ],
     },
     {
-      code: "let v: Array<fooName.BarType> = [{ bar: 'bar' }];",
-      output: "let v: fooName.BarType[] = [{ bar: 'bar' }];",
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: {
-            className: 'Array',
-            readonlyPrefix: '',
-            type: 'fooName.BarType',
-          },
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: "let w: fooName.BazType<string>[] = [['baz']];",
-      output: "let w: Array<fooName.BazType<string>> = [['baz']];",
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringGenericSimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: 'let x: Array<undefined> = [undefined] as undefined[];',
-      output: 'let x: undefined[] = [undefined] as undefined[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array' }],
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
-      output: "let y: string[] = <string[]>['2'];",
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 1,
-          column: 20,
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'array-simple', readonly: 'array' }],
     },
     {
-      code: "let z: Array = [3, '4'];",
-      output: "let z: any[] = [3, '4'];",
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array' }],
     },
     {
-      code: 'type Arr<T> = Array<T>;',
-      output: 'type Arr<T> = T[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 15,
-        },
-      ],
+      code: 'let a: readonly (string | number)[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          column: 15,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          column: 8,
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
     },
     {
-      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: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
-          column: 27,
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
     },
     {
-      code: 'let fooVar: Array<(c: number) => number>;',
-      output: 'let fooVar: ((c: number) => number)[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 13,
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
     },
     {
-      code: 'type fooUnion = Array<string | number | boolean>;',
-      output: 'type fooUnion = (string | number | boolean)[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 17,
-        },
-      ],
+      code: 'let a: number[] = [];',
+      options: [{ default: 'array-simple', readonly: 'generic' }],
     },
     {
-      code: 'type fooIntersection = Array<string & number>;',
-      output: 'type fooIntersection = (string & number)[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 24,
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'array-simple', readonly: 'generic' }],
     },
     {
-      code: 'let x: Array;',
-      output: 'let x: any[];',
+      code: 'let a: ReadonlyArray<number> = [];',
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<number> = [];',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: readonly (string | number)[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: Array<bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: readonly bigint[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: readonly (string | bigint)[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Array<bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: Array<string | bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: readonly bigint[] = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+    {
+      code: 'let a: ReadonlyArray<string | bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+    },
+
+    // End of base cases
+
+    {
+      code: 'let a = new Array();',
       options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: 'let x: Array<>;',
-      output: 'let x: any[];',
+      code: 'let a: { foo: Bar[] }[] = [];',
       options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: 'let x: Array;',
-      output: 'let x: any[];',
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let yy: number[][] = [[4, 5], [6]];',
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: 'let x: Array<>;',
-      output: 'let x: any[];',
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
       options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimple',
-          line: 1,
-          column: 8,
-        },
-      ],
     },
     {
-      code: 'let x: Array<number> = [1] as number[];',
-      output: 'let x: Array<number> = [1] as Array<number>;',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          column: 31,
-        },
-      ],
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
+      options: [{ default: 'array-simple' }],
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
-      output: "let y: Array<string> = <Array<string>>['2'];",
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 1,
-          column: 8,
-        },
-      ],
+      code: 'let fooVar: Array<(c: number) => number>;',
+      options: [{ default: 'array-simple' }],
     },
     {
-      code: "let ya = [[1, '2']] as [number, string][];",
-      output: "let ya = [[1, '2']] as Array<[number, string]>;",
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 24,
-        },
-      ],
+      code: 'type fooUnion = Array<string | number | boolean>;',
+      options: [{ default: 'array-simple' }],
+    },
+    {
+      code: 'type fooIntersection = Array<string & number>;',
+      options: [{ default: 'array-simple' }],
     },
     {
       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']]]];
+namespace fooName {
+  type BarType = { bar: string };
+  type BazType<T> = Arr<T>;
+}
       `,
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          column: 15,
-        },
-      ],
+      options: [{ default: 'array-simple' }],
     },
     {
       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>;
+interface FooInterface {
+  '.bar': { baz: string[] };
 }
       `,
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 4,
-          column: 8,
-        },
-      ],
+      options: [{ default: 'array-simple' }],
+    },
+    {
+      code: 'let yy: number[][] = [[4, 5], [6]];',
+      options: [{ default: 'array' }],
+    },
+    {
+      code: "let ya = [[1, '2']] as [number, string][];",
+      options: [{ default: 'array' }],
     },
     {
       code: `
@@ -1774,59 +1861,27 @@ 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' }],
+    },
+    {
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
 }
       `,
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
-          column: 27,
-        },
-      ],
+      options: [{ default: 'array' }],
     },
     {
       code: 'let barVar: ((c: number) => number)[];',
-      output: 'let barVar: Array<(c: number) => number>;',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 13,
-        },
-      ],
+      options: [{ default: 'array' }],
     },
     {
       code: 'type barUnion = (string | number | boolean)[];',
-      output: 'type barUnion = Array<string | number | boolean>;',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 17,
-        },
-      ],
+      options: [{ default: 'array' }],
     },
     {
       code: 'type barIntersection = (string & number)[];',
-      output: 'type barIntersection = Array<string & number>;',
-      options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 24,
-        },
-      ],
+      options: [{ default: 'array' }],
     },
     {
       code: `
@@ -1834,125 +1889,71 @@ interface FooInterface {
   '.bar': { baz: string[] };
 }
       `,
-      output: `
-interface FooInterface {
-  '.bar': { baz: Array<string> };
+      options: [{ default: 'array' }],
+    },
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
+      options: [{ default: 'array' }],
+    },
+    {
+      code: 'let xx: Array<Array<number>> = [[1, 2], [3]];',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'type Arr<T> = Array<T>;',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
 }
       `,
       options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          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;',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 28,
-        },
-      ],
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
+      options: [{ default: 'generic' }],
     },
     {
-      // 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: 'let fooVar: Array<(c: number) => number>;',
       options: [{ default: 'generic' }],
-      errors: [
-        {
-          messageId: 'errorStringGeneric',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 28,
-        },
-      ],
     },
     {
-      code: 'type Foo = ReadonlyArray<object>[];',
-      output: 'type Foo = (readonly object[])[];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'object',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      code: 'type fooUnion = Array<string | number | boolean>;',
+      options: [{ default: 'generic' }],
     },
     {
-      code: 'const foo: Array<new (...args: any[]) => void> = [];',
-      output: 'const foo: (new (...args: any[]) => void)[] = [];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          column: 12,
-        },
-      ],
+      code: 'type fooIntersection = Array<string & number>;',
+      options: [{ default: 'generic' }],
     },
     {
-      code: 'const foo: ReadonlyArray<new (...args: any[]) => void> = [];',
-      output: 'const foo: readonly (new (...args: any[]) => void)[] = [];',
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArray',
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      options: [{ default: 'generic' }],
     },
+
+    // nested readonly
     {
-      code: "const x: Readonly<string[]> = ['a', 'b'];",
-      output: "const x: readonly string[] = ['a', 'b'];",
-      options: [{ default: 'array' }],
-      errors: [
-        {
-          messageId: 'errorStringArrayReadonly',
-          data: {
-            className: 'Readonly',
-            readonlyPrefix: 'readonly ',
-            type: 'string[]',
-          },
-        },
-      ],
+      code: 'let a: ReadonlyArray<number[]> = [[]];',
+      options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'declare function foo<E extends Readonly<string[]>>(extra: E): E;',
-      output: 'declare function foo<E extends readonly string[]>(extra: E): E;',
-      options: [{ default: 'array-simple' }],
-      errors: [
-        {
-          messageId: 'errorStringArraySimpleReadonly',
-          data: {
-            className: 'Readonly',
-            readonlyPrefix: 'readonly ',
-            type: 'string[]',
-          },
-        },
-      ],
+      code: 'let a: readonly Array<number>[] = [[]];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Readonly = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: "const x: Readonly<string> = 'a';",
+      options: [{ default: 'array' }],
     },
   ],
 });
@@ -1975,13 +1976,13 @@ describe('array-type (nested)', () => {
         const result = linter.verifyAndFix(
           code,
           {
+            parser: '@typescript-eslint/parser',
             rules: {
               'array-type': [
                 2,
                 { default: defaultOption, readonly: readonlyOption },
               ],
             },
-            parser: '@typescript-eslint/parser',
           },
           {
             fix: true,
diff --git a/packages/eslint-plugin/tests/rules/await-thenable.test.ts b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
index ebb8c6ef9537..3779ff6385fe 100644
--- a/packages/eslint-plugin/tests/rules/await-thenable.test.ts
+++ b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
@@ -9,13 +9,193 @@ const messageId = 'await';
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('await-thenable', rule, {
+  invalid: [
+    {
+      code: 'await 0;',
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: ' 0;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "await 'value';",
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: " 'value';",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "async () => await (Math.random() > 0.5 ? '' : 0);",
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: "async () =>  (Math.random() > 0.5 ? '' : 0);",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: noFormat`async () => await(Math.random() > 0.5 ? '' : 0);`,
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: "async () => (Math.random() > 0.5 ? '' : 0);",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+class NonPromise extends Array {}
+await new NonPromise();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+class NonPromise extends Array {}
+ new NonPromise();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  class IncorrectThenable {
+    then() {}
+  }
+  const thenable = new IncorrectThenable();
+
+  await thenable;
+}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+async function test() {
+  class IncorrectThenable {
+    then() {}
+  }
+  const thenable = new IncorrectThenable();
+
+   thenable;
+}
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const callback: (() => void) | undefined;
+await callback?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const callback: (() => void) | undefined;
+ callback?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const obj: { a?: { b?: () => void } };
+await obj.a?.b?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const obj: { a?: { b?: () => void } };
+ obj.a?.b?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const obj: { a: { b: { c?: () => void } } } | undefined;
+await obj?.a.b.c?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const obj: { a: { b: { c?: () => void } } } | undefined;
+ obj?.a.b.c?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+  ],
+
   valid: [
     `
 async function test() {
@@ -199,184 +379,4 @@ const doSomething = async (
 };
     `,
   ],
-
-  invalid: [
-    {
-      code: 'await 0;',
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: ' 0;',
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: "await 'value';",
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: " 'value';",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: "async () => await (Math.random() > 0.5 ? '' : 0);",
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: "async () =>  (Math.random() > 0.5 ? '' : 0);",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: noFormat`async () => await(Math.random() > 0.5 ? '' : 0);`,
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: "async () => (Math.random() > 0.5 ? '' : 0);",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class NonPromise extends Array {}
-await new NonPromise();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-class NonPromise extends Array {}
- new NonPromise();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  class IncorrectThenable {
-    then() {}
-  }
-  const thenable = new IncorrectThenable();
-
-  await thenable;
-}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-async function test() {
-  class IncorrectThenable {
-    then() {}
-  }
-  const thenable = new IncorrectThenable();
-
-   thenable;
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const callback: (() => void) | undefined;
-await callback?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const callback: (() => void) | undefined;
- callback?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const obj: { a?: { b?: () => void } };
-await obj.a?.b?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const obj: { a?: { b?: () => void } };
- obj.a?.b?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const obj: { a: { b: { c?: () => void } } } | undefined;
-await obj?.a.b.c?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const obj: { a: { b: { c?: () => void } } } | undefined;
- obj?.a.b.c?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-  ],
 });
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 8ac62dbb40cb..5cc5e3d5dfa3 100644
--- a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
@@ -5,196 +5,93 @@ import rule from '../../src/rules/ban-ts-comment';
 const ruleTester = new RuleTester();
 
 ruleTester.run('ts-expect-error', rule, {
-  valid: [
-    '// just a comment containing @ts-expect-error somewhere',
-    `
-/*
- @ts-expect-error running with long description in a block
-*/
-    `,
-    `
-/* @ts-expect-error not on the last line
- */
-    `,
-    `
-/**
- * @ts-expect-error not on the last line
- */
-    `,
-    `
-/* not on the last line
- * @ts-expect-error
- */
-    `,
-    `
-/* @ts-expect-error
- * not on the last line */
-    `,
-    {
-      code: '// @ts-expect-error',
-      options: [{ 'ts-expect-error': false }],
-    },
-    {
-      code: '// @ts-expect-error here is why the error is expected',
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: `
-/*
- * @ts-expect-error here is why the error is expected */
-      `,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: '// @ts-expect-error exactly 21 characters',
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-          minimumDescriptionLength: 21,
-        },
-      ],
-    },
-    {
-      code: `
-/*
- * @ts-expect-error exactly 21 characters*/
-      `,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-          minimumDescriptionLength: 21,
-        },
-      ],
-    },
-    {
-      code: '// @ts-expect-error: TS1234 because xyz',
-      options: [
-        {
-          'ts-expect-error': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 10,
-        },
-      ],
-    },
-    {
-      code: `
-/*
- * @ts-expect-error: TS1234 because xyz */
-      `,
-      options: [
-        {
-          'ts-expect-error': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 10,
-        },
-      ],
-    },
-    {
-      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
-    },
-  ],
   invalid: [
     {
       code: '// @ts-expect-error',
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: '/* @ts-expect-error */',
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: `
 /*
 @ts-expect-error */
       `,
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 2,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: `
 /** on the last line
   @ts-expect-error */
       `,
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 2,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: `
 /** on the last line
  * @ts-expect-error */
       `,
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 2,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: `
 /**
  * @ts-expect-error: TODO */
       `,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-          minimumDescriptionLength: 10,
-        },
-      ],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 10 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 2,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
@@ -203,20 +100,20 @@ ruleTester.run('ts-expect-error', rule, {
 /**
  * @ts-expect-error: TS1234 because xyz */
       `,
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'expect-error', minimumDescriptionLength: 25 },
+          line: 2,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
       options: [
         {
+          minimumDescriptionLength: 25,
           'ts-expect-error': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
-          minimumDescriptionLength: 25,
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'expect-error', minimumDescriptionLength: 25 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 2,
-          column: 1,
         },
       ],
     },
@@ -225,6 +122,14 @@ ruleTester.run('ts-expect-error', rule, {
 /**
  * @ts-expect-error: TS1234 */
       `,
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
+          line: 2,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
       options: [
         {
           'ts-expect-error': {
@@ -232,20 +137,20 @@ ruleTester.run('ts-expect-error', rule, {
           },
         },
       ],
-      errors: [
-        {
-          data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 2,
-          column: 1,
-        },
-      ],
     },
     {
       code: `
 /**
  * @ts-expect-error    : TS1234 */
       `,
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
+          line: 2,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
       options: [
         {
           'ts-expect-error': {
@@ -253,69 +158,61 @@ ruleTester.run('ts-expect-error', rule, {
           },
         },
       ],
-      errors: [
-        {
-          data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 2,
-          column: 1,
-        },
-      ],
     },
     {
       code: `
 /**
  * @ts-expect-error 👨‍👩‍👧‍👦 */
       `,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 2,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [
+        {
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
     {
       code: '/** @ts-expect-error */',
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: '// @ts-expect-error: Suppress next line',
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: '/////@ts-expect-error: Suppress next line',
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: `
@@ -324,88 +221,78 @@ if (false) {
   console.log('hello');
 }
       `,
-      options: [{ 'ts-expect-error': true }],
       errors: [
         {
+          column: 3,
           data: { directive: 'expect-error' },
-          messageId: 'tsDirectiveComment',
           line: 3,
-          column: 3,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-expect-error': true }],
     },
     {
       code: '// @ts-expect-error',
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-    },
-    {
-      code: '// @ts-expect-error: TODO',
       options: [
         {
           'ts-expect-error': 'allow-with-description',
-          minimumDescriptionLength: 10,
         },
       ],
+    },
+    {
+      code: '// @ts-expect-error: TODO',
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 10 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-    },
-    {
-      code: '// @ts-expect-error: TS1234 because xyz',
       options: [
         {
-          'ts-expect-error': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 25,
+          minimumDescriptionLength: 10,
+          'ts-expect-error': 'allow-with-description',
         },
       ],
+    },
+    {
+      code: '// @ts-expect-error: TS1234 because xyz',
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 25 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-    },
-    {
-      code: '// @ts-expect-error: TS1234',
       options: [
         {
+          minimumDescriptionLength: 25,
           'ts-expect-error': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
+    },
+    {
+      code: '// @ts-expect-error: TS1234',
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
         },
       ],
-    },
-    {
-      code: noFormat`// @ts-expect-error    : TS1234 because xyz`,
       options: [
         {
           'ts-expect-error': {
@@ -413,70 +300,56 @@ if (false) {
           },
         },
       ],
+    },
+    {
+      code: noFormat`// @ts-expect-error    : TS1234 because xyz`,
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
         },
       ],
-    },
-    {
-      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦`,
       options: [
         {
-          'ts-expect-error': 'allow-with-description',
+          'ts-expect-error': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
         },
       ],
+    },
+    {
+      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦`,
       errors: [
         {
+          column: 1,
           data: { directive: 'expect-error', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-    },
-  ],
-});
-
-ruleTester.run('ts-ignore', rule, {
-  valid: [
-    '// just a comment containing @ts-ignore somewhere',
-    {
-      code: '// @ts-ignore',
-      options: [{ 'ts-ignore': false }],
-    },
-    {
-      code: '// @ts-ignore I think that I am exempted from any need to follow the rules!',
-      options: [{ 'ts-ignore': 'allow-with-description' }],
-    },
-    {
-      code: `
-/*
- @ts-ignore running with long description in a block
-*/
-      `,
       options: [
         {
-          'ts-ignore': 'allow-with-description',
-          minimumDescriptionLength: 21,
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
+  ],
+  valid: [
+    '// just a comment containing @ts-expect-error somewhere',
     `
 /*
- @ts-ignore
+ @ts-expect-error running with long description in a block
 */
     `,
     `
-/* @ts-ignore not on the last line
+/* @ts-expect-error not on the last line
  */
     `,
     `
 /**
- * @ts-ignore not on the last line
+ * @ts-expect-error not on the last line
  */
     `,
     `
@@ -485,84 +358,98 @@ ruleTester.run('ts-ignore', rule, {
  */
     `,
     `
-/* @ts-ignore
+/* @ts-expect-error
  * not on the last line */
     `,
     {
-      code: '// @ts-ignore: TS1234 because xyz',
-      options: [
-        {
-          'ts-ignore': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 10,
-        },
-      ],
+      code: '// @ts-expect-error',
+      options: [{ 'ts-expect-error': false }],
     },
     {
-      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
+      code: '// @ts-expect-error here is why the error is expected',
       options: [
         {
-          'ts-ignore': 'allow-with-description',
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
     {
       code: `
 /*
- * @ts-ignore here is why the error is expected */
+ * @ts-expect-error here is why the error is expected */
       `,
       options: [
         {
-          'ts-ignore': 'allow-with-description',
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
     {
-      code: '// @ts-ignore exactly 21 characters',
+      code: '// @ts-expect-error exactly 21 characters',
       options: [
         {
-          'ts-ignore': 'allow-with-description',
           minimumDescriptionLength: 21,
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
     {
       code: `
 /*
- * @ts-ignore exactly 21 characters*/
+ * @ts-expect-error exactly 21 characters*/
       `,
       options: [
         {
-          'ts-ignore': 'allow-with-description',
           minimumDescriptionLength: 21,
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: '// @ts-expect-error: TS1234 because xyz',
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
         },
       ],
     },
     {
       code: `
 /*
- * @ts-ignore: TS1234 because xyz */
+ * @ts-expect-error: TS1234 because xyz */
       `,
       options: [
         {
-          'ts-ignore': {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
-          minimumDescriptionLength: 10,
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
+      options: [
+        {
+          'ts-expect-error': 'allow-with-description',
         },
       ],
     },
   ],
+});
+
+ruleTester.run('ts-ignore', rule, {
   invalid: [
     {
       code: '// @ts-ignore',
-      options: [{ 'ts-ignore': true, 'ts-expect-error': true }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -571,17 +458,15 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-expect-error': true, 'ts-ignore': true }],
     },
     {
       code: '// @ts-ignore',
-      options: [
-        { 'ts-ignore': true, 'ts-expect-error': 'allow-with-description' },
-      ],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -590,14 +475,17 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [
+        { 'ts-expect-error': 'allow-with-description', 'ts-ignore': true },
+      ],
     },
     {
       code: '// @ts-ignore',
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -609,12 +497,11 @@ ruleTester.run('ts-ignore', rule, {
     },
     {
       code: '/* @ts-ignore */',
-      options: [{ 'ts-ignore': true }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -623,18 +510,18 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-ignore': true }],
     },
     {
       code: `
 /*
  @ts-ignore */
       `,
-      options: [{ 'ts-ignore': true }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -646,18 +533,18 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-ignore': true }],
     },
     {
       code: `
 /** on the last line
   @ts-ignore */
       `,
-      options: [{ 'ts-ignore': true }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -669,18 +556,18 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-ignore': true }],
     },
     {
       code: `
 /** on the last line
  * @ts-ignore */
       `,
-      options: [{ 'ts-ignore': true }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -692,15 +579,15 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-ignore': true }],
     },
     {
       code: '/** @ts-ignore */',
-      options: [{ 'ts-ignore': true, 'ts-expect-error': false }],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -709,23 +596,18 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [{ 'ts-expect-error': false, 'ts-ignore': true }],
     },
     {
       code: `
 /**
  * @ts-ignore: TODO */
       `,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-          minimumDescriptionLength: 10,
-        },
-      ],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -737,25 +619,23 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
     },
     {
       code: `
 /**
  * @ts-ignore: TS1234 because xyz */
       `,
-      options: [
-        {
-          'ts-expect-error': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 25,
-        },
-      ],
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -767,14 +647,22 @@ ruleTester.run('ts-ignore', rule, {
           ],
         },
       ],
+      options: [
+        {
+          minimumDescriptionLength: 25,
+          'ts-expect-error': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
     },
     {
       code: '// @ts-ignore: Suppress next line',
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -788,9 +676,9 @@ ruleTester.run('ts-ignore', rule, {
       code: '/////@ts-ignore: Suppress next line',
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -809,9 +697,9 @@ if (false) {
       `,
       errors: [
         {
-          messageId: 'tsIgnoreInsteadOfExpectError',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'tsIgnoreInsteadOfExpectError',
           suggestions: [
             {
               messageId: 'replaceTsIgnoreWithTsExpectError',
@@ -828,61 +716,69 @@ if (false) {
     },
     {
       code: '// @ts-ignore',
-      options: [{ 'ts-ignore': 'allow-with-description' }],
       errors: [
         {
+          column: 1,
           data: { directive: 'ignore', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
+      options: [{ 'ts-ignore': 'allow-with-description' }],
     },
     {
       code: noFormat`// @ts-ignore         `,
-      options: [{ 'ts-ignore': 'allow-with-description' }],
       errors: [
         {
+          column: 1,
           data: { directive: 'ignore', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
+      options: [{ 'ts-ignore': 'allow-with-description' }],
     },
     {
       code: '// @ts-ignore    .',
-      options: [{ 'ts-ignore': 'allow-with-description' }],
       errors: [
         {
+          column: 1,
           data: { directive: 'ignore', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
+      options: [{ 'ts-ignore': 'allow-with-description' }],
     },
     {
       code: '// @ts-ignore: TS1234 because xyz',
-      options: [
+      errors: [
         {
-          'ts-ignore': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 25,
+          column: 1,
+          data: { directive: 'ignore', minimumDescriptionLength: 25 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-      errors: [
+      options: [
         {
-          data: { directive: 'ignore', minimumDescriptionLength: 25 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
-          column: 1,
+          minimumDescriptionLength: 25,
+          'ts-ignore': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
         },
       ],
     },
     {
       code: '// @ts-ignore: TS1234',
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'ignore', format: '^: TS\\d+ because .+$' },
+          line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
       options: [
         {
           'ts-ignore': {
@@ -890,53 +786,292 @@ if (false) {
           },
         },
       ],
+    },
+    {
+      code: noFormat`// @ts-ignore    : TS1234 because xyz`,
       errors: [
         {
+          column: 1,
           data: { directive: 'ignore', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
           line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
+      options: [
+        {
+          'ts-ignore': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦`,
+      errors: [
+        {
           column: 1,
+          data: { directive: 'ignore', minimumDescriptionLength: 3 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [
+        {
+          'ts-ignore': 'allow-with-description',
         },
       ],
     },
+  ],
+  valid: [
+    '// just a comment containing @ts-ignore somewhere',
     {
-      code: noFormat`// @ts-ignore    : TS1234 because xyz`,
+      code: '// @ts-ignore',
+      options: [{ 'ts-ignore': false }],
+    },
+    {
+      code: '// @ts-ignore I think that I am exempted from any need to follow the rules!',
+      options: [{ 'ts-ignore': 'allow-with-description' }],
+    },
+    {
+      code: `
+/*
+ @ts-ignore running with long description in a block
+*/
+      `,
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
+    `
+/*
+ @ts-ignore
+*/
+    `,
+    `
+/* @ts-ignore not on the last line
+ */
+    `,
+    `
+/**
+ * @ts-ignore not on the last line
+ */
+    `,
+    `
+/* not on the last line
+ * @ts-expect-error
+ */
+    `,
+    `
+/* @ts-ignore
+ * not on the last line */
+    `,
+    {
+      code: '// @ts-ignore: TS1234 because xyz',
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-ignore': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
+      options: [
+        {
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-ignore here is why the error is expected */
+      `,
+      options: [
+        {
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: '// @ts-ignore exactly 21 characters',
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-ignore exactly 21 characters*/
+      `,
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-ignore: TS1234 because xyz */
+      `,
       options: [
         {
+          minimumDescriptionLength: 10,
           'ts-ignore': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
+    },
+  ],
+});
+
+ruleTester.run('ts-nocheck', rule, {
+  invalid: [
+    {
+      code: '// @ts-nocheck',
       errors: [
         {
-          data: { directive: 'ignore', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+          column: 1,
+          data: { directive: 'nocheck' },
+          line: 1,
+          messageId: 'tsDirectiveComment',
+        },
+      ],
+      options: [{ 'ts-nocheck': true }],
+    },
+    {
+      code: '// @ts-nocheck',
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'nocheck' },
           line: 1,
+          messageId: 'tsDirectiveComment',
+        },
+      ],
+    },
+    {
+      code: '// @ts-nocheck: Suppress next line',
+      errors: [
+        {
           column: 1,
+          data: { directive: 'nocheck' },
+          line: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
     },
     {
-      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦`,
-      options: [
+      code: `
+if (false) {
+  // @ts-nocheck: Unreachable code error
+  console.log('hello');
+}
+      `,
+      errors: [
         {
-          'ts-ignore': 'allow-with-description',
+          column: 3,
+          data: { directive: 'nocheck' },
+          line: 3,
+          messageId: 'tsDirectiveComment',
         },
       ],
+    },
+    {
+      code: '// @ts-nocheck',
       errors: [
         {
-          data: { directive: 'ignore', minimumDescriptionLength: 3 },
+          column: 1,
+          data: { directive: 'nocheck', minimumDescriptionLength: 3 },
+          line: 1,
           messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [{ 'ts-nocheck': 'allow-with-description' }],
+    },
+    {
+      code: '// @ts-nocheck: TS1234 because xyz',
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'nocheck', minimumDescriptionLength: 25 },
           line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [
+        {
+          minimumDescriptionLength: 25,
+          'ts-nocheck': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: '// @ts-nocheck: TS1234',
+      errors: [
+        {
           column: 1,
+          data: { directive: 'nocheck', format: '^: TS\\d+ because .+$' },
+          line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
+      options: [
+        {
+          'ts-nocheck': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-nocheck    : TS1234 because xyz`,
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'nocheck', format: '^: TS\\d+ because .+$' },
+          line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+        },
+      ],
+      options: [
+        {
+          'ts-nocheck': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-nocheck 👨‍👩‍👧‍👦`,
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'nocheck', minimumDescriptionLength: 3 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
+      options: [
+        {
+          'ts-nocheck': 'allow-with-description',
         },
       ],
     },
   ],
-});
-
-ruleTester.run('ts-nocheck', rule, {
   valid: [
     '// just a comment containing @ts-nocheck somewhere',
     {
@@ -955,8 +1090,8 @@ ruleTester.run('ts-nocheck', rule, {
       `,
       options: [
         {
-          'ts-nocheck': 'allow-with-description',
           minimumDescriptionLength: 21,
+          'ts-nocheck': 'allow-with-description',
         },
       ],
     },
@@ -964,10 +1099,10 @@ ruleTester.run('ts-nocheck', rule, {
       code: '// @ts-nocheck: TS1234 because xyz',
       options: [
         {
+          minimumDescriptionLength: 10,
           'ts-nocheck': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
-          minimumDescriptionLength: 10,
         },
       ],
     },
@@ -993,144 +1128,135 @@ ruleTester.run('ts-nocheck', rule, {
     '/** @ts-nocheck */',
     '/* @ts-nocheck */',
   ],
+});
+
+ruleTester.run('ts-check', rule, {
   invalid: [
     {
-      code: '// @ts-nocheck',
-      options: [{ 'ts-nocheck': true }],
+      code: '// @ts-check',
       errors: [
         {
-          data: { directive: 'nocheck' },
-          messageId: 'tsDirectiveComment',
-          line: 1,
           column: 1,
-        },
-      ],
-    },
-    {
-      code: '// @ts-nocheck',
-      errors: [
-        {
-          data: { directive: 'nocheck' },
-          messageId: 'tsDirectiveComment',
+          data: { directive: 'check' },
           line: 1,
-          column: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-check': true }],
     },
     {
-      code: '// @ts-nocheck: Suppress next line',
+      code: '// @ts-check: Suppress next line',
       errors: [
         {
-          data: { directive: 'nocheck' },
-          messageId: 'tsDirectiveComment',
-          line: 1,
           column: 1,
+          data: { directive: 'check' },
+          line: 1,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-check': true }],
     },
     {
       code: `
 if (false) {
-  // @ts-nocheck: Unreachable code error
+  // @ts-check: Unreachable code error
   console.log('hello');
 }
       `,
       errors: [
         {
-          data: { directive: 'nocheck' },
-          messageId: 'tsDirectiveComment',
-          line: 3,
           column: 3,
+          data: { directive: 'check' },
+          line: 3,
+          messageId: 'tsDirectiveComment',
         },
       ],
+      options: [{ 'ts-check': true }],
     },
     {
-      code: '// @ts-nocheck',
-      options: [{ 'ts-nocheck': 'allow-with-description' }],
+      code: '// @ts-check',
       errors: [
         {
-          data: { directive: 'nocheck', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
           column: 1,
+          data: { directive: 'check', minimumDescriptionLength: 3 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
+      options: [{ 'ts-check': 'allow-with-description' }],
     },
     {
-      code: '// @ts-nocheck: TS1234 because xyz',
+      code: '// @ts-check: TS1234 because xyz',
+      errors: [
+        {
+          column: 1,
+          data: { directive: 'check', minimumDescriptionLength: 25 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
+        },
+      ],
       options: [
         {
-          'ts-nocheck': {
+          minimumDescriptionLength: 25,
+          'ts-check': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
-          minimumDescriptionLength: 25,
         },
       ],
+    },
+    {
+      code: '// @ts-check: TS1234',
       errors: [
         {
-          data: { directive: 'nocheck', minimumDescriptionLength: 25 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
           column: 1,
+          data: { directive: 'check', format: '^: TS\\d+ because .+$' },
+          line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
         },
       ],
-    },
-    {
-      code: '// @ts-nocheck: TS1234',
       options: [
         {
-          'ts-nocheck': {
+          'ts-check': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
+    },
+    {
+      code: noFormat`// @ts-check    : TS1234 because xyz`,
       errors: [
         {
-          data: { directive: 'nocheck', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 1,
           column: 1,
+          data: { directive: 'check', format: '^: TS\\d+ because .+$' },
+          line: 1,
+          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
         },
       ],
-    },
-    {
-      code: noFormat`// @ts-nocheck    : TS1234 because xyz`,
       options: [
         {
-          'ts-nocheck': {
+          'ts-check': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
+    },
+    {
+      code: noFormat`// @ts-check 👨‍👩‍👧‍👦`,
       errors: [
         {
-          data: { directive: 'nocheck', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 1,
           column: 1,
+          data: { directive: 'check', minimumDescriptionLength: 3 },
+          line: 1,
+          messageId: 'tsDirectiveCommentRequiresDescription',
         },
       ],
-    },
-    {
-      code: noFormat`// @ts-nocheck 👨‍👩‍👧‍👦`,
       options: [
         {
-          'ts-nocheck': 'allow-with-description',
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'nocheck', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
-          column: 1,
+          'ts-check': 'allow-with-description',
         },
       ],
     },
   ],
-});
-
-ruleTester.run('ts-check', rule, {
   valid: [
     '// just a comment containing @ts-check somewhere',
     `
@@ -1145,17 +1271,17 @@ ruleTester.run('ts-check', rule, {
     {
       code: '// @ts-check with a description and also with a no-op // @ts-ignore',
       options: [
-        { 'ts-check': 'allow-with-description', minimumDescriptionLength: 3 },
+        { minimumDescriptionLength: 3, 'ts-check': 'allow-with-description' },
       ],
     },
     {
       code: '// @ts-check: TS1234 because xyz',
       options: [
         {
+          minimumDescriptionLength: 10,
           'ts-check': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
-          minimumDescriptionLength: 10,
         },
       ],
     },
@@ -1196,130 +1322,4 @@ ruleTester.run('ts-check', rule, {
       options: [{ 'ts-check': true }],
     },
   ],
-  invalid: [
-    {
-      code: '// @ts-check',
-      options: [{ 'ts-check': true }],
-      errors: [
-        {
-          data: { directive: 'check' },
-          messageId: 'tsDirectiveComment',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '// @ts-check: Suppress next line',
-      options: [{ 'ts-check': true }],
-      errors: [
-        {
-          data: { directive: 'check' },
-          messageId: 'tsDirectiveComment',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: `
-if (false) {
-  // @ts-check: Unreachable code error
-  console.log('hello');
-}
-      `,
-      options: [{ 'ts-check': true }],
-      errors: [
-        {
-          data: { directive: 'check' },
-          messageId: 'tsDirectiveComment',
-          line: 3,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: '// @ts-check',
-      options: [{ 'ts-check': 'allow-with-description' }],
-      errors: [
-        {
-          data: { directive: 'check', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '// @ts-check: TS1234 because xyz',
-      options: [
-        {
-          'ts-check': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-          minimumDescriptionLength: 25,
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'check', minimumDescriptionLength: 25 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '// @ts-check: TS1234',
-      options: [
-        {
-          'ts-check': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'check', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: noFormat`// @ts-check    : TS1234 because xyz`,
-      options: [
-        {
-          'ts-check': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'check', format: '^: TS\\d+ because .+$' },
-          messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: noFormat`// @ts-check 👨‍👩‍👧‍👦`,
-      options: [
-        {
-          'ts-check': 'allow-with-description',
-        },
-      ],
-      errors: [
-        {
-          data: { directive: 'check', minimumDescriptionLength: 3 },
-          messageId: 'tsDirectiveCommentRequiresDescription',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts b/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
index 062fcd531988..fdc00a705308 100644
--- a/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
@@ -4,10 +4,10 @@ import rule from '../../src/rules/ban-tslint-comment';
 
 interface Testable {
   code: string;
-  text?: string;
   column?: number;
   line?: number;
   output?: string;
+  text?: string;
 }
 
 const PALANTIR_EXAMPLES: Testable[] = [
@@ -22,9 +22,9 @@ const PALANTIR_EXAMPLES: Testable[] = [
   { code: '// tslint:disable-next-line' }, // Disables all rules for the following line
   {
     code: 'someCode(); // tslint:disable-line',
-    text: '// tslint:disable-line',
     column: 13,
     output: 'someCode();',
+    text: '// tslint:disable-line',
   }, // Disables all rules for the current line
   {
     code: '// tslint:disable-next-line:rule1 rule2 rule3...',
@@ -38,17 +38,31 @@ const MORE_EXAMPLES: Testable[] = [
 // tslint:disable-line
 console.log(woah);
 `,
+    line: 2,
     output: `const woah = doSomeStuff();
 console.log(woah);
 `,
     text: '// tslint:disable-line',
-    line: 2,
   },
 ]
 
 const ruleTester = new RuleTester();
 
 ruleTester.run('ban-tslint-comment', rule, {
+  invalid: [...PALANTIR_EXAMPLES, ...MORE_EXAMPLES].map(
+    ({ code, column, line, output, text }) => ({
+      code,
+      errors: [
+        {
+          column: column ?? 1,
+          data: { text: text ?? code },
+          line: line ?? 1,
+          messageId: 'commentDetected' as const,
+        },
+      ],
+      output: output ?? '',
+    }),
+  ),
   valid: [
     {
       code: 'let a: readonly any[] = [];',
@@ -66,18 +80,4 @@ ruleTester.run('ban-tslint-comment', rule, {
       code: '/* another comment that mentions tslint */',
     },
   ],
-  invalid: [...PALANTIR_EXAMPLES, ...MORE_EXAMPLES].map(
-    ({ code, column, line, output, text }) => ({
-      code,
-      output: output ?? '',
-      errors: [
-        {
-          column: column ?? 1,
-          line: line ?? 1,
-          data: { text: text ?? code },
-          messageId: 'commentDetected' as const,
-        },
-      ],
-    }),
-  ),
 });
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 902274292572..5564a2ce7719 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
@@ -5,458 +5,358 @@ import rule from '../../src/rules/class-literal-property-style';
 const ruleTester = new RuleTester();
 
 ruleTester.run('class-literal-property-style', rule, {
-  valid: [
-    `
+  invalid: [
+    {
+      code: `
 class Mx {
-  declare readonly p1 = 1;
+  get p1() {
+    return 'hello world';
+  }
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 7,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
 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')};
-        \`;
-      }
-    `,
-    `
-      class Mx {
-        set p1(val) {}
-        get p1() {
-          return '';
-        }
-      }
-    `,
-    `
-      let p1 = 'p1';
-      class Mx {
-        set [p1](val) {}
-        get [p1]() {
-          return '';
-        }
-      }
-    `,
-    `
-      let p1 = 'p1';
-      class Mx {
-        set [/* before set */ p1 /* after set */](val) {}
-        get [/* before get */ p1 /* after get */]() {
-          return '';
-        }
-      }
-    `,
-    `
-      class Mx {
-        set ['foo'](val) {}
-        get foo() {
-          return '';
-        }
-        set bar(val) {}
-        get ['bar']() {
-          return '';
-        }
-        set ['baz'](val) {}
-        get baz() {
-          return '';
-        }
-      }
-    `,
-    {
-      code: `
-        class Mx {
-          public get myButton() {
-            return styled.button\`
-              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
-            \`;
-          }
-        }
       `,
-      options: ['fields'],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
 class Mx {
-  public declare readonly foo = 1;
+  get p1() {
+    return \`hello world\`;
+  }
 }
       `,
-      options: ['getters'],
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 7,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
 class Mx {
-  get p1() {
-    return 'hello world';
-  }
+  readonly p1 = \`hello world\`;
 }
       `,
-      options: ['getters'],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
 class Mx {
-  p1 = 'hello world';
+  static get p1() {
+    return 'hello world';
+  }
 }
       `,
-      options: ['getters'],
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 14,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
 class Mx {
-  p1: string;
+  static readonly p1 = 'hello world';
 }
       `,
-      options: ['getters'],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
 class Mx {
-  readonly p1 = [1, 2, 3];
+  public static get foo() {
+    return 1;
+  }
 }
       `,
-      options: ['getters'],
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 21,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
 class Mx {
-  static p1: string;
+  public static readonly foo = 1;
 }
       `,
-      options: ['getters'],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
 class Mx {
-  static get p1() {
-    return 'hello world';
+  public get [myValue]() {
+    return 'a literal value';
   }
 }
       `,
-      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'],
-    },
-    {
-      code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            this.foo = foo;
-          }
-        }
+      errors: [
+        {
+          column: 15,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
+class Mx {
+  public readonly [myValue] = 'a literal value';
+}
       `,
-      options: ['getters'],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            this['foo'] = foo;
-          }
-        }
+class Mx {
+  public get [myValue]() {
+    return 12345n;
+  }
+}
       `,
-      options: ['getters'],
-    },
-    {
-      code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            const bar = new (class {
-              private readonly foo: string = 'baz';
-              constructor() {
-                this.foo = 'qux';
-              }
-            })();
-            this['foo'] = foo;
-          }
-        }
+      errors: [
+        {
+          column: 15,
+          line: 3,
+          messageId: 'preferFieldStyle',
+          suggestions: [
+            {
+              messageId: 'preferFieldStyleSuggestion',
+              output: `
+class Mx {
+  public readonly [myValue] = 12345n;
+}
       `,
-      options: ['getters'],
+            },
+          ],
+        },
+      ],
     },
-  ],
-  invalid: [
     {
       code: `
 class Mx {
-  get p1() {
-    return 'hello world';
-  }
+  public readonly [myValue] = 'a literal value';
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 7,
+          column: 20,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  readonly p1 = 'hello world';
+  public get [myValue]() { return 'a literal value'; }
 }
       `,
             },
           ],
         },
       ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  get p1() {
-    return \`hello world\`;
-  }
+  readonly p1 = 'hello world';
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 7,
+          column: 12,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  readonly p1 = \`hello world\`;
+  get p1() { return 'hello world'; }
 }
       `,
             },
           ],
         },
       ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  static get p1() {
-    return 'hello world';
-  }
+  readonly p1 = \`hello world\`;
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 14,
+          column: 12,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  static readonly p1 = 'hello world';
+  get p1() { return \`hello world\`; }
 }
       `,
             },
           ],
         },
       ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  public static get foo() {
-    return 1;
-  }
+  static readonly p1 = 'hello world';
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 21,
+          column: 19,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  public static readonly foo = 1;
+  static get p1() { return 'hello world'; }
 }
       `,
             },
           ],
         },
       ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  public get [myValue]() {
-    return 'a literal value';
+  protected get p1() {
+    return 'hello world';
   }
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 15,
+          column: 17,
           line: 3,
+          messageId: 'preferFieldStyle',
           suggestions: [
             {
               messageId: 'preferFieldStyleSuggestion',
               output: `
 class Mx {
-  public readonly [myValue] = 'a literal value';
+  protected readonly p1 = 'hello world';
 }
       `,
             },
           ],
         },
       ],
+      options: ['fields'],
     },
     {
       code: `
 class Mx {
-  public get [myValue]() {
-    return 12345n;
-  }
+  protected readonly p1 = 'hello world';
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 15,
+          column: 22,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  public readonly [myValue] = 12345n;
+  protected get p1() { return 'hello world'; }
 }
       `,
             },
           ],
         },
       ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  public readonly [myValue] = 'a literal value';
+  public static get p1() {
+    return 'hello world';
+  }
 }
       `,
       errors: [
         {
-          messageId: 'preferGetterStyle',
-          column: 20,
+          column: 21,
           line: 3,
+          messageId: 'preferFieldStyle',
           suggestions: [
             {
-              messageId: 'preferGetterStyleSuggestion',
+              messageId: 'preferFieldStyleSuggestion',
               output: `
 class Mx {
-  public get [myValue]() { return 'a literal value'; }
+  public static readonly p1 = 'hello world';
 }
       `,
             },
           ],
         },
       ],
-      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  readonly p1 = 'hello world';
+  public static readonly p1 = 'hello world';
 }
       `,
       errors: [
         {
-          messageId: 'preferGetterStyle',
-          column: 12,
+          column: 26,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
               messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  get p1() { return 'hello world'; }
+  public static get p1() { return 'hello world'; }
 }
       `,
             },
@@ -468,45 +368,74 @@ class Mx {
     {
       code: `
 class Mx {
-  readonly p1 = \`hello world\`;
+  public get myValue() {
+    return gql\`
+      {
+        user(id: 5) {
+          firstName
+          lastName
+        }
+      }
+    \`;
+  }
 }
       `,
       errors: [
         {
-          messageId: 'preferGetterStyle',
-          column: 12,
+          column: 14,
           line: 3,
+          messageId: 'preferFieldStyle',
           suggestions: [
             {
-              messageId: 'preferGetterStyleSuggestion',
+              messageId: 'preferFieldStyleSuggestion',
               output: `
 class Mx {
-  get p1() { return \`hello world\`; }
+  public readonly myValue = gql\`
+      {
+        user(id: 5) {
+          firstName
+          lastName
+        }
+      }
+    \`;
 }
       `,
             },
           ],
         },
       ],
-      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  static readonly p1 = 'hello world';
+  public readonly myValue = gql\`
+    {
+      user(id: 5) {
+        firstName
+        lastName
+      }
+    }
+  \`;
 }
       `,
       errors: [
         {
-          messageId: 'preferGetterStyle',
           column: 19,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
               messageId: 'preferGetterStyleSuggestion',
               output: `
 class Mx {
-  static get p1() { return 'hello world'; }
+  public get myValue() { return gql\`
+    {
+      user(id: 5) {
+        firstName
+        lastName
+      }
+    }
+  \`; }
 }
       `,
             },
@@ -517,48 +446,82 @@ class Mx {
     },
     {
       code: `
-class Mx {
-  protected get p1() {
-    return 'hello world';
+class A {
+  private readonly foo: string = 'bar';
+  constructor(foo: string) {
+    const bar = new (class {
+      private readonly foo: string = 'baz';
+      constructor() {
+        this.foo = 'qux';
+      }
+    })();
   }
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 17,
+          column: 20,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
-class Mx {
-  protected readonly p1 = 'hello world';
+class A {
+  private get foo() { return 'bar'; }
+  constructor(foo: string) {
+    const bar = new (class {
+      private readonly foo: string = 'baz';
+      constructor() {
+        this.foo = 'qux';
+      }
+    })();
+  }
 }
       `,
             },
           ],
         },
       ],
-      options: ['fields'],
+      options: ['getters'],
     },
     {
       code: `
-class Mx {
-  protected readonly p1 = 'hello world';
+class A {
+  private readonly ['foo']: string = 'bar';
+  constructor(foo: string) {
+    const bar = new (class {
+      private readonly foo: string = 'baz';
+      constructor() {}
+    })();
+
+    if (bar) {
+      this.foo = 'baz';
+    }
+  }
 }
       `,
       errors: [
         {
+          column: 24,
+          line: 6,
           messageId: 'preferGetterStyle',
-          column: 22,
-          line: 3,
           suggestions: [
             {
               messageId: 'preferGetterStyleSuggestion',
               output: `
-class Mx {
-  protected get p1() { return 'hello world'; }
+class A {
+  private readonly ['foo']: string = 'bar';
+  constructor(foo: string) {
+    const bar = new (class {
+      private get foo() { return 'baz'; }
+      constructor() {}
+    })();
+
+    if (bar) {
+      this.foo = 'baz';
+    }
+  }
 }
       `,
             },
@@ -569,254 +532,291 @@ class Mx {
     },
     {
       code: `
-class Mx {
-  public static get p1() {
-    return 'hello world';
+class A {
+  private readonly foo: string = 'bar';
+  constructor(foo: string) {
+    function func() {
+      this.foo = 'aa';
+    }
   }
 }
       `,
       errors: [
         {
-          messageId: 'preferFieldStyle',
-          column: 21,
+          column: 20,
           line: 3,
+          messageId: 'preferGetterStyle',
           suggestions: [
             {
-              messageId: 'preferFieldStyleSuggestion',
+              messageId: 'preferGetterStyleSuggestion',
               output: `
+class A {
+  private get foo() { return 'bar'; }
+  constructor(foo: string) {
+    function func() {
+      this.foo = 'aa';
+    }
+  }
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: ['getters'],
+    },
+  ],
+  valid: [
+    `
 class Mx {
-  public static readonly p1 = 'hello world';
+  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')};
+        \`;
+      }
+    `,
+    `
+      class Mx {
+        set p1(val) {}
+        get p1() {
+          return '';
+        }
+      }
+    `,
+    `
+      let p1 = 'p1';
+      class Mx {
+        set [p1](val) {}
+        get [p1]() {
+          return '';
+        }
+      }
+    `,
+    `
+      let p1 = 'p1';
+      class Mx {
+        set [/* before set */ p1 /* after set */](val) {}
+        get [/* before get */ p1 /* after get */]() {
+          return '';
+        }
+      }
+    `,
+    `
+      class Mx {
+        set ['foo'](val) {}
+        get foo() {
+          return '';
+        }
+        set bar(val) {}
+        get ['bar']() {
+          return '';
+        }
+        set ['baz'](val) {}
+        get baz() {
+          return '';
+        }
+      }
+    `,
+    {
+      code: `
+        class Mx {
+          public get myButton() {
+            return styled.button\`
+              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+            \`;
+          }
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['fields'],
     },
     {
       code: `
 class Mx {
-  public static readonly p1 = 'hello world';
+  public declare readonly foo = 1;
 }
       `,
-      errors: [
-        {
-          messageId: 'preferGetterStyle',
-          column: 26,
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'preferGetterStyleSuggestion',
-              output: `
+      options: ['getters'],
+    },
+    {
+      code: `
 class Mx {
-  public static get p1() { return 'hello world'; }
+  get p1() {
+    return 'hello world';
+  }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: ['getters'],
     },
     {
       code: `
 class Mx {
-  public get myValue() {
-    return gql\`
-      {
-        user(id: 5) {
-          firstName
-          lastName
-        }
-      }
-    \`;
-  }
+  p1 = 'hello world';
 }
       `,
-      errors: [
-        {
-          messageId: 'preferFieldStyle',
-          column: 14,
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'preferFieldStyleSuggestion',
-              output: `
+      options: ['getters'],
+    },
+    {
+      code: `
 class Mx {
-  public readonly myValue = gql\`
-      {
-        user(id: 5) {
-          firstName
-          lastName
-        }
-      }
-    \`;
+  p1: string;
 }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['getters'],
     },
     {
       code: `
 class Mx {
-  public readonly myValue = gql\`
-    {
-      user(id: 5) {
-        firstName
-        lastName
-      }
-    }
-  \`;
+  readonly p1 = [1, 2, 3];
 }
       `,
-      errors: [
-        {
-          messageId: 'preferGetterStyle',
-          column: 19,
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'preferGetterStyleSuggestion',
-              output: `
-class Mx {
-  public get myValue() { return gql\`
+      options: ['getters'],
+    },
     {
-      user(id: 5) {
-        firstName
-        lastName
-      }
-    }
-  \`; }
+      code: `
+class Mx {
+  static p1: string;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: ['getters'],
     },
     {
       code: `
-class A {
-  private readonly foo: string = 'bar';
-  constructor(foo: string) {
-    const bar = new (class {
-      private readonly foo: string = 'baz';
-      constructor() {
-        this.foo = 'qux';
-      }
-    })();
+class Mx {
+  static get p1() {
+    return 'hello world';
   }
 }
       `,
       options: ['getters'],
-      errors: [
-        {
-          messageId: 'preferGetterStyle',
-          column: 20,
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'preferGetterStyleSuggestion',
-              output: `
-class A {
-  private get foo() { return 'bar'; }
-  constructor(foo: string) {
-    const bar = new (class {
-      private readonly foo: string = 'baz';
-      constructor() {
-        this.foo = 'qux';
-      }
-    })();
-  }
-}
+    },
+    {
+      code: `
+        class Mx {
+          public readonly myButton = styled.button\`
+            color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+          \`;
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['getters'],
     },
     {
       code: `
-class A {
-  private readonly ['foo']: string = 'bar';
-  constructor(foo: string) {
-    const bar = new (class {
-      private readonly foo: string = 'baz';
-      constructor() {}
-    })();
-
-    if (bar) {
-      this.foo = 'baz';
-    }
-  }
-}
+        class Mx {
+          public get myButton() {
+            return styled.button\`
+              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+            \`;
+          }
+        }
       `,
       options: ['getters'],
-      errors: [
-        {
-          messageId: 'preferGetterStyle',
-          column: 24,
-          line: 6,
-          suggestions: [
-            {
-              messageId: 'preferGetterStyleSuggestion',
-              output: `
-class A {
-  private readonly ['foo']: string = 'bar';
-  constructor(foo: string) {
-    const bar = new (class {
-      private get foo() { return 'baz'; }
-      constructor() {}
-    })();
-
-    if (bar) {
-      this.foo = 'baz';
-    }
-  }
-}
+    },
+    {
+      code: `
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            this.foo = foo;
+          }
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['getters'],
     },
     {
       code: `
-class A {
-  private readonly foo: string = 'bar';
-  constructor(foo: string) {
-    function func() {
-      this.foo = 'aa';
-    }
-  }
-}
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            this['foo'] = foo;
+          }
+        }
       `,
       options: ['getters'],
-      errors: [
-        {
-          messageId: 'preferGetterStyle',
-          column: 20,
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'preferGetterStyleSuggestion',
-              output: `
-class A {
-  private get foo() { return 'bar'; }
-  constructor(foo: string) {
-    function func() {
-      this.foo = 'aa';
-    }
-  }
-}
+    },
+    {
+      code: `
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            const bar = new (class {
+              private readonly foo: string = 'baz';
+              constructor() {
+                this.foo = 'qux';
+              }
+            })();
+            this['foo'] = foo;
+          }
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['getters'],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this-core.test.ts b/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this-core.test.ts
index 50f527082553..d0193efdc99d 100644
--- a/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this-core.test.ts
+++ b/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this-core.test.ts
@@ -8,440 +8,440 @@ import rule from '../../../src/rules/class-methods-use-this';
 const ruleTester = new RuleTester();
 
 ruleTester.run('class-methods-use-this', rule, {
-  valid: [
-    {
-      code: 'class A { constructor() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo() {this} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: "class A { foo() {this.bar = 'bar';} }",
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo() {bar(this);} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A extends B { foo() {super.foo();} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo() { if(true) { return this; } } }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { static foo() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: '({ a(){} });',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo() { () => this; } }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: '({ a: function () {} });',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo() {this} bar() {} }',
-      options: [{ exceptMethods: ['bar'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { "foo"() { } }',
-      options: [{ exceptMethods: ['foo'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { 42() { } }',
-      options: [{ exceptMethods: ['42'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'class A { foo = function() {this} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { foo = () => {this} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { foo = () => {super.toString} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { static foo = function() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { static foo = () => {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { #bar() {} }',
-      options: [{ exceptMethods: ['#bar'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { foo = function () {} }',
-      options: [{ enforceForClassFields: false }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { foo = () => {} }',
-      options: [{ enforceForClassFields: false }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { foo() { return class { [this.foo] = 1 }; } }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-    {
-      code: 'class A { static {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-    },
-  ],
   invalid: [
     {
       code: 'class A { foo() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {/**this**/} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {var a = function () {this};} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {var a = function () {var b = function(){this}};} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {window.this} }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: "class A { foo() {that.this = 'this';} }",
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() { () => undefined; } }',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {} bar() {} }',
-      options: [{ exceptMethods: ['bar'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['bar'] }],
     },
     {
       code: 'class A { foo() {} hasOwnProperty() {} }',
-      options: [{ exceptMethods: ['foo'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 20,
-          messageId: 'missingThis',
           data: { name: "method 'hasOwnProperty'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['foo'] }],
     },
     {
       code: 'class A { [foo]() {} }',
-      options: [{ exceptMethods: ['foo'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 11,
-          messageId: 'missingThis',
           data: { name: 'method' },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['foo'] }],
     },
     {
       code: 'class A { #foo() { } foo() {} #bar() {} }',
-      options: [{ exceptMethods: ['#foo'] }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 22,
-          messageId: 'missingThis',
           data: { name: "method 'foo'" },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
         {
-          type: AST_NODE_TYPES.FunctionExpression,
-          line: 1,
           column: 31,
-          messageId: 'missingThis',
           data: { name: 'private method #bar' },
+          line: 1,
+          messageId: 'missingThis',
+          type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ exceptMethods: ['#foo'] }],
     },
     {
       code: "class A { foo(){} 'bar'(){} 123(){} [`baz`](){} [a](){} [f(a)](){} get quux(){} set[a](b){} *quuux(){} }",
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'missingThis',
+          column: 11,
           data: { name: "method 'foo'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 11,
         },
         {
-          messageId: 'missingThis',
+          column: 19,
           data: { name: "method 'bar'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 19,
         },
         {
-          messageId: 'missingThis',
+          column: 29,
           data: { name: "method '123'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 29,
         },
         {
-          messageId: 'missingThis',
+          column: 37,
           data: { name: "method 'baz'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 37,
         },
         {
-          messageId: 'missingThis',
+          column: 49,
           data: { name: 'method' },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 49,
         },
         {
-          messageId: 'missingThis',
+          column: 57,
           data: { name: 'method' },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 57,
         },
         {
-          messageId: 'missingThis',
+          column: 68,
           data: { name: "getter 'quux'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 68,
         },
         {
-          messageId: 'missingThis',
+          column: 81,
           data: { name: 'setter' },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 81,
         },
         {
-          messageId: 'missingThis',
+          column: 93,
           data: { name: "generator method 'quuux'" },
+          messageId: 'missingThis',
           type: AST_NODE_TYPES.FunctionExpression,
-          column: 93,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo = function() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: "method 'foo'" },
           column: 11,
+          data: { name: "method 'foo'" },
           endColumn: 25,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo = () => {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: "method 'foo'" },
           column: 11,
+          data: { name: "method 'foo'" },
           endColumn: 17,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { #foo = function() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: 'private method #foo' },
           column: 11,
+          data: { name: 'private method #foo' },
           endColumn: 26,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { #foo = () => {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: 'private method #foo' },
           column: 11,
+          data: { name: 'private method #foo' },
           endColumn: 18,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { #foo() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: 'private method #foo' },
           column: 11,
+          data: { name: 'private method #foo' },
           endColumn: 15,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { get #foo() {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: 'private getter #foo' },
           column: 11,
+          data: { name: 'private getter #foo' },
           endColumn: 19,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { set #foo(x) {} }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: 'private setter #foo' },
           column: 11,
+          data: { name: 'private setter #foo' },
           endColumn: 19,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo () { return class { foo = this }; } }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: "method 'foo'" },
           column: 11,
+          data: { name: "method 'foo'" },
           endColumn: 15,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo () { return function () { foo = this }; } }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: "method 'foo'" },
           column: 11,
+          data: { name: "method 'foo'" },
           endColumn: 15,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo () { return class { static { this; } } } }',
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
-          messageId: 'missingThis',
-          data: { name: "method 'foo'" },
           column: 11,
+          data: { name: "method 'foo'" },
           endColumn: 15,
+          messageId: 'missingThis',
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+  ],
+  valid: [
+    {
+      code: 'class A { constructor() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() {this} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: "class A { foo() {this.bar = 'bar';} }",
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() {bar(this);} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A extends B { foo() {super.foo();} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() { if(true) { return this; } } }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { static foo() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: '({ a(){} });',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() { () => this; } }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: '({ a: function () {} });',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() {this} bar() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['bar'] }],
+    },
+    {
+      code: 'class A { "foo"() { } }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['foo'] }],
+    },
+    {
+      code: 'class A { 42() { } }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ exceptMethods: ['42'] }],
+    },
+    {
+      code: 'class A { foo = function() {this} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { foo = () => {this} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { foo = () => {super.toString} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { static foo = function() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { static foo = () => {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { #bar() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ exceptMethods: ['#bar'] }],
+    },
+    {
+      code: 'class A { foo = function () {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ enforceForClassFields: false }],
+    },
+    {
+      code: 'class A { foo = () => {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ enforceForClassFields: false }],
+    },
+    {
+      code: 'class A { foo() { return class { [this.foo] = 1 }; } }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { static {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this.test.ts b/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this.test.ts
index 575daef11a8b..4238d4c05582 100644
--- a/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this.test.ts
+++ b/packages/eslint-plugin/tests/rules/class-methods-use-this/class-methods-use-this.test.ts
@@ -5,536 +5,523 @@ import rule from '../../../src/rules/class-methods-use-this';
 const ruleTester = new RuleTester();
 
 ruleTester.run('class-methods-use-this', rule, {
-  valid: [
+  invalid: [
     {
       code: `
-class Foo implements Bar {
+class Foo {
   method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
-class Foo implements Bar {
-  get getter() {}
+class Foo {
+  private method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
-class Foo implements Bar {
-  set setter() {}
+class Foo {
+  protected method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  override method() {}
+  #method() {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  private override method() {}
+  get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  protected override method() {}
+  private get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  override get getter(): number {}
+  protected get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  private override get getter(): number {}
+  get #getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  protected override get getter(): number {}
+  set setter(b: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [
+        {
+          ignoreClassesThatImplementAnInterface: false,
+          ignoreOverrideMethods: false,
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  override set setter(v: number) {}
+  private set setter(b: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  private override set setter(v: number) {}
+  protected set setter(b: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo {
-  protected override set setter(v: number) {}
+  set #setter(b: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{}],
     },
     {
       code: `
 class Foo implements Bar {
-  override method() {}
+  method() {}
 }
       `,
-      options: [
+      errors: [
         {
-          ignoreClassesThatImplementAnInterface: true,
-          ignoreOverrideMethods: true,
+          messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  private override method() {}
+  #method() {}
 }
       `,
-      options: [
+      errors: [
         {
-          // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
-          ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
+          messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  protected override method() {}
+  private method() {}
 }
       `,
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  override get getter(): number {}
+  protected method() {}
 }
       `,
-      options: [
+      errors: [
         {
-          ignoreClassesThatImplementAnInterface: true,
-          ignoreOverrideMethods: true,
+          messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo implements Bar {
-  private override get getter(): number {}
-}
-      `,
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  protected override get getter(): number {}
+  get getter(): number {}
 }
       `,
-      options: [
+      errors: [
         {
-          // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
-          ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
+          messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  override set setter(v: number) {}
+  get #getter(): number {}
 }
       `,
-      options: [
+      errors: [
         {
-          ignoreClassesThatImplementAnInterface: true,
-          ignoreOverrideMethods: true,
+          messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  private override set setter(v: number) {}
+  private get getter(): number {}
 }
       `,
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  protected override set setter(v: number) {}
+  protected get getter(): number {}
 }
       `,
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  property = () => {};
-}
-      `,
-      options: [{ ignoreClassesThatImplementAnInterface: true }],
-    },
-    {
-      code: `
-class Foo {
-  override property = () => {};
-}
-      `,
-      options: [{ ignoreOverrideMethods: true }],
-    },
-    {
-      code: `
-class Foo {
-  private override property = () => {};
+  set setter(v: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
-class Foo {
-  protected override property = () => {};
+class Foo implements Bar {
+  set #setter(v: number) {}
 }
       `,
-      options: [{ ignoreOverrideMethods: true }],
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  override property = () => {};
+  private set setter(v: number) {}
 }
       `,
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
       options: [
         {
-          ignoreClassesThatImplementAnInterface: true,
-          ignoreOverrideMethods: true,
+          // _interface_ cannot have `private`/`protected` modifier on members.
+          // We should ignore only public members.
+          ignoreClassesThatImplementAnInterface: 'public-fields',
+          ignoreOverrideMethods: false,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  property = () => {};
+  protected set setter(v: number) {}
 }
       `,
-      options: [
+      errors: [
         {
-          ignoreClassesThatImplementAnInterface: false,
-          enforceForClassFields: false,
+          messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo {
-  override property = () => {};
-}
-      `,
-      options: [
-        {
-          ignoreOverrideMethods: false,
-          enforceForClassFields: false,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo implements Bar {
-  private override property = () => {};
-}
-      `,
-      options: [
-        {
-          // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should check only public members.
-          ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo implements Bar {
-  protected override property = () => {};
-}
-      `,
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should check only public members.
+          // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          // But overridden properties should be ignored.
-          ignoreOverrideMethods: true,
+          ignoreOverrideMethods: false,
         },
       ],
     },
-  ],
-  invalid: [
     {
       code: `
 class Foo {
-  method() {}
+  override method() {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreOverrideMethods: false }],
     },
     {
       code: `
 class Foo {
-  private method() {}
+  override get getter(): number {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreOverrideMethods: false }],
     },
     {
       code: `
 class Foo {
-  protected method() {}
+  override set setter(v: number) {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreOverrideMethods: false }],
     },
     {
       code: `
-class Foo {
-  #method() {}
+class Foo implements Bar {
+  override method() {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo {
-  get getter(): number {}
-}
-      `,
-      options: [{}],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: false,
+          ignoreOverrideMethods: false,
         },
       ],
     },
     {
       code: `
-class Foo {
-  private get getter(): number {}
+class Foo implements Bar {
+  override get getter(): number {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo {
-  protected get getter(): number {}
-}
-      `,
-      options: [{}],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: false,
+          ignoreOverrideMethods: false,
         },
       ],
     },
     {
       code: `
-class Foo {
-  get #getter(): number {}
+class Foo implements Bar {
+  override set setter(v: number) {}
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo {
-  set setter(b: number) {}
-}
-      `,
       options: [
         {
           ignoreClassesThatImplementAnInterface: false,
           ignoreOverrideMethods: false,
         },
       ],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
     },
     {
       code: `
-class Foo {
-  private set setter(b: number) {}
+class Foo implements Bar {
+  property = () => {};
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
-class Foo {
-  protected set setter(b: number) {}
+class Foo implements Bar {
+  #property = () => {};
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreClassesThatImplementAnInterface: false }],
     },
     {
       code: `
 class Foo {
-  set #setter(b: number) {}
+  override property = () => {};
 }
       `,
-      options: [{}],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [{ ignoreOverrideMethods: false }],
     },
     {
       code: `
 class Foo implements Bar {
-  method() {}
+  override property = () => {};
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
+      options: [
+        {
+          ignoreClassesThatImplementAnInterface: false,
+          ignoreOverrideMethods: false,
+        },
+      ],
     },
     {
       code: `
 class Foo implements Bar {
-  #method() {}
+  private property = () => {};
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
       errors: [
         {
           messageId: 'missingThis',
         },
       ],
-    },
-    {
-      code: `
-class Foo implements Bar {
-  private method() {}
-}
-      `,
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
@@ -542,18 +529,18 @@ class Foo implements Bar {
           ignoreClassesThatImplementAnInterface: 'public-fields',
         },
       ],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
     },
     {
       code: `
 class Foo implements Bar {
-  protected method() {}
+  protected property = () => {};
 }
       `,
+      errors: [
+        {
+          messageId: 'missingThis',
+        },
+      ],
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
@@ -561,106 +548,122 @@ class Foo implements Bar {
           ignoreClassesThatImplementAnInterface: 'public-fields',
         },
       ],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
     },
+  ],
+  valid: [
     {
       code: `
 class Foo implements Bar {
-  get getter(): number {}
+  method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreClassesThatImplementAnInterface: true }],
     },
     {
       code: `
 class Foo implements Bar {
-  get #getter(): number {}
+  get getter() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreClassesThatImplementAnInterface: true }],
     },
     {
       code: `
 class Foo implements Bar {
-  private get getter(): number {}
+  set setter() {}
 }
       `,
-      options: [
-        {
-          // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
-          ignoreClassesThatImplementAnInterface: 'public-fields',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreClassesThatImplementAnInterface: true }],
     },
     {
       code: `
-class Foo implements Bar {
-  protected get getter(): number {}
+class Foo {
+  override method() {}
 }
       `,
-      options: [
-        {
-          // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
-          ignoreClassesThatImplementAnInterface: 'public-fields',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreOverrideMethods: true }],
     },
     {
       code: `
-class Foo implements Bar {
-  set setter(v: number) {}
+class Foo {
+  private override method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  protected override method() {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  override get getter(): number {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  private override get getter(): number {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  protected override get getter(): number {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  override set setter(v: number) {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  private override set setter(v: number) {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  protected override set setter(v: number) {}
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
     },
     {
       code: `
 class Foo implements Bar {
-  set #setter(v: number) {}
+  override method() {}
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: true,
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  private set setter(v: number) {}
+  private override method() {}
 }
       `,
       options: [
@@ -668,19 +671,15 @@ class Foo implements Bar {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          ignoreOverrideMethods: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  protected set setter(v: number) {}
+  protected override method() {}
 }
       `,
       options: [
@@ -688,105 +687,98 @@ class Foo implements Bar {
           // _interface_ cannot have `private`/`protected` modifier on members.
           // We should ignore only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-          ignoreOverrideMethods: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
-class Foo {
-  override method() {}
+class Foo implements Bar {
+  override get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: false }],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: true,
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
-class Foo {
-  override get getter(): number {}
+class Foo implements Bar {
+  private override get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: false }],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          // _interface_ cannot have `private`/`protected` modifier on members.
+          // We should ignore only public members.
+          ignoreClassesThatImplementAnInterface: 'public-fields',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
-class Foo {
-  override set setter(v: number) {}
+class Foo implements Bar {
+  protected override get getter(): number {}
 }
       `,
-      options: [{ ignoreOverrideMethods: false }],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          // _interface_ cannot have `private`/`protected` modifier on members.
+          // We should ignore only public members.
+          ignoreClassesThatImplementAnInterface: 'public-fields',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  override method() {}
+  override set setter(v: number) {}
 }
       `,
       options: [
         {
-          ignoreClassesThatImplementAnInterface: false,
-          ignoreOverrideMethods: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: true,
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  override get getter(): number {}
+  private override set setter(v: number) {}
 }
       `,
       options: [
         {
-          ignoreClassesThatImplementAnInterface: false,
-          ignoreOverrideMethods: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // _interface_ cannot have `private`/`protected` modifier on members.
+          // We should ignore only public members.
+          ignoreClassesThatImplementAnInterface: 'public-fields',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  override set setter(v: number) {}
+  protected override set setter(v: number) {}
 }
       `,
       options: [
         {
-          ignoreClassesThatImplementAnInterface: false,
-          ignoreOverrideMethods: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // _interface_ cannot have `private`/`protected` modifier on members.
+          // We should ignore only public members.
+          ignoreClassesThatImplementAnInterface: 'public-fields',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
@@ -796,92 +788,100 @@ class Foo implements Bar {
   property = () => {};
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreClassesThatImplementAnInterface: true }],
     },
     {
       code: `
-class Foo implements Bar {
-  #property = () => {};
+class Foo {
+  override property = () => {};
 }
       `,
-      options: [{ ignoreClassesThatImplementAnInterface: false }],
-      errors: [
-        {
-          messageId: 'missingThis',
-        },
-      ],
+      options: [{ ignoreOverrideMethods: true }],
     },
     {
       code: `
 class Foo {
+  private override property = () => {};
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo {
+  protected override property = () => {};
+}
+      `,
+      options: [{ ignoreOverrideMethods: true }],
+    },
+    {
+      code: `
+class Foo implements Bar {
   override property = () => {};
 }
       `,
-      options: [{ ignoreOverrideMethods: false }],
-      errors: [
+      options: [
         {
-          messageId: 'missingThis',
+          ignoreClassesThatImplementAnInterface: true,
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  override property = () => {};
+  property = () => {};
 }
       `,
       options: [
         {
+          enforceForClassFields: false,
           ignoreClassesThatImplementAnInterface: false,
-          ignoreOverrideMethods: false,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+class Foo {
+  override property = () => {};
+}
+      `,
+      options: [
         {
-          messageId: 'missingThis',
+          enforceForClassFields: false,
+          ignoreOverrideMethods: false,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  private property = () => {};
+  private override property = () => {};
 }
       `,
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
+          // We should check only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
     {
       code: `
 class Foo implements Bar {
-  protected property = () => {};
+  protected override property = () => {};
 }
       `,
       options: [
         {
           // _interface_ cannot have `private`/`protected` modifier on members.
-          // We should ignore only public members.
+          // We should check only public members.
           ignoreClassesThatImplementAnInterface: 'public-fields',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingThis',
+          // But overridden properties should be ignored.
+          ignoreOverrideMethods: true,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts b/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
index f7f50ea44524..ec8d13719751 100644
--- a/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
@@ -5,135 +5,6 @@ import rule from '../../src/rules/consistent-generic-constructors';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-generic-constructors', rule, {
-  valid: [
-    // default: constructor
-    'const a = new Foo();',
-    'const a = new Foo<string>();',
-    'const a: Foo<string> = new Foo<string>();',
-    'const a: Foo = new Foo();',
-    'const a: Bar<string> = new Foo();',
-    'const a: Foo = new Foo<string>();',
-    'const a: Bar = new Foo<string>();',
-    'const a: Bar<string> = new Foo<string>();',
-    'const a: Foo<string> = Foo<string>();',
-    'const a: Foo<string> = Foo();',
-    'const a: Foo = Foo<string>();',
-    `
-class Foo {
-  a = new Foo<string>();
-}
-    `,
-    `
-function foo(a: Foo = new Foo<string>()) {}
-    `,
-    `
-function foo({ a }: Foo = new Foo<string>()) {}
-    `,
-    `
-function foo([a]: Foo = new Foo<string>()) {}
-    `,
-    `
-class A {
-  constructor(a: Foo = new Foo<string>()) {}
-}
-    `,
-    `
-const a = function (a: Foo = new Foo<string>()) {};
-    `,
-    // type-annotation
-    {
-      code: 'const a = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Bar = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Bar<string> = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo = Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a = new (class C<T> {})<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-class Foo {
-  a: Foo<string> = new Foo();
-}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo(a: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo({ a }: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo([a]: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-class A {
-  constructor(a: Foo<string> = new Foo()) {}
-}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-const a = function (a: Foo<string> = new Foo()) {};
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-const [a = new Foo<string>()] = [];
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function a([a = new Foo<string>()]) {}
-      `,
-      options: ['type-annotation'],
-    },
-  ],
   invalid: [
     {
       code: 'const a: Foo<string> = new Foo();',
@@ -321,72 +192,72 @@ const a = function (a = new Foo<string>()) {};
     },
     {
       code: 'const a = new Foo<string>();',
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: 'const a: Foo<string> = new Foo();',
     },
     {
       code: 'const a = new Map<string, number>();',
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: 'const a: Map<string, number> = new Map();',
     },
     {
       code: noFormat`const a = new Map <string, number> ();`,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `const a: Map<string, number> = new Map  ();`,
     },
     {
       code: noFormat`const a = new Map< string, number >();`,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `const a: Map< string, number > = new Map();`,
     },
     {
       code: noFormat`const a = new \n Foo<string> \n ();`,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `const a: Foo<string> = new \n Foo \n ();`,
     },
     {
       code: 'const a = new Foo/* comment */ <string> /* another */();',
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `const a: Foo<string> = new Foo/* comment */  /* another */();`,
     },
     {
       code: 'const a = new Foo</* comment */ string, /* another */ number>();',
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `const a: Foo</* comment */ string, /* another */ number> = new Foo();`,
     },
     {
@@ -395,12 +266,12 @@ class Foo {
   a = new Foo<string>();
 }
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 class Foo {
   a: Foo<string> = new Foo();
@@ -413,12 +284,12 @@ class Foo {
   [a] = new Foo<string>();
 }
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 class Foo {
   [a]: Foo<string> = new Foo();
@@ -431,12 +302,12 @@ class Foo {
   [a + b] = new Foo<string>();
 }
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 class Foo {
   [a + b]: Foo<string> = new Foo();
@@ -447,12 +318,12 @@ class Foo {
       code: `
 function foo(a = new Foo<string>()) {}
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 function foo(a: Foo<string> = new Foo()) {}
       `,
@@ -461,12 +332,12 @@ function foo(a: Foo<string> = new Foo()) {}
       code: `
 function foo({ a } = new Foo<string>()) {}
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 function foo({ a }: Foo<string> = new Foo()) {}
       `,
@@ -475,12 +346,12 @@ function foo({ a }: Foo<string> = new Foo()) {}
       code: `
 function foo([a] = new Foo<string>()) {}
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 function foo([a]: Foo<string> = new Foo()) {}
       `,
@@ -491,12 +362,12 @@ class A {
   constructor(a = new Foo<string>()) {}
 }
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 class A {
   constructor(a: Foo<string> = new Foo()) {}
@@ -507,15 +378,144 @@ class A {
       code: `
 const a = function (a = new Foo<string>()) {};
       `,
-      options: ['type-annotation'],
       errors: [
         {
           messageId: 'preferTypeAnnotation',
         },
       ],
+      options: ['type-annotation'],
       output: `
 const a = function (a: Foo<string> = new Foo()) {};
       `,
     },
   ],
+  valid: [
+    // default: constructor
+    'const a = new Foo();',
+    'const a = new Foo<string>();',
+    'const a: Foo<string> = new Foo<string>();',
+    'const a: Foo = new Foo();',
+    'const a: Bar<string> = new Foo();',
+    'const a: Foo = new Foo<string>();',
+    'const a: Bar = new Foo<string>();',
+    'const a: Bar<string> = new Foo<string>();',
+    'const a: Foo<string> = Foo<string>();',
+    'const a: Foo<string> = Foo();',
+    'const a: Foo = Foo<string>();',
+    `
+class Foo {
+  a = new Foo<string>();
+}
+    `,
+    `
+function foo(a: Foo = new Foo<string>()) {}
+    `,
+    `
+function foo({ a }: Foo = new Foo<string>()) {}
+    `,
+    `
+function foo([a]: Foo = new Foo<string>()) {}
+    `,
+    `
+class A {
+  constructor(a: Foo = new Foo<string>()) {}
+}
+    `,
+    `
+const a = function (a: Foo = new Foo<string>()) {};
+    `,
+    // type-annotation
+    {
+      code: 'const a = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Bar = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Bar<string> = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo = Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a = new (class C<T> {})<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+class Foo {
+  a: Foo<string> = new Foo();
+}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo(a: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo({ a }: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo([a]: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+class A {
+  constructor(a: Foo<string> = new Foo()) {}
+}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+const a = function (a: Foo<string> = new Foo()) {};
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+const [a = new Foo<string>()] = [];
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function a([a = new Foo<string>()]) {}
+      `,
+      options: ['type-annotation'],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts b/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
index 30f98f976e5c..cf0c5f8ba0fd 100644
--- a/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
@@ -5,143 +5,6 @@ import rule from '../../src/rules/consistent-indexed-object-style';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-indexed-object-style', rule, {
-  valid: [
-    // 'record' (default)
-    // Record
-    'type Foo = Record<string, any>;',
-
-    // Interface
-    'interface Foo {}',
-    `
-interface Foo {
-  bar: string;
-}
-    `,
-    `
-interface Foo {
-  bar: string;
-  [key: string]: any;
-}
-    `,
-    `
-interface Foo {
-  [key: string]: any;
-  bar: string;
-}
-    `,
-    // circular
-    'type Foo = { [key: string]: string | Foo };',
-    'type Foo = { [key: string]: Foo };',
-    'type Foo = { [key: string]: Foo } | Foo;',
-    `
-interface Foo {
-  [key: string]: Foo;
-}
-    `,
-    `
-interface Foo<T> {
-  [key: string]: Foo<T>;
-}
-    `,
-    `
-interface Foo<T> {
-  [key: string]: Foo<T> | string;
-}
-    `,
-    // Type literal
-    'type Foo = {};',
-    `
-type Foo = {
-  bar: string;
-  [key: string]: any;
-};
-    `,
-    `
-type Foo = {
-  bar: string;
-};
-    `,
-    `
-type Foo = {
-  [key: string]: any;
-  bar: string;
-};
-    `,
-
-    // Generic
-    `
-type Foo = Generic<{
-  [key: string]: any;
-  bar: string;
-}>;
-    `,
-
-    // Function types
-    'function foo(arg: { [key: string]: any; bar: string }) {}',
-    'function foo(): { [key: string]: any; bar: string } {}',
-
-    // Invalid syntax allowed by the parser
-    'type Foo = { [key: string] };',
-    'type Foo = { [] };',
-    `
-interface Foo {
-  [key: string];
-}
-    `,
-    `
-interface Foo {
-  [];
-}
-    `,
-    // 'index-signature'
-    // Unhandled type
-    {
-      code: 'type Foo = Misc<string, unknown>;',
-      options: ['index-signature'],
-    },
-
-    // Invalid record
-    {
-      code: 'type Foo = Record;',
-      options: ['index-signature'],
-    },
-    {
-      code: 'type Foo = Record<string>;',
-      options: ['index-signature'],
-    },
-    {
-      code: 'type Foo = Record<string, number, unknown>;',
-      options: ['index-signature'],
-    },
-
-    // Type literal
-    {
-      code: 'type Foo = { [key: string]: any };',
-      options: ['index-signature'],
-    },
-
-    // Generic
-    {
-      code: 'type Foo = Generic<{ [key: string]: any }>;',
-      options: ['index-signature'],
-    },
-
-    // Function types
-    {
-      code: 'function foo(arg: { [key: string]: any }) {}',
-      options: ['index-signature'],
-    },
-    {
-      code: 'function foo(): { [key: string]: any } {}',
-      options: ['index-signature'],
-    },
-
-    // Namespace
-    {
-      code: 'type T = A.B;',
-      options: ['index-signature'],
-    },
-  ],
   invalid: [
     // Interface
     {
@@ -150,10 +13,10 @@ interface Foo {
   [key: string]: any;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo = Record<string, any>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Readonly interface
@@ -163,10 +26,10 @@ interface Foo {
   readonly [key: string]: any;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo = Readonly<Record<string, any>>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Interface with generic parameter
@@ -176,10 +39,10 @@ interface Foo<A> {
   [key: string]: A;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<A> = Record<string, A>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Interface with generic parameter and default value
@@ -189,10 +52,10 @@ interface Foo<A = any> {
   [key: string]: A;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<A = any> = Record<string, A>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Interface with extends
@@ -202,8 +65,8 @@ interface B extends A {
   [index: number]: unknown;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: null,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
     // Readonly interface with generic parameter
     {
@@ -212,10 +75,10 @@ interface Foo<A> {
   readonly [key: string]: A;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<A> = Readonly<Record<string, A>>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Interface with multiple generic parameters
@@ -225,10 +88,10 @@ interface Foo<A, B> {
   [key: A]: B;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<A, B> = Record<A, B>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Readonly interface with multiple generic parameters
@@ -238,101 +101,101 @@ interface Foo<A, B> {
   readonly [key: A]: B;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<A, B> = Readonly<Record<A, B>>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
 
     // Type literal
     {
       code: 'type Foo = { [key: string]: any };',
+      errors: [{ column: 12, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Record<string, any>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 12 }],
     },
 
     // Readonly type literal
     {
       code: 'type Foo = { readonly [key: string]: any };',
+      errors: [{ column: 12, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Readonly<Record<string, any>>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 12 }],
     },
 
     // Generic
     {
       code: 'type Foo = Generic<{ [key: string]: any }>;',
+      errors: [{ column: 20, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Generic<Record<string, any>>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 20 }],
     },
 
     // Readonly Generic
     {
       code: 'type Foo = Generic<{ readonly [key: string]: any }>;',
+      errors: [{ column: 20, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Generic<Readonly<Record<string, any>>>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 20 }],
     },
 
     // Function types
     {
       code: 'function foo(arg: { [key: string]: any }) {}',
+      errors: [{ column: 19, line: 1, messageId: 'preferRecord' }],
       output: 'function foo(arg: Record<string, any>) {}',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 19 }],
     },
     {
       code: 'function foo(): { [key: string]: any } {}',
+      errors: [{ column: 17, line: 1, messageId: 'preferRecord' }],
       output: 'function foo(): Record<string, any> {}',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 17 }],
     },
 
     // Readonly function types
     {
       code: 'function foo(arg: { readonly [key: string]: any }) {}',
+      errors: [{ column: 19, line: 1, messageId: 'preferRecord' }],
       output: 'function foo(arg: Readonly<Record<string, any>>) {}',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 19 }],
     },
     {
       code: 'function foo(): { readonly [key: string]: any } {}',
+      errors: [{ column: 17, line: 1, messageId: 'preferRecord' }],
       output: 'function foo(): Readonly<Record<string, any>> {}',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 17 }],
     },
 
     // Never
     // Type literal
     {
       code: 'type Foo = Record<string, any>;',
+      errors: [{ column: 12, line: 1, messageId: 'preferIndexSignature' }],
       options: ['index-signature'],
       output: 'type Foo = { [key: string]: any };',
-      errors: [{ messageId: 'preferIndexSignature', line: 1, column: 12 }],
     },
 
     // Type literal with generic parameter
     {
       code: 'type Foo<T> = Record<string, T>;',
+      errors: [{ column: 15, line: 1, messageId: 'preferIndexSignature' }],
       options: ['index-signature'],
       output: 'type Foo<T> = { [key: string]: T };',
-      errors: [{ messageId: 'preferIndexSignature', line: 1, column: 15 }],
     },
 
     // Circular
     {
       code: 'type Foo = { [k: string]: A.Foo };',
+      errors: [{ column: 12, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Record<string, A.Foo>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 12 }],
     },
     {
       code: 'type Foo = { [key: string]: AnotherFoo };',
+      errors: [{ column: 12, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Record<string, AnotherFoo>;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 12 }],
     },
     {
       code: 'type Foo = { [key: string]: { [key: string]: Foo } };',
+      errors: [{ column: 29, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = { [key: string]: Record<string, Foo> };',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 29 }],
     },
     {
       code: 'type Foo = { [key: string]: string } | Foo;',
+      errors: [{ column: 12, line: 1, messageId: 'preferRecord' }],
       output: 'type Foo = Record<string, string> | Foo;',
-      errors: [{ messageId: 'preferRecord', line: 1, column: 12 }],
     },
     {
       code: `
@@ -340,10 +203,10 @@ interface Foo<T> {
   [k: string]: T;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo<T> = Record<string, T>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
     {
       code: `
@@ -351,10 +214,10 @@ interface Foo {
   [k: string]: A.Foo;
 }
       `,
+      errors: [{ column: 1, line: 2, messageId: 'preferRecord' }],
       output: `
 type Foo = Record<string, A.Foo>;
       `,
-      errors: [{ messageId: 'preferRecord', line: 2, column: 1 }],
     },
     {
       code: `
@@ -362,34 +225,171 @@ interface Foo {
   [k: string]: { [key: string]: Foo };
 }
       `,
+      errors: [{ column: 16, line: 3, messageId: 'preferRecord' }],
       output: `
 interface Foo {
   [k: string]: Record<string, Foo>;
 }
       `,
-      errors: [{ messageId: 'preferRecord', line: 3, column: 16 }],
     },
 
     // Generic
     {
       code: 'type Foo = Generic<Record<string, any>>;',
+      errors: [{ column: 20, line: 1, messageId: 'preferIndexSignature' }],
       options: ['index-signature'],
       output: 'type Foo = Generic<{ [key: string]: any }>;',
-      errors: [{ messageId: 'preferIndexSignature', line: 1, column: 20 }],
     },
 
     // Function types
     {
       code: 'function foo(arg: Record<string, any>) {}',
+      errors: [{ column: 19, line: 1, messageId: 'preferIndexSignature' }],
       options: ['index-signature'],
       output: 'function foo(arg: { [key: string]: any }) {}',
-      errors: [{ messageId: 'preferIndexSignature', line: 1, column: 19 }],
     },
     {
       code: 'function foo(): Record<string, any> {}',
+      errors: [{ column: 17, line: 1, messageId: 'preferIndexSignature' }],
       options: ['index-signature'],
       output: 'function foo(): { [key: string]: any } {}',
-      errors: [{ messageId: 'preferIndexSignature', line: 1, column: 17 }],
+    },
+  ],
+  valid: [
+    // 'record' (default)
+    // Record
+    'type Foo = Record<string, any>;',
+
+    // Interface
+    'interface Foo {}',
+    `
+interface Foo {
+  bar: string;
+}
+    `,
+    `
+interface Foo {
+  bar: string;
+  [key: string]: any;
+}
+    `,
+    `
+interface Foo {
+  [key: string]: any;
+  bar: string;
+}
+    `,
+    // circular
+    'type Foo = { [key: string]: string | Foo };',
+    'type Foo = { [key: string]: Foo };',
+    'type Foo = { [key: string]: Foo } | Foo;',
+    `
+interface Foo {
+  [key: string]: Foo;
+}
+    `,
+    `
+interface Foo<T> {
+  [key: string]: Foo<T>;
+}
+    `,
+    `
+interface Foo<T> {
+  [key: string]: Foo<T> | string;
+}
+    `,
+    // Type literal
+    'type Foo = {};',
+    `
+type Foo = {
+  bar: string;
+  [key: string]: any;
+};
+    `,
+    `
+type Foo = {
+  bar: string;
+};
+    `,
+    `
+type Foo = {
+  [key: string]: any;
+  bar: string;
+};
+    `,
+
+    // Generic
+    `
+type Foo = Generic<{
+  [key: string]: any;
+  bar: string;
+}>;
+    `,
+
+    // Function types
+    'function foo(arg: { [key: string]: any; bar: string }) {}',
+    'function foo(): { [key: string]: any; bar: string } {}',
+
+    // Invalid syntax allowed by the parser
+    'type Foo = { [key: string] };',
+    'type Foo = { [] };',
+    `
+interface Foo {
+  [key: string];
+}
+    `,
+    `
+interface Foo {
+  [];
+}
+    `,
+    // 'index-signature'
+    // Unhandled type
+    {
+      code: 'type Foo = Misc<string, unknown>;',
+      options: ['index-signature'],
+    },
+
+    // Invalid record
+    {
+      code: 'type Foo = Record;',
+      options: ['index-signature'],
+    },
+    {
+      code: 'type Foo = Record<string>;',
+      options: ['index-signature'],
+    },
+    {
+      code: 'type Foo = Record<string, number, unknown>;',
+      options: ['index-signature'],
+    },
+
+    // Type literal
+    {
+      code: 'type Foo = { [key: string]: any };',
+      options: ['index-signature'],
+    },
+
+    // Generic
+    {
+      code: 'type Foo = Generic<{ [key: string]: any }>;',
+      options: ['index-signature'],
+    },
+
+    // Function types
+    {
+      code: 'function foo(arg: { [key: string]: any }) {}',
+      options: ['index-signature'],
+    },
+    {
+      code: 'function foo(): { [key: string]: any } {}',
+      options: ['index-signature'],
+    },
+
+    // Namespace
+    {
+      code: 'type T = A.B;',
+      options: ['index-signature'],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-return.test.ts b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
index b26b70654dee..ce807a71175c 100644
--- a/packages/eslint-plugin/tests/rules/consistent-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
@@ -8,13 +8,257 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('consistent-return', rule, {
+  invalid: [
+    {
+      code: `
+        function foo(flag: boolean): any {
+          if (flag) return true;
+          else return;
+        }
+      `,
+      errors: [
+        {
+          column: 16,
+          data: { name: "Function 'foo'" },
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        function bar(): undefined {}
+        function foo(flag: boolean): undefined {
+          if (flag) return bar();
+          return;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: { name: "Function 'foo'" },
+          endColumn: 18,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        declare function foo(): void;
+        function bar(flag: boolean): undefined {
+          function baz(): undefined {
+            if (flag) return;
+            return undefined;
+          }
+          if (flag) return baz();
+          return;
+        }
+      `,
+      errors: [
+        {
+          column: 13,
+          data: { name: "Function 'baz'" },
+          endColumn: 30,
+          endLine: 6,
+          line: 6,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+        {
+          column: 11,
+          data: { name: "Function 'bar'" },
+          endColumn: 18,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        function foo(flag: boolean): Promise<void> {
+          if (flag) return Promise.resolve(void 0);
+          else return;
+        }
+      `,
+      errors: [
+        {
+          column: 16,
+          data: { name: "Function 'foo'" },
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        async function foo(flag: boolean): Promise<string> {
+          if (flag) return;
+          else return 'value';
+        }
+      `,
+      errors: [
+        {
+          column: 16,
+          data: { name: "Async function 'foo'" },
+          endColumn: 31,
+          endLine: 4,
+          line: 4,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        async function foo(flag: boolean): Promise<string | undefined> {
+          if (flag) return 'value';
+          else return;
+        }
+      `,
+      errors: [
+        {
+          column: 16,
+          data: { name: "Async function 'foo'" },
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        async function foo(flag: boolean) {
+          if (flag) return;
+          return 1;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: { name: "Async function 'foo'" },
+          endColumn: 20,
+          endLine: 4,
+          line: 4,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        function foo(flag: boolean): Promise<string | undefined> {
+          if (flag) return;
+          else return 'value';
+        }
+      `,
+      errors: [
+        {
+          column: 16,
+          data: { name: "Function 'foo'" },
+          endColumn: 31,
+          endLine: 4,
+          line: 4,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        declare function bar(): Promise<void>;
+        function foo(flag?: boolean): Promise<void> {
+          if (flag) {
+            return bar();
+          }
+          return;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: { name: "Function 'foo'" },
+          endColumn: 18,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+    },
+    {
+      code: `
+        function foo(flag: boolean): undefined | boolean {
+          if (flag) {
+            return undefined;
+          }
+          return true;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: { name: "Function 'foo'" },
+          endColumn: 23,
+          endLine: 6,
+          line: 6,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+      options: [
+        {
+          treatUndefinedAsUnspecified: true,
+        },
+      ],
+    },
+    {
+      code: `
+        declare const undefOrNum: undefined | number;
+        function foo(flag: boolean) {
+          if (flag) {
+            return;
+          }
+          return undefOrNum;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: { name: "Function 'foo'" },
+          endColumn: 29,
+          endLine: 7,
+          line: 7,
+          messageId: 'unexpectedReturnValue',
+          type: AST_NODE_TYPES.ReturnStatement,
+        },
+      ],
+      options: [
+        {
+          treatUndefinedAsUnspecified: true,
+        },
+      ],
+    },
+  ],
   valid: [
     // base rule
     `
@@ -210,248 +454,4 @@ ruleTester.run('consistent-return', rule, {
       ],
     },
   ],
-  invalid: [
-    {
-      code: `
-        function foo(flag: boolean): any {
-          if (flag) return true;
-          else return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: `
-        function bar(): undefined {}
-        function foo(flag: boolean): undefined {
-          if (flag) return bar();
-          return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 5,
-          column: 11,
-          endLine: 5,
-          endColumn: 18,
-        },
-      ],
-    },
-    {
-      code: `
-        declare function foo(): void;
-        function bar(flag: boolean): undefined {
-          function baz(): undefined {
-            if (flag) return;
-            return undefined;
-          }
-          if (flag) return baz();
-          return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Function 'baz'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 6,
-          column: 13,
-          endLine: 6,
-          endColumn: 30,
-        },
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Function 'bar'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 9,
-          column: 11,
-          endLine: 9,
-          endColumn: 18,
-        },
-      ],
-    },
-    {
-      code: `
-        function foo(flag: boolean): Promise<void> {
-          if (flag) return Promise.resolve(void 0);
-          else return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: `
-        async function foo(flag: boolean): Promise<string> {
-          if (flag) return;
-          else return 'value';
-        }
-      `,
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Async function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 31,
-        },
-      ],
-    },
-    {
-      code: `
-        async function foo(flag: boolean): Promise<string | undefined> {
-          if (flag) return 'value';
-          else return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Async function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: `
-        async function foo(flag: boolean) {
-          if (flag) return;
-          return 1;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Async function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 11,
-          endLine: 4,
-          endColumn: 20,
-        },
-      ],
-    },
-    {
-      code: `
-        function foo(flag: boolean): Promise<string | undefined> {
-          if (flag) return;
-          else return 'value';
-        }
-      `,
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 31,
-        },
-      ],
-    },
-    {
-      code: `
-        declare function bar(): Promise<void>;
-        function foo(flag?: boolean): Promise<void> {
-          if (flag) {
-            return bar();
-          }
-          return;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'missingReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 7,
-          column: 11,
-          endLine: 7,
-          endColumn: 18,
-        },
-      ],
-    },
-    {
-      code: `
-        function foo(flag: boolean): undefined | boolean {
-          if (flag) {
-            return undefined;
-          }
-          return true;
-        }
-      `,
-      options: [
-        {
-          treatUndefinedAsUnspecified: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 6,
-          column: 11,
-          endLine: 6,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: `
-        declare const undefOrNum: undefined | number;
-        function foo(flag: boolean) {
-          if (flag) {
-            return;
-          }
-          return undefOrNum;
-        }
-      `,
-      options: [
-        {
-          treatUndefinedAsUnspecified: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unexpectedReturnValue',
-          data: { name: "Function 'foo'" },
-          type: AST_NODE_TYPES.ReturnStatement,
-          line: 7,
-          column: 11,
-          endLine: 7,
-          endColumn: 29,
-        },
-      ],
-    },
-  ],
 });
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 29eb3d5297a0..435030e82982 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
@@ -6,6 +6,7 @@ import type {
   MessageIds,
   Options,
 } from '../../src/rules/consistent-type-assertions';
+
 import rule from '../../src/rules/consistent-type-assertions';
 import { dedupeTestCases } from '../dedupeTestCases';
 import { batchedSingleLineTests } from '../RuleTester';
@@ -83,68 +84,6 @@ print\`\${<Foo>{ bar: 5 }}\`
 `;
 
 ruleTester.run('consistent-type-assertions', rule, {
-  valid: [
-    ...dedupeTestCases(
-      batchedSingleLineTests<Options>({
-        code: AS_TESTS,
-        options: [
-          { assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' },
-        ],
-      }),
-    ),
-    ...batchedSingleLineTests<Options>({
-      code: ANGLE_BRACKET_TESTS,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: `${OBJECT_LITERAL_AS_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_AS_CASTS}`,
-      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' }],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: `${OBJECT_LITERAL_ANGLE_BRACKET_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS}`,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: OBJECT_LITERAL_ARGUMENT_AS_CASTS,
-      options: [
-        {
-          assertionStyle: 'as',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    }),
-    { code: 'const x = <const>[1];', options: [{ assertionStyle: 'never' }] },
-    { code: 'const x = [1] as const;', options: [{ assertionStyle: 'never' }] },
-    {
-      code: 'const bar = <Foo style={{ bar: 5 } as Bar} />;',
-      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
-      options: [
-        {
-          assertionStyle: 'as',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    },
-  ],
   invalid: [
     ...dedupeTestCases(
       (
@@ -157,445 +96,445 @@ ruleTester.run('consistent-type-assertions', rule, {
       ).flatMap(([assertionStyle, code, output]) =>
         batchedSingleLineTests<MessageIds, Options>({
           code,
-          options: [{ assertionStyle }],
           errors: code
             .split(`\n`)
-            .map((_, i) => ({ messageId: assertionStyle, line: i + 1 })),
+            .map((_, i) => ({ line: i + 1, messageId: assertionStyle })),
+          options: [{ assertionStyle }],
           output,
         }),
       ),
     ),
     ...batchedSingleLineTests<MessageIds, Options>({
       code: OBJECT_LITERAL_AS_CASTS,
-      options: [
-        {
-          assertionStyle: 'as',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
       errors: [
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 2,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: Foo<int> = {};',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies Foo<int>;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 3,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: a | b = ({});',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = ({}) satisfies a | b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 4,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'A' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies A + b;',
             },
           ],
         },
       ],
-    }),
-    ...batchedSingleLineTests<MessageIds, Options>({
-      code: OBJECT_LITERAL_ANGLE_BRACKET_CASTS,
       options: [
         {
-          assertionStyle: 'angle-bracket',
+          assertionStyle: 'as',
           objectLiteralTypeAssertions: 'allow-as-parameter',
         },
       ],
+    }),
+    ...batchedSingleLineTests<MessageIds, Options>({
+      code: OBJECT_LITERAL_ANGLE_BRACKET_CASTS,
       errors: [
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 2,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: Foo<int> = {};',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies Foo<int>;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 3,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: a | b = ({});',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = ({}) satisfies a | b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 4,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'A' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies A + b;',
             },
           ],
         },
       ],
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
+        },
+      ],
     }),
     ...batchedSingleLineTests<MessageIds, Options>({
       code: `${OBJECT_LITERAL_AS_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_AS_CASTS}`,
-      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'never' }],
       errors: [
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 2,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: Foo<int> = {};',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies Foo<int>;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 3,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: a | b = ({});',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = ({}) satisfies a | b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 4,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'A' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies A + b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 5,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 6,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'new print({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 7,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'function foo() { throw { bar: 5 } satisfies Foo }',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 8,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo.Bar' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'function b(x = {} satisfies Foo.Bar) {}',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 9,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'function c(x = {} satisfies Foo) {}',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 10,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print?.({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 11,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print?.call({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 12,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: `print\`\${{ bar: 5 } satisfies Foo}\``,
             },
           ],
         },
       ],
+      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'never' }],
     }),
     ...batchedSingleLineTests<MessageIds, Options>({
       code: `${OBJECT_LITERAL_ANGLE_BRACKET_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS}`,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'never',
-        },
-      ],
       errors: [
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 2,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: Foo<int> = {};',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo<int>' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies Foo<int>;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 3,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithAnnotation',
               output: 'const x: a | b = ({});',
             },
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'a | b' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = ({}) satisfies a | b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 4,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'A' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'const x = {} satisfies A + b;',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 5,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 6,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'new print({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 7,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'function foo() { throw { bar: 5 } satisfies Foo }',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 8,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print?.({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 9,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: 'print?.call({ bar: 5 } satisfies Foo)',
             },
           ],
         },
         {
-          messageId: 'unexpectedObjectTypeAssertion',
           line: 10,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggestions: [
             {
-              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               data: { cast: 'Foo' },
+              messageId: 'replaceObjectTypeAssertionWithSatisfies',
               output: `print\`\${{ bar: 5 } satisfies Foo}\``,
             },
           ],
         },
       ],
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'never',
+        },
+      ],
     }),
     {
       code: 'const foo = <Foo style={{ bar: 5 } as Bar} />;',
-      output: null,
+      errors: [{ line: 1, messageId: 'never' }],
       languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
       options: [{ assertionStyle: 'never' }],
-      errors: [{ messageId: 'never', line: 1 }],
+      output: null,
     },
     {
       code: 'const a = <any>(b, c);',
-      output: `const a = (b, c) as any;`,
-      options: [
-        {
-          assertionStyle: 'as',
-        },
-      ],
       errors: [
         {
-          messageId: 'as',
           line: 1,
+          messageId: 'as',
         },
       ],
-    },
-    {
-      code: 'const f = <any>(() => {});',
-      output: 'const f = (() => {}) as any;',
       options: [
         {
           assertionStyle: 'as',
         },
       ],
+      output: `const a = (b, c) as any;`,
+    },
+    {
+      code: 'const f = <any>(() => {});',
       errors: [
         {
-          messageId: 'as',
           line: 1,
+          messageId: 'as',
         },
       ],
-    },
-    {
-      code: 'const f = <any>function () {};',
-      output: 'const f = function () {} as any;',
       options: [
         {
           assertionStyle: 'as',
         },
       ],
+      output: 'const f = (() => {}) as any;',
+    },
+    {
+      code: 'const f = <any>function () {};',
       errors: [
         {
-          messageId: 'as',
           line: 1,
+          messageId: 'as',
         },
       ],
-    },
-    {
-      code: 'const f = <any>(async () => {});',
-      output: 'const f = (async () => {}) as any;',
       options: [
         {
           assertionStyle: 'as',
         },
       ],
+      output: 'const f = function () {} as any;',
+    },
+    {
+      code: 'const f = <any>(async () => {});',
       errors: [
         {
-          messageId: 'as',
           line: 1,
+          messageId: 'as',
         },
       ],
+      options: [
+        {
+          assertionStyle: 'as',
+        },
+      ],
+      output: 'const f = (async () => {}) as any;',
     },
     {
       // prettier wants to remove the parens around the yield expression,
@@ -605,56 +544,118 @@ function* g() {
   const y = <any>(yield a);
 }
       `,
-      output: `
-function* g() {
-  const y = (yield a) as any;
-}
-      `,
-      options: [
+      errors: [
         {
-          assertionStyle: 'as',
+          line: 3,
+          messageId: 'as',
         },
       ],
-      errors: [
+      options: [
         {
-          messageId: 'as',
-          line: 3,
+          assertionStyle: 'as',
         },
       ],
+      output: `
+function* g() {
+  const y = (yield a) as any;
+}
+      `,
     },
     {
       code: `
 declare let x: number, y: number;
 const bs = <any>(x <<= y);
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'as',
+        },
+      ],
+      options: [
+        {
+          assertionStyle: 'as',
+        },
+      ],
       output: `
 declare let x: number, y: number;
 const bs = (x <<= y) as any;
       `,
+    },
+    {
+      code: 'const ternary = <any>(true ? x : y);',
+      errors: [
+        {
+          line: 1,
+          messageId: 'as',
+        },
+      ],
       options: [
         {
           assertionStyle: 'as',
         },
       ],
-      errors: [
+      output: 'const ternary = (true ? x : y) as any;',
+    },
+  ],
+  valid: [
+    ...dedupeTestCases(
+      batchedSingleLineTests<Options>({
+        code: AS_TESTS,
+        options: [
+          { assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' },
+        ],
+      }),
+    ),
+    ...batchedSingleLineTests<Options>({
+      code: ANGLE_BRACKET_TESTS,
+      options: [
         {
-          messageId: 'as',
-          line: 3,
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow',
         },
       ],
-    },
-    {
-      code: 'const ternary = <any>(true ? x : y);',
-      output: 'const ternary = (true ? x : y) as any;',
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: `${OBJECT_LITERAL_AS_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_AS_CASTS}`,
+      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' }],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: `${OBJECT_LITERAL_ANGLE_BRACKET_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS}`,
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow',
+        },
+      ],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: OBJECT_LITERAL_ARGUMENT_AS_CASTS,
       options: [
         {
           assertionStyle: 'as',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
         },
       ],
-      errors: [
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS,
+      options: [
         {
-          messageId: 'as',
-          line: 1,
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
+        },
+      ],
+    }),
+    { code: 'const x = <const>[1];', options: [{ assertionStyle: 'never' }] },
+    { code: 'const x = [1] as const;', options: [{ assertionStyle: 'never' }] },
+    {
+      code: 'const bar = <Foo style={{ bar: 5 } as Bar} />;',
+      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+      options: [
+        {
+          assertionStyle: 'as',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
         },
       ],
     },
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 4fa17b04e988..1fbbf9cb7ba6 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
@@ -5,96 +5,42 @@ import rule from '../../src/rules/consistent-type-definitions';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-type-definitions', rule, {
-  valid: [
-    {
-      code: 'var foo = {};',
-      options: ['interface'],
-    },
-    {
-      code: 'interface A {}',
-      options: ['interface'],
-    },
-    {
-      code: `
-interface A extends B {
-  x: number;
-}
-      `,
-      options: ['interface'],
-    },
-    {
-      code: 'type U = string;',
-      options: ['interface'],
-    },
-    {
-      code: 'type V = { x: number } | { y: string };',
-      options: ['interface'],
-    },
-    {
-      code: `
-type Record<T, U> = {
-  [K in T]: U;
-};
-      `,
-      options: ['interface'],
-    },
-    {
-      code: 'type T = { x: number };',
-      options: ['type'],
-    },
-    {
-      code: 'type A = { x: number } & B & C;',
-      options: ['type'],
-    },
-    {
-      code: 'type A = { x: number } & B<T1> & C<T2>;',
-      options: ['type'],
-    },
-    {
-      code: `
-export type W<T> = {
-  x: T;
-};
-      `,
-      options: ['type'],
-    },
-  ],
   invalid: [
     {
       code: noFormat`type T = { x: number; };`,
-      output: `interface T { x: number; }`,
-      options: ['interface'],
       errors: [
         {
-          messageId: 'interfaceOverType',
-          line: 1,
           column: 6,
+          line: 1,
+          messageId: 'interfaceOverType',
         },
       ],
+      options: ['interface'],
+      output: `interface T { x: number; }`,
     },
     {
       code: noFormat`type T={ x: number; };`,
-      output: `interface T { x: number; }`,
-      options: ['interface'],
       errors: [
         {
-          messageId: 'interfaceOverType',
-          line: 1,
           column: 6,
+          line: 1,
+          messageId: 'interfaceOverType',
         },
       ],
+      options: ['interface'],
+      output: `interface T { x: number; }`,
     },
     {
       code: noFormat`type T=                         { x: number; };`,
-      output: `interface T { x: number; }`,
-      options: ['interface'],
       errors: [
         {
-          messageId: 'interfaceOverType',
-          line: 1,
           column: 6,
+          line: 1,
+          messageId: 'interfaceOverType',
         },
       ],
+      options: ['interface'],
+      output: `interface T { x: number; }`,
     },
     {
       code: `
@@ -102,79 +48,79 @@ export type W<T> = {
   x: T;
 };
       `,
-      output: `
-export interface W<T> {
-  x: T;
-}
-      `,
-      options: ['interface'],
       errors: [
         {
-          messageId: 'interfaceOverType',
-          line: 2,
           column: 13,
+          line: 2,
+          messageId: 'interfaceOverType',
         },
       ],
+      options: ['interface'],
+      output: `
+export interface W<T> {
+  x: T;
+}
+      `,
     },
     {
       code: noFormat`interface T { x: number; }`,
-      output: `type T = { x: number; }`,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `type T = { x: number; }`,
     },
     {
       code: noFormat`interface T{ x: number; }`,
-      output: `type T = { x: number; }`,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `type T = { x: number; }`,
     },
     {
       code: noFormat`interface T                          { x: number; }`,
-      output: `type T = { x: number; }`,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `type T = { x: number; }`,
     },
     {
       code: noFormat`interface A extends B, C { x: number; };`,
-      output: `type A = { x: number; } & B & C;`,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `type A = { x: number; } & B & C;`,
     },
     {
       code: noFormat`interface A extends B<T1>, C<T2> { x: number; };`,
-      output: `type A = { x: number; } & B<T1> & C<T2>;`,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `type A = { x: number; } & B<T1> & C<T2>;`,
     },
     {
       code: `
@@ -182,19 +128,19 @@ export interface W<T> {
   x: T;
 }
       `,
-      output: `
-export type W<T> = {
-  x: T;
-}
-      `,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 2,
           column: 18,
+          line: 2,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: `
+export type W<T> = {
+  x: T;
+}
+      `,
     },
     {
       code: `
@@ -204,6 +150,14 @@ namespace JSX {
   }
 }
       `,
+      errors: [
+        {
+          column: 13,
+          line: 3,
+          messageId: 'typeOverInterface',
+        },
+      ],
+      options: ['type'],
       output: `
 namespace JSX {
   type Array<T> = {
@@ -211,14 +165,6 @@ namespace JSX {
   }
 }
       `,
-      options: ['type'],
-      errors: [
-        {
-          messageId: 'typeOverInterface',
-          line: 3,
-          column: 13,
-        },
-      ],
     },
     {
       code: `
@@ -228,6 +174,14 @@ global {
   }
 }
       `,
+      errors: [
+        {
+          column: 13,
+          line: 3,
+          messageId: 'typeOverInterface',
+        },
+      ],
+      options: ['type'],
       output: `
 global {
   type Array<T> = {
@@ -235,14 +189,6 @@ global {
   }
 }
       `,
-      options: ['type'],
-      errors: [
-        {
-          messageId: 'typeOverInterface',
-          line: 3,
-          column: 13,
-        },
-      ],
     },
     {
       code: `
@@ -252,15 +198,15 @@ declare global {
   }
 }
       `,
-      output: null,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 3,
           column: 13,
+          line: 3,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: null,
     },
     {
       code: `
@@ -270,15 +216,15 @@ declare global {
   }
 }
       `,
-      output: null,
-      options: ['type'],
       errors: [
         {
-          messageId: 'typeOverInterface',
-          line: 4,
           column: 15,
+          line: 4,
+          messageId: 'typeOverInterface',
         },
       ],
+      options: ['type'],
+      output: null,
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/3894
@@ -288,6 +234,14 @@ export default interface Test {
   foo(): number;
 }
       `,
+      errors: [
+        {
+          column: 26,
+          line: 2,
+          messageId: 'typeOverInterface',
+        },
+      ],
+      options: ['type'],
       output: `
 type Test = {
   bar(): string;
@@ -295,14 +249,6 @@ type Test = {
 }
 export default Test
       `,
-      options: ['type'],
-      errors: [
-        {
-          messageId: 'typeOverInterface',
-          line: 2,
-          column: 26,
-        },
-      ],
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/4333
@@ -312,20 +258,20 @@ export declare type Test = {
   bar: string;
 };
       `,
+      errors: [
+        {
+          column: 21,
+          line: 2,
+          messageId: 'interfaceOverType',
+        },
+      ],
+      options: ['interface'],
       output: `
 export declare interface Test {
   foo: string;
   bar: string;
 }
       `,
-      options: ['interface'],
-      errors: [
-        {
-          messageId: 'interfaceOverType',
-          line: 2,
-          column: 21,
-        },
-      ],
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/4333
@@ -335,20 +281,74 @@ export declare interface Test {
   bar: string;
 }
       `,
+      errors: [
+        {
+          column: 26,
+          line: 2,
+          messageId: 'typeOverInterface',
+        },
+      ],
+      options: ['type'],
       output: `
 export declare type Test = {
   foo: string;
   bar: string;
 }
       `,
+    },
+  ],
+  valid: [
+    {
+      code: 'var foo = {};',
+      options: ['interface'],
+    },
+    {
+      code: 'interface A {}',
+      options: ['interface'],
+    },
+    {
+      code: `
+interface A extends B {
+  x: number;
+}
+      `,
+      options: ['interface'],
+    },
+    {
+      code: 'type U = string;',
+      options: ['interface'],
+    },
+    {
+      code: 'type V = { x: number } | { y: string };',
+      options: ['interface'],
+    },
+    {
+      code: `
+type Record<T, U> = {
+  [K in T]: U;
+};
+      `,
+      options: ['interface'],
+    },
+    {
+      code: 'type T = { x: number };',
+      options: ['type'],
+    },
+    {
+      code: 'type A = { x: number } & B & C;',
+      options: ['type'],
+    },
+    {
+      code: 'type A = { x: number } & B<T1> & C<T2>;',
+      options: ['type'],
+    },
+    {
+      code: `
+export type W<T> = {
+  x: T;
+};
+      `,
       options: ['type'],
-      errors: [
-        {
-          messageId: 'typeOverInterface',
-          line: 2,
-          column: 26,
-        },
-      ],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
index 209a285c7ee1..de0b57798c3f 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
@@ -8,135 +8,96 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('consistent-type-exports', rule, {
-  valid: [
-    // unknown module should be ignored
-    "export { Foo } from 'foo';",
-
-    "export type { Type1 } from './consistent-type-exports';",
-    "export { value1 } from './consistent-type-exports';",
-    "export type { value1 } from './consistent-type-exports';",
-    `
-const variable = 1;
-class Class {}
-enum Enum {}
-function Func() {}
-namespace ValueNS {
-  export const x = 1;
-}
-
-export { variable, Class, Enum, Func, ValueNS };
-    `,
-    `
-type Alias = 1;
-interface IFace {}
-namespace TypeNS {
-  export type x = 1;
-}
-
-export type { Alias, IFace, TypeNS };
-    `,
-    `
-const foo = 1;
-export type { foo };
-    `,
-    `
-namespace NonTypeNS {
-  export const x = 1;
-}
-
-export { NonTypeNS };
-    `,
-  ],
   invalid: [
     {
       code: "export { Type1 } from './consistent-type-exports';",
-      output: "export type { Type1 } from './consistent-type-exports';",
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'typeOverValue',
         },
       ],
+      output: "export type { Type1 } from './consistent-type-exports';",
     },
     {
       code: "export { Type1, value1 } from './consistent-type-exports';",
-      output:
-        `export type { Type1 } from './consistent-type-exports';\n` +
-        `export { value1 } from './consistent-type-exports';`,
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'singleExportIsType',
         },
       ],
+      output:
+        `export type { Type1 } from './consistent-type-exports';\n` +
+        `export { value1 } from './consistent-type-exports';`,
     },
     {
       code: `
 export { Type1, value1, value2 } from './consistent-type-exports';
-      `,
-      output: `
-export type { Type1 } from './consistent-type-exports';
-export { value1, value2 } from './consistent-type-exports';
       `,
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'singleExportIsType',
         },
       ],
+      output: `
+export type { Type1 } from './consistent-type-exports';
+export { value1, value2 } from './consistent-type-exports';
+      `,
     },
     {
       code: `
 export { Type1, value1, Type2, value2 } from './consistent-type-exports';
-      `,
-      output: `
-export type { Type1, Type2 } from './consistent-type-exports';
-export { value1, value2 } from './consistent-type-exports';
       `,
       errors: [
         {
-          messageId: 'multipleExportsAreTypes',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'multipleExportsAreTypes',
         },
       ],
+      output: `
+export type { Type1, Type2 } from './consistent-type-exports';
+export { value1, value2 } from './consistent-type-exports';
+      `,
     },
     {
       code: "export { Type2 as Foo } from './consistent-type-exports';",
-      output: "export type { Type2 as Foo } from './consistent-type-exports';",
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'typeOverValue',
         },
       ],
+      output: "export type { Type2 as Foo } from './consistent-type-exports';",
     },
     {
       code: `
 export { Type2 as Foo, value1 } from './consistent-type-exports';
-      `,
-      output: `
-export type { Type2 as Foo } from './consistent-type-exports';
-export { value1 } from './consistent-type-exports';
       `,
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'singleExportIsType',
         },
       ],
+      output: `
+export type { Type2 as Foo } from './consistent-type-exports';
+export { value1 } from './consistent-type-exports';
+      `,
     },
     {
       code: `
@@ -145,53 +106,53 @@ export {
   value1 as BScope,
   value2 as CScope,
 } from './consistent-type-exports';
-      `,
-      output: `
-export type { Type2 as Foo } from './consistent-type-exports';
-export { value1 as BScope, value2 as CScope } from './consistent-type-exports';
       `,
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'singleExportIsType',
         },
       ],
+      output: `
+export type { Type2 as Foo } from './consistent-type-exports';
+export { value1 as BScope, value2 as CScope } from './consistent-type-exports';
+      `,
     },
     {
       code: `
 import { Type2 } from './consistent-type-exports';
 export { Type2 };
-      `,
-      output: `
-import { Type2 } from './consistent-type-exports';
-export type { Type2 };
       `,
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'typeOverValue',
         },
       ],
+      output: `
+import { Type2 } from './consistent-type-exports';
+export type { Type2 };
+      `,
     },
     {
       code: `
 import { value2, Type2 } from './consistent-type-exports';
 export { value2, Type2 };
-      `,
-      output: `
-import { value2, Type2 } from './consistent-type-exports';
-export type { Type2 };
-export { value2 };
       `,
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'singleExportIsType',
         },
       ],
+      output: `
+import { value2, Type2 } from './consistent-type-exports';
+export type { Type2 };
+export { value2 };
+      `,
     },
     {
       code: `
@@ -204,6 +165,13 @@ namespace TypeNS {
 
 export { Alias, IFace, TypeNS };
       `,
+      errors: [
+        {
+          column: 1,
+          line: 9,
+          messageId: 'multipleExportsAreTypes',
+        },
+      ],
       output: `
 type Alias = 1;
 interface IFace {}
@@ -215,13 +183,6 @@ namespace TypeNS {
 export type { Alias, IFace };
 export { TypeNS };
       `,
-      errors: [
-        {
-          messageId: 'multipleExportsAreTypes',
-          line: 9,
-          column: 1,
-        },
-      ],
     },
     {
       code: `
@@ -231,6 +192,13 @@ namespace TypeNS {
 
 export { TypeNS };
       `,
+      errors: [
+        {
+          column: 1,
+          line: 6,
+          messageId: 'typeOverValue',
+        },
+      ],
       output: `
 namespace TypeNS {
   export interface Foo {}
@@ -238,47 +206,40 @@ namespace TypeNS {
 
 export type { TypeNS };
       `,
-      errors: [
-        {
-          messageId: 'typeOverValue',
-          line: 6,
-          column: 1,
-        },
-      ],
     },
     {
       code: `
 type T = 1;
 export { type T, T };
-      `,
-      output: `
-type T = 1;
-export type { T, T };
       `,
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'typeOverValue',
         },
       ],
+      output: `
+type T = 1;
+export type { T, T };
+      `,
     },
     {
       code: noFormat`
 type T = 1;
 export { type/* */T, type     /* */T, T };
-      `,
-      output: `
-type T = 1;
-export type { /* */T, /* */T, T };
       `,
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'typeOverValue',
         },
       ],
+      output: `
+type T = 1;
+export type { /* */T, /* */T, T };
+      `,
     },
     {
       code: `
@@ -286,19 +247,19 @@ type T = 1;
 const x = 1;
 export { type T, T, x };
       `,
+      errors: [
+        {
+          column: 1,
+          line: 4,
+          messageId: 'singleExportIsType',
+        },
+      ],
       output: `
 type T = 1;
 const x = 1;
 export type { T, T };
 export { x };
       `,
-      errors: [
-        {
-          messageId: 'singleExportIsType',
-          line: 4,
-          column: 1,
-        },
-      ],
     },
     {
       code: `
@@ -306,37 +267,37 @@ type T = 1;
 const x = 1;
 export { T, x };
       `,
-      output: `
-type T = 1;
-const x = 1;
-export { type T, x };
-      `,
-      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
       errors: [
         {
-          messageId: 'singleExportIsType',
-          line: 4,
           column: 1,
+          line: 4,
+          messageId: 'singleExportIsType',
         },
       ],
+      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
+      output: `
+type T = 1;
+const x = 1;
+export { type T, x };
+      `,
     },
     {
       code: `
 type T = 1;
 export { type T, T };
       `,
-      output: `
-type T = 1;
-export type { T, T };
-      `,
-      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
       errors: [
         {
-          messageId: 'typeOverValue',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'typeOverValue',
         },
       ],
+      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
+      output: `
+type T = 1;
+export type { T, T };
+      `,
     },
     {
       code: `
@@ -347,18 +308,18 @@ export {
   value2 as CScope,
 } from './consistent-type-exports';
       `,
-      output: `
-export type { Type1, Type2 as Foo, value1 as BScope } from './consistent-type-exports';
-export { value2 as CScope } from './consistent-type-exports';
-      `,
-      options: [{ fixMixedExportsWithInlineTypeSpecifier: false }],
       errors: [
         {
-          messageId: 'multipleExportsAreTypes',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'multipleExportsAreTypes',
         },
       ],
+      options: [{ fixMixedExportsWithInlineTypeSpecifier: false }],
+      output: `
+export type { Type1, Type2 as Foo, value1 as BScope } from './consistent-type-exports';
+export { value2 as CScope } from './consistent-type-exports';
+      `,
     },
     {
       code: `
@@ -369,6 +330,14 @@ export {
   value2 as CScope,
 } from './consistent-type-exports';
       `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'multipleExportsAreTypes',
+        },
+      ],
+      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
       output: `
 export {
   type Type1,
@@ -377,14 +346,45 @@ export {
   value2 as CScope,
 } from './consistent-type-exports';
       `,
-      options: [{ fixMixedExportsWithInlineTypeSpecifier: true }],
-      errors: [
-        {
-          messageId: 'multipleExportsAreTypes',
-          line: 2,
-          column: 1,
-        },
-      ],
     },
   ],
+  valid: [
+    // unknown module should be ignored
+    "export { Foo } from 'foo';",
+
+    "export type { Type1 } from './consistent-type-exports';",
+    "export { value1 } from './consistent-type-exports';",
+    "export type { value1 } from './consistent-type-exports';",
+    `
+const variable = 1;
+class Class {}
+enum Enum {}
+function Func() {}
+namespace ValueNS {
+  export const x = 1;
+}
+
+export { variable, Class, Enum, Func, ValueNS };
+    `,
+    `
+type Alias = 1;
+interface IFace {}
+namespace TypeNS {
+  export type x = 1;
+}
+
+export type { Alias, IFace, TypeNS };
+    `,
+    `
+const foo = 1;
+export type { foo };
+    `,
+    `
+namespace NonTypeNS {
+  export const x = 1;
+}
+
+export { NonTypeNS };
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
index 48d918a6436e..86c952435afe 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
@@ -4,16 +4,16 @@ import rule from '../../src/rules/consistent-type-imports';
 
 const PARSER_OPTION_COMBOS = [
   {
-    experimentalDecorators: false,
     emitDecoratorMetadata: false,
+    experimentalDecorators: false,
   },
   {
-    experimentalDecorators: false,
     emitDecoratorMetadata: true,
+    experimentalDecorators: false,
   },
   {
-    experimentalDecorators: true,
     emitDecoratorMetadata: false,
+    experimentalDecorators: true,
   },
 ];
 for (const parserOptions of PARSER_OPTION_COMBOS) {
@@ -23,1926 +23,1926 @@ for (const parserOptions of PARSER_OPTION_COMBOS) {
     });
 
     ruleTester.run('consistent-type-imports', rule, {
-      valid: [
-        `
-          import Foo from 'foo';
-          const foo: Foo = new Foo();
-        `,
-        `
-          import foo from 'foo';
-          const foo: foo.Foo = foo.fn();
-        `,
-        `
-          import { A, B } from 'foo';
-          const foo: A = B();
-          const bar = new A();
-        `,
-        `
-          import Foo from 'foo';
-        `,
-        `
-          import Foo from 'foo';
-          type T<Foo> = Foo; // shadowing
-        `,
-        `
-          import Foo from 'foo';
-          function fn() {
-            type Foo = {}; // shadowing
-            let foo: Foo;
-          }
-        `,
-        `
-          import { A, B } from 'foo';
-          const b = B;
-        `,
-        `
-          import { A, B, C as c } from 'foo';
-          const d = c;
-        `,
-        `
-          import {} from 'foo'; // empty
-        `,
+      invalid: [
         {
           code: `
-let foo: import('foo');
-let bar: import('foo').Bar;
+import Foo from 'foo';
+let foo: Foo;
+type Bar = Foo;
+interface Baz {
+  foo: Foo;
+}
+function fn(a: Foo): Foo {}
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type Foo from 'foo';
+let foo: Foo;
+type Bar = Foo;
+interface Baz {
+  foo: Foo;
+}
+function fn(a: Foo): Foo {}
           `,
-          options: [{ disallowTypeAnnotations: false }],
         },
         {
           code: `
 import Foo from 'foo';
 let foo: Foo;
           `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        // type queries
-        `
-          import type Type from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        `
-          import type { Type } from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        `
-          import type * as Type from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        {
-          code: `
-import Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type Foo from 'foo';
+let foo: Foo;
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import Foo from 'foo';
+let foo: Foo;
           `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        {
-          code: `
-import * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import type Foo from 'foo';
+let foo: Foo;
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import * as Type from 'foo' assert { type: 'json' };
-const a: typeof Type = Type;
+import { A, B } from 'foo';
+let foo: A;
+let bar: B;
           `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        `
-          import { type A } from 'foo';
-          type T = A;
-        `,
-        `
-          import { type A, B } from 'foo';
-          type T = A;
-          const b = B;
-        `,
-        `
-          import { type A, type B } from 'foo';
-          type T = A;
-          type Z = B;
-        `,
-        `
-          import { B } from 'foo';
-          import { type A } from 'foo';
-          type T = A;
-          const b = B;
-        `,
-        {
-          code: `
-import { B, type A } from 'foo';
-type T = A;
-const b = B;
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type { A, B } from 'foo';
+let foo: A;
+let bar: B;
           `,
-          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import { B } from 'foo';
-import type A from 'baz';
-type T = A;
-const b = B;
+import { A as a, B as b } from 'foo';
+let foo: a;
+let bar: b;
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type { A as a, B as b } from 'foo';
+let foo: a;
+let bar: b;
           `,
-          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import { type B } from 'foo';
-import type { A } from 'foo';
-type T = A;
-const b = B;
+import Foo from 'foo';
+type Bar = typeof Foo; // TSTypeQuery
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type Foo from 'foo';
+type Bar = typeof Foo; // TSTypeQuery
           `,
-          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import { B, type C } from 'foo';
-import type A from 'baz';
-type T = A;
-type Z = C;
-const b = B;
+import foo from 'foo';
+type Bar = foo.Bar; // TSQualifiedName
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
           ],
+          output: `
+import type foo from 'foo';
+type Bar = foo.Bar; // TSQualifiedName
+          `,
         },
         {
           code: `
-import { B } from 'foo';
-import type { A } from 'foo';
-type T = A;
-const b = B;
+import foo from 'foo';
+type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
           ],
+          output: `
+import type foo from 'foo';
+type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
+          `,
         },
         {
           code: `
-import { B } from 'foo';
-import { A } from 'foo';
-type T = A;
-const b = B;
+import * as A from 'foo';
+let foo: A.Foo;
           `,
-          options: [
-            { prefer: 'no-type-imports', fixStyle: 'inline-type-imports' },
-          ],
-        },
-        // exports
-        `
-          import Type from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type Type from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-        `
-          import { Type } from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type { Type } from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-        `
-          import * as Type from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type * as Type from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-
-        {
-          code: `
-import Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type * as A from 'foo';
+let foo: A.Foo;
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
         {
+          // default and named
           code: `
-import { Type } from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+import A, { B } from 'foo';
+let foo: A;
+let bar: B;
           `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        {
-          code: `
-import * as Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type { B } from 'foo';
+import type A from 'foo';
+let foo: A;
+let bar: B;
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
-        // https://github.com/typescript-eslint/typescript-eslint/issues/2455
         {
-          code: `
-import React from 'react';
-
-export const ComponentFoo: React.FC = () => {
-  return <div>Foo Foo</div>;
-};
+          code: noFormat`
+import A, {} from 'foo';
+let foo: A;
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
             },
-          },
-        },
-        {
-          code: `
-import { h } from 'some-other-jsx-lib';
-
-export const ComponentFoo: h.FC = () => {
-  return <div>Foo Foo</div>;
-};
+          ],
+          output: `
+import type A from 'foo';
+let foo: A;
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
-              jsxPragma: 'h',
-            },
-          },
         },
         {
           code: `
-import { Fragment } from 'react';
-
-export const ComponentFoo: Fragment = () => {
-  return <>Foo Foo</>;
-};
+import { A, B } from 'foo';
+const foo: A = B();
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
-              jsxFragmentName: 'Fragment',
+          errors: [
+            {
+              data: { typeImports: '"A"' },
+              line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
-          },
+          ],
+          output: `
+import type { A} from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+          `,
         },
-        `
-          import Default, * as Rest from 'module';
-          const a: typeof Default = Default;
-          const b: typeof Rest = Rest;
-        `,
-
-        // https://github.com/typescript-eslint/typescript-eslint/issues/2989
-        `
-          import type * as constants from './constants';
-
-          export type Y = {
-            [constants.X]: ReadonlyArray<string>;
-          };
-        `,
-        `
-          import A from 'foo';
-          export = A;
-        `,
-        `
-          import type A from 'foo';
-          export = A;
-        `,
-        `
-          import type A from 'foo';
-          export = {} as A;
-        `,
-        `
-          import { type A } from 'foo';
-          export = {} as A;
-        `,
-
-        // semantically these are insane but syntactically they are valid
-        // we don't want to handle them because it means changing invalid code
-        // to valid code which is dangerous "undefined" behavior.
-        `
-import type T from 'mod';
-const x = T;
-        `,
-        `
-import type { T } from 'mod';
-const x = T;
-        `,
-        `
-import { type T } from 'mod';
-const x = T;
-        `,
-      ],
-      invalid: [
         {
           code: `
-import Foo from 'foo';
-let foo: Foo;
-type Bar = Foo;
-interface Baz {
-  foo: Foo;
-}
-function fn(a: Foo): Foo {}
-          `,
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
-type Bar = Foo;
-interface Baz {
-  foo: Foo;
-}
-function fn(a: Foo): Foo {}
+import { A, B, C } from 'foo';
+const foo: A = B();
+let bar: C;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"A" and "C"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { A, C } from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+let bar: C;
+          `,
         },
         {
           code: `
-import Foo from 'foo';
-let foo: Foo;
-          `,
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
+import { A, B, C, D } from 'foo';
+const foo: A = B();
+type T = { bar: C; baz: D };
           `,
-          options: [{ prefer: 'type-imports' }],
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"A", "C" and "D"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { A, C, D } from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+type T = { bar: C; baz: D };
+          `,
         },
         {
           code: `
-import Foo from 'foo';
-let foo: Foo;
-          `,
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
+import A, { B, C, D } from 'foo';
+B();
+type T = { foo: A; bar: C; baz: D };
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"A", "C" and "D"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
-        },
-        {
-          code: `
-import { A, B } from 'foo';
-let foo: A;
-let bar: B;
+          output: `
+import type { C, D } from 'foo';
+import type A from 'foo';
+import { B } from 'foo';
+B();
+type T = { foo: A; bar: C; baz: D };
           `,
-          output: `
-import type { A, B } from 'foo';
-let foo: A;
-let bar: B;
+        },
+        {
+          code: `
+import A, { B } from 'foo';
+B();
+type T = A;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type A from 'foo';
+import { B } from 'foo';
+B();
+type T = A;
+          `,
         },
         {
           code: `
-import { A as a, B as b } from 'foo';
-let foo: a;
-let bar: b;
-          `,
-          output: `
-import type { A as a, B as b } from 'foo';
-let foo: a;
-let bar: b;
+import type Already1Def from 'foo';
+import type { Already1 } from 'foo';
+import A, { B } from 'foo';
+import { C, D, E } from 'bar';
+import type { Already2 } from 'bar';
+type T = { b: B; c: C; d: D };
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
-              line: 2,
+              data: { typeImports: '"B"' },
+              line: 4,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"C" and "D"' },
+              line: 5,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type Already1Def from 'foo';
+import type { Already1 , B } from 'foo';
+import A from 'foo';
+import { E } from 'bar';
+import type { Already2 , C, D} from 'bar';
+type T = { b: B; c: C; d: D };
+          `,
         },
         {
           code: `
-import Foo from 'foo';
-type Bar = typeof Foo; // TSTypeQuery
-          `,
-          output: `
-import type Foo from 'foo';
-type Bar = typeof Foo; // TSTypeQuery
+import A, { /* comment */ B } from 'foo';
+type T = B;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"B"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { /* comment */ B } from 'foo';
+import A from 'foo';
+type T = B;
+          `,
         },
         {
-          code: `
-import foo from 'foo';
-type Bar = foo.Bar; // TSQualifiedName
-          `,
-          output: `
-import type foo from 'foo';
-type Bar = foo.Bar; // TSQualifiedName
+          code: noFormat`
+import { A, B, C } from 'foo';
+import { D, E, F, } from 'bar';
+type T = A | D;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"D"' },
+              line: 3,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { A} from 'foo';
+import { B, C } from 'foo';
+import type { D} from 'bar';
+import { E, F, } from 'bar';
+type T = A | D;
+          `,
         },
         {
-          code: `
-import foo from 'foo';
-type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
-          `,
-          output: `
-import type foo from 'foo';
-type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
+          code: noFormat`
+import { A, B, C } from 'foo';
+import { D, E, F, } from 'bar';
+type T = B | E;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"B"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"E"' },
+              line: 3,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { B} from 'foo';
+import { A, C } from 'foo';
+import type { E} from 'bar';
+import { D, F, } from 'bar';
+type T = B | E;
+          `,
         },
         {
-          code: `
-import * as A from 'foo';
-let foo: A.Foo;
-          `,
-          output: `
-import type * as A from 'foo';
-let foo: A.Foo;
+          code: noFormat`
+import { A, B, C } from 'foo';
+import { D, E, F, } from 'bar';
+type T = C | F;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"C"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"F"' },
+              line: 3,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { C } from 'foo';
+import { A, B } from 'foo';
+import type { F} from 'bar';
+import { D, E } from 'bar';
+type T = C | F;
+          `,
         },
         {
-          // default and named
+          // all type fix cases
           code: `
-import A, { B } from 'foo';
-let foo: A;
-let bar: B;
-          `,
-          output: `
-import type { B } from 'foo';
-import type A from 'foo';
-let foo: A;
-let bar: B;
+import { Type1, Type2 } from 'named_types';
+import Type from 'default_type';
+import * as Types from 'namespace_type';
+import Default, { Named } from 'default_and_named_type';
+type T = Type1 | Type2 | Type | Types.A | Default | Named;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
+            },
+            {
+              line: 3,
+              messageId: 'typeOverValue',
+            },
+            {
+              line: 4,
+              messageId: 'typeOverValue',
+            },
+            {
+              line: 5,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type { Type1, Type2 } from 'named_types';
+import type Type from 'default_type';
+import type * as Types from 'namespace_type';
+import type { Named } from 'default_and_named_type';
+import type Default from 'default_and_named_type';
+type T = Type1 | Type2 | Type | Types.A | Default | Named;
+          `,
         },
         {
-          code: noFormat`
-import A, {} from 'foo';
-let foo: A;
-          `,
-          output: `
-import type A from 'foo';
-let foo: A;
+          // some type fix cases
+          code: `
+import { Value1, Type1 } from 'named_import';
+import Type2, { Value2 } from 'default_import';
+import Value3, { Type3 } from 'default_import2';
+import Type4, { Type5, Value4 } from 'default_and_named_import';
+type T = Type1 | Type2 | Type3 | Type4 | Type5;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
+              data: { typeImports: '"Type1"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"Type2"' },
+              line: 3,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"Type3"' },
+              line: 4,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+            {
+              data: { typeImports: '"Type4" and "Type5"' },
+              line: 5,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          output: `
+import type { Type1 } from 'named_import';
+import { Value1 } from 'named_import';
+import type Type2 from 'default_import';
+import { Value2 } from 'default_import';
+import type { Type3 } from 'default_import2';
+import Value3 from 'default_import2';
+import type { Type5} from 'default_and_named_import';
+import type Type4 from 'default_and_named_import';
+import { Value4 } from 'default_and_named_import';
+type T = Type1 | Type2 | Type3 | Type4 | Type5;
+          `,
         },
+        // type annotations
         {
           code: `
-import { A, B } from 'foo';
-const foo: A = B();
-          `,
-          output: `
-import type { A} from 'foo';
-import { B } from 'foo';
-const foo: A = B();
+let foo: import('foo');
+let bar: import('foo').Bar;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'noImportTypeAnnotations',
+            },
+            {
+              line: 3,
+              messageId: 'noImportTypeAnnotations',
             },
           ],
-        },
-        {
-          code: `
-import { A, B, C } from 'foo';
-const foo: A = B();
-let bar: C;
-          `,
-          output: `
-import type { A, C } from 'foo';
-import { B } from 'foo';
-const foo: A = B();
-let bar: C;
+          output: null,
+        },
+        {
+          code: `
+let foo: import('foo');
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A" and "C"' },
               line: 2,
+              messageId: 'noImportTypeAnnotations',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: null,
         },
         {
           code: `
-import { A, B, C, D } from 'foo';
-const foo: A = B();
-type T = { bar: C; baz: D };
-          `,
-          output: `
-import type { A, C, D } from 'foo';
-import { B } from 'foo';
-const foo: A = B();
-type T = { bar: C; baz: D };
+import type Foo from 'foo';
+let foo: Foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A", "C" and "D"' },
               line: 2,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import Foo from 'foo';
+let foo: Foo;
+          `,
         },
         {
           code: `
-import A, { B, C, D } from 'foo';
-B();
-type T = { foo: A; bar: C; baz: D };
-          `,
-          output: `
-import type { C, D } from 'foo';
-import type A from 'foo';
-import { B } from 'foo';
-B();
-type T = { foo: A; bar: C; baz: D };
+import type { Foo } from 'foo';
+let foo: Foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A", "C" and "D"' },
               line: 2,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import { Foo } from 'foo';
+let foo: Foo;
+          `,
         },
+        // type queries
         {
           code: `
-import A, { B } from 'foo';
-B();
-type T = A;
-          `,
-          output: `
-import type A from 'foo';
-import { B } from 'foo';
-B();
-type T = A;
+import Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
         {
           code: `
-import type Already1Def from 'foo';
-import type { Already1 } from 'foo';
-import A, { B } from 'foo';
-import { C, D, E } from 'bar';
-import type { Already2 } from 'bar';
-type T = { b: B; c: C; d: D };
-          `,
-          output: `
-import type Already1Def from 'foo';
-import type { Already1 , B } from 'foo';
-import A from 'foo';
-import { E } from 'bar';
-import type { Already2 , C, D} from 'bar';
-type T = { b: B; c: C; d: D };
+import { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"B"' },
-              line: 4,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"C" and "D"' },
-              line: 5,
+              line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
         {
           code: `
-import A, { /* comment */ B } from 'foo';
-type T = B;
-          `,
-          output: `
-import type { /* comment */ B } from 'foo';
-import A from 'foo';
-type T = B;
+import * as Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"B"' },
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type * as Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
         {
-          code: noFormat`
-import { A, B, C } from 'foo';
-import { D, E, F, } from 'bar';
-type T = A | D;
-          `,
-          output: `
-import type { A} from 'foo';
-import { B, C } from 'foo';
-import type { D} from 'bar';
-import { E, F, } from 'bar';
-type T = A | D;
+          code: `
+import type Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A"' },
               line: 2,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"D"' },
-              line: 3,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
         {
-          code: noFormat`
-import { A, B, C } from 'foo';
-import { D, E, F, } from 'bar';
-type T = B | E;
-          `,
-          output: `
-import type { B} from 'foo';
-import { A, C } from 'foo';
-import type { E} from 'bar';
-import { D, F, } from 'bar';
-type T = B | E;
+          code: `
+import type { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"B"' },
               line: 2,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"E"' },
-              line: 3,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
         {
-          code: noFormat`
-import { A, B, C } from 'foo';
-import { D, E, F, } from 'bar';
-type T = C | F;
-          `,
-          output: `
-import type { C } from 'foo';
-import { A, B } from 'foo';
-import type { F} from 'bar';
-import { D, E } from 'bar';
-type T = C | F;
+          code: `
+import type * as Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"C"' },
               line: 2,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"F"' },
-              line: 3,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import * as Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
+          `,
         },
+        // exports
         {
-          // all type fix cases
           code: `
-import { Type1, Type2 } from 'named_types';
-import Type from 'default_type';
-import * as Types from 'namespace_type';
-import Default, { Named } from 'default_and_named_type';
-type T = Type1 | Type2 | Type | Types.A | Default | Named;
-          `,
-          output: `
-import type { Type1, Type2 } from 'named_types';
-import type Type from 'default_type';
-import type * as Types from 'namespace_type';
-import type { Named } from 'default_and_named_type';
-import type Default from 'default_and_named_type';
-type T = Type1 | Type2 | Type | Types.A | Default | Named;
+import Type from 'foo';
+
+export type { Type }; // is a type-only export
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
-            },
-            {
               messageId: 'typeOverValue',
-              line: 3,
-            },
-            {
-              messageId: 'typeOverValue',
-              line: 4,
             },
+          ],
+          output: `
+import type Type from 'foo';
+
+export type { Type }; // is a type-only export
+          `,
+        },
+        {
+          code: `
+import { Type } from 'foo';
+
+export type { Type }; // is a type-only export
+          `,
+          errors: [
             {
+              line: 2,
               messageId: 'typeOverValue',
-              line: 5,
             },
           ],
+          output: `
+import type { Type } from 'foo';
+
+export type { Type }; // is a type-only export
+          `,
         },
         {
-          // some type fix cases
           code: `
-import { Value1, Type1 } from 'named_import';
-import Type2, { Value2 } from 'default_import';
-import Value3, { Type3 } from 'default_import2';
-import Type4, { Type5, Value4 } from 'default_and_named_import';
-type T = Type1 | Type2 | Type3 | Type4 | Type5;
-          `,
-          output: `
-import type { Type1 } from 'named_import';
-import { Value1 } from 'named_import';
-import type Type2 from 'default_import';
-import { Value2 } from 'default_import';
-import type { Type3 } from 'default_import2';
-import Value3 from 'default_import2';
-import type { Type5} from 'default_and_named_import';
-import type Type4 from 'default_and_named_import';
-import { Value4 } from 'default_and_named_import';
-type T = Type1 | Type2 | Type3 | Type4 | Type5;
+import * as Type from 'foo';
+
+export type { Type }; // is a type-only export
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"Type1"' },
               line: 2,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"Type2"' },
-              line: 3,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"Type3"' },
-              line: 4,
-            },
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"Type4" and "Type5"' },
-              line: 5,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type * as Type from 'foo';
+
+export type { Type }; // is a type-only export
+          `,
         },
-        // type annotations
         {
           code: `
-let foo: import('foo');
-let bar: import('foo').Bar;
+import type Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
-          output: null,
           errors: [
             {
-              messageId: 'noImportTypeAnnotations',
               line: 2,
-            },
-            {
-              messageId: 'noImportTypeAnnotations',
-              line: 3,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
         },
         {
           code: `
-let foo: import('foo');
+import type { Type } from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
-          output: null,
-          options: [{ prefer: 'type-imports' }],
           errors: [
             {
-              messageId: 'noImportTypeAnnotations',
               line: 2,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import { Type } from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
         },
         {
           code: `
-import type Foo from 'foo';
-let foo: Foo;
+import type * as Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'avoidImportType',
+            },
+          ],
           options: [{ prefer: 'no-type-imports' }],
           output: `
-import Foo from 'foo';
-let foo: Foo;
+import * as Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
+        },
+        {
+          // type with comments
+          code: noFormat`
+import type /*comment*/ * as AllType from 'foo';
+import type // comment
+DefType from 'foo';
+import type /*comment*/ { Type } from 'foo';
+
+type T = { a: AllType; b: DefType; c: Type };
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'avoidImportType',
+            },
+            {
+              line: 3,
+              messageId: 'avoidImportType',
+            },
+            {
+              line: 5,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import /*comment*/ * as AllType from 'foo';
+import // comment
+DefType from 'foo';
+import /*comment*/ { Type } from 'foo';
+
+type T = { a: AllType; b: DefType; c: Type };
+          `,
         },
         {
+          // https://github.com/typescript-eslint/typescript-eslint/issues/2775
           code: `
-import type { Foo } from 'foo';
-let foo: Foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import { Foo } from 'foo';
-let foo: Foo;
+import Default, * as Rest from 'module';
+const a: Rest.A = '';
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type * as Rest from 'module';
+import Default from 'module';
+const a: Rest.A = '';
+          `,
         },
-        // type queries
         {
           code: `
-import Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          output: `
-import type Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import Default, * as Rest from 'module';
+const a: Default = '';
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type Default from 'module';
+import * as Rest from 'module';
+const a: Default = '';
+          `,
         },
         {
           code: `
-import { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          output: `
-import type { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import Default, * as Rest from 'module';
+const a: Default = '';
+const b: Rest.A = '';
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type * as Rest from 'module';
+import type Default from 'module';
+const a: Default = '';
+const b: Rest.A = '';
+          `,
         },
         {
+          // type with comments
           code: `
-import * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import Default, /*comment*/ * as Rest from 'module';
+const a: Default = '';
           `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+          ],
+          options: [{ prefer: 'type-imports' }],
           output: `
-import type * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import type Default from 'module';
+import /*comment*/ * as Rest from 'module';
+const a: Default = '';
+          `,
+        },
+        {
+          // type with comments
+          code: noFormat`
+import Default /*comment1*/, /*comment2*/ { Data } from 'module';
+const a: Default = '';
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type Default /*comment1*/ from 'module';
+import /*comment2*/ { Data } from 'module';
+const a: Default = '';
+          `,
         },
         {
           code: `
-import type Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import Foo from 'foo';
+@deco
+class A {
+  constructor(foo: Foo) {}
+}
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+import type Foo from 'foo';
+@deco
+class A {
+  constructor(foo: Foo) {}
+}
+          `,
         },
         {
           code: `
-import type { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import { type A, B } from 'foo';
+type T = A;
+const b = B;
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'avoidImportType',
             },
           ],
+          options: [{ prefer: 'no-type-imports' }],
+          output: `
+import { A, B } from 'foo';
+type T = A;
+const b = B;
+          `,
         },
         {
           code: `
-import type * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
+import { A, B, type C } from 'foo';
+type T = A | C;
+const b = B;
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
+              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
+          output: `
+import type { A} from 'foo';
+import { B, type C } from 'foo';
+type T = A | C;
+const b = B;
+          `,
         },
-        // exports
+
+        // inline-type-imports
         {
           code: `
-import Type from 'foo';
-
-export type { Type }; // is a type-only export
-          `,
-          output: `
-import type Type from 'foo';
-
-export type { Type }; // is a type-only export
+import { A, B } from 'foo';
+let foo: A;
+let bar: B;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A, type B } from 'foo';
+let foo: A;
+let bar: B;
+          `,
         },
         {
           code: `
-import { Type } from 'foo';
-
-export type { Type }; // is a type-only export
-          `,
-          output: `
-import type { Type } from 'foo';
+import { A, B } from 'foo';
 
-export type { Type }; // is a type-only export
+let foo: A;
+B();
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A, B } from 'foo';
+
+let foo: A;
+B();
+          `,
         },
         {
           code: `
-import * as Type from 'foo';
-
-export type { Type }; // is a type-only export
-          `,
-          output: `
-import type * as Type from 'foo';
-
-export type { Type }; // is a type-only export
+import { A, B } from 'foo';
+type T = A;
+B();
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A, B } from 'foo';
+type T = A;
+B();
+          `,
         },
         {
           code: `
-import type Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+import { A } from 'foo';
+import { B } from 'foo';
+type T = A;
+type U = B;
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'typeOverValue',
+            },
+            {
+              line: 3,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A } from 'foo';
+import { type B } from 'foo';
+type T = A;
+type U = B;
+          `,
         },
         {
           code: `
-import type { Type } from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import { Type } from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+import { A } from 'foo';
+import B from 'foo';
+type T = A;
+type U = B;
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'typeOverValue',
+            },
+            {
+              line: 3,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A } from 'foo';
+import type B from 'foo';
+type T = A;
+type U = B;
+          `,
         },
         {
           code: `
-import type * as Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import * as Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+import A, { B, C } from 'foo';
+type T = B;
+type U = C;
+A();
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import A, { type B, type C } from 'foo';
+type T = B;
+type U = C;
+A();
+          `,
         },
         {
-          // type with comments
-          code: noFormat`
-import type /*comment*/ * as AllType from 'foo';
-import type // comment
-DefType from 'foo';
-import type /*comment*/ { Type } from 'foo';
-
-type T = { a: AllType; b: DefType; c: Type };
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-          output: `
-import /*comment*/ * as AllType from 'foo';
-import // comment
-DefType from 'foo';
-import /*comment*/ { Type } from 'foo';
-
-type T = { a: AllType; b: DefType; c: Type };
+          code: `
+import A, { B, C } from 'foo';
+type T = B;
+type U = C;
+type V = A;
           `,
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'typeOverValue',
             },
+          ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import {type B, type C} from 'foo';
+import type A from 'foo';
+type T = B;
+type U = C;
+type V = A;
+          `,
+        },
+        {
+          code: `
+import A, { B, C as D } from 'foo';
+type T = B;
+type U = D;
+type V = A;
+          `,
+          errors: [
             {
-              messageId: 'avoidImportType',
-              line: 3,
-            },
-            {
-              messageId: 'avoidImportType',
-              line: 5,
+              line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import {type B, type C as D} from 'foo';
+import type A from 'foo';
+type T = B;
+type U = D;
+type V = A;
+          `,
         },
         {
-          // https://github.com/typescript-eslint/typescript-eslint/issues/2775
           code: `
-import Default, * as Rest from 'module';
-const a: Rest.A = '';
-          `,
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type * as Rest from 'module';
-import Default from 'module';
-const a: Rest.A = '';
+import { /* comment */ A, B } from 'foo';
+type T = A;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { /* comment */ type A, B } from 'foo';
+type T = A;
+          `,
         },
         {
           code: `
-import Default, * as Rest from 'module';
-const a: Default = '';
-          `,
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type Default from 'module';
-import * as Rest from 'module';
-const a: Default = '';
+import { B, /* comment */ A } from 'foo';
+type T = A;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { B, /* comment */ type A } from 'foo';
+type T = A;
+          `,
         },
         {
           code: `
-import Default, * as Rest from 'module';
-const a: Default = '';
-const b: Rest.A = '';
-          `,
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type * as Rest from 'module';
-import type Default from 'module';
-const a: Default = '';
-const b: Rest.A = '';
+import { A, B, C } from 'foo';
+import type { D } from 'deez';
+
+const foo: A = B();
+let bar: C;
+let baz: D;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A, B, type C } from 'foo';
+import type { D } from 'deez';
+
+const foo: A = B();
+let bar: C;
+let baz: D;
+          `,
         },
         {
-          // type with comments
           code: `
-import Default, /*comment*/ * as Rest from 'module';
-const a: Default = '';
-          `,
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type Default from 'module';
-import /*comment*/ * as Rest from 'module';
-const a: Default = '';
+import { A, B, type C } from 'foo';
+import type { D } from 'deez';
+const foo: A = B();
+let bar: C;
+let baz: D;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'someImportsAreOnlyTypes',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A, B, type C } from 'foo';
+import type { D } from 'deez';
+const foo: A = B();
+let bar: C;
+let baz: D;
+          `,
         },
         {
-          // type with comments
-          code: noFormat`
-import Default /*comment1*/, /*comment2*/ { Data } from 'module';
-const a: Default = '';
-          `,
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type Default /*comment1*/ from 'module';
-import /*comment2*/ { Data } from 'module';
-const a: Default = '';
+          code: `
+import A from 'foo';
+export = {} as A;
           `,
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import type A from 'foo';
+export = {} as A;
+          `,
         },
         {
           code: `
-import Foo from 'foo';
-@deco
-class A {
-  constructor(foo: Foo) {}
-}
-          `,
-          output: `
-import type Foo from 'foo';
-@deco
-class A {
-  constructor(foo: Foo) {}
-}
+import { A } from 'foo';
+export = {} as A;
           `,
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
+          output: `
+import { type A } from 'foo';
+export = {} as A;
+          `,
         },
         {
           code: `
-import { type A, B } from 'foo';
-type T = A;
-const b = B;
-          `,
-          output: `
-import { A, B } from 'foo';
-type T = A;
-const b = B;
+            import Foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: Foo) {}
+            }
           `,
-          options: [{ prefer: 'no-type-imports' }],
           errors: [
             {
-              messageId: 'avoidImportType',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import { A, B, type C } from 'foo';
-type T = A | C;
-const b = B;
-          `,
-          output: `
-import type { A} from 'foo';
-import { B, type C } from 'foo';
-type T = A | C;
-const b = B;
+            import Foo from 'foo';
+            class A {
+              @deco
+              foo: Foo;
+            }
           `,
-          options: [{ prefer: 'type-imports' }],
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
-              data: { typeImports: '"A"' },
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              foo: Foo;
+            }
+          `,
         },
-
-        // inline-type-imports
         {
           code: `
-import { A, B } from 'foo';
-let foo: A;
-let bar: B;
-          `,
-          output: `
-import { type A, type B } from 'foo';
-let foo: A;
-let bar: B;
+            import Foo from 'foo';
+            class A {
+              @deco
+              foo(foo: Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              foo(foo: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import { A, B } from 'foo';
-
-let foo: A;
-B();
-          `,
-          output: `
-import { type A, B } from 'foo';
-
-let foo: A;
-B();
+            import Foo from 'foo';
+            class A {
+              @deco
+              foo(): Foo {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              foo(): Foo {}
+            }
+          `,
         },
         {
           code: `
-import { A, B } from 'foo';
-type T = A;
-B();
-          `,
-          output: `
-import { type A, B } from 'foo';
-type T = A;
-B();
+            import Foo from 'foo';
+            class A {
+              foo(@deco foo: Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              foo(@deco foo: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import { A } from 'foo';
-import { B } from 'foo';
-type T = A;
-type U = B;
-          `,
-          output: `
-import { type A } from 'foo';
-import { type B } from 'foo';
-type T = A;
-type U = B;
+            import Foo from 'foo';
+            class A {
+              @deco
+              set foo(value: Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
-            },
-            {
               messageId: 'typeOverValue',
-              line: 3,
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              set foo(value: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import { A } from 'foo';
-import B from 'foo';
-type T = A;
-type U = B;
-          `,
-          output: `
-import { type A } from 'foo';
-import type B from 'foo';
-type T = A;
-type U = B;
+            import Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set foo(value: Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
-            },
-            {
               messageId: 'typeOverValue',
-              line: 3,
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set foo(value: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import A, { B, C } from 'foo';
-type T = B;
-type U = C;
-A();
-          `,
-          output: `
-import A, { type B, type C } from 'foo';
-type T = B;
-type U = C;
-A();
+            import Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set ['foo'](value: Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'someImportsAreOnlyTypes',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set ['foo'](value: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import A, { B, C } from 'foo';
-type T = B;
-type U = C;
-type V = A;
-          `,
-          output: `
-import {type B, type C} from 'foo';
-import type A from 'foo';
-type T = B;
-type U = C;
-type V = A;
+            import * as foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: foo.Foo) {}
+            }
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
             {
-              messageId: 'typeOverValue',
               line: 2,
+              messageId: 'typeOverValue',
             },
           ],
+          output: `
+            import type * as foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: foo.Foo) {}
+            }
+          `,
         },
+        // https://github.com/typescript-eslint/typescript-eslint/issues/7209
         {
           code: `
-import A, { B, C as D } from 'foo';
-type T = B;
-type U = D;
-type V = A;
+import 'foo';
+import { Foo, Bar } from 'foo';
+function test(foo: Foo) {}
           `,
+          errors: [
+            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
+          ],
           output: `
-import {type B, type C as D} from 'foo';
-import type A from 'foo';
-type T = B;
-type U = D;
-type V = A;
+import 'foo';
+import type { Foo} from 'foo';
+import { Bar } from 'foo';
+function test(foo: Foo) {}
+          `,
+        },
+        {
+          code: `
+import {} from 'foo';
+import { Foo, Bar } from 'foo';
+function test(foo: Foo) {}
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
           errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
+            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
           ],
+          output: `
+import {} from 'foo';
+import type { Foo} from 'foo';
+import { Bar } from 'foo';
+function test(foo: Foo) {}
+          `,
+        },
+      ],
+      valid: [
+        `
+          import Foo from 'foo';
+          const foo: Foo = new Foo();
+        `,
+        `
+          import foo from 'foo';
+          const foo: foo.Foo = foo.fn();
+        `,
+        `
+          import { A, B } from 'foo';
+          const foo: A = B();
+          const bar = new A();
+        `,
+        `
+          import Foo from 'foo';
+        `,
+        `
+          import Foo from 'foo';
+          type T<Foo> = Foo; // shadowing
+        `,
+        `
+          import Foo from 'foo';
+          function fn() {
+            type Foo = {}; // shadowing
+            let foo: Foo;
+          }
+        `,
+        `
+          import { A, B } from 'foo';
+          const b = B;
+        `,
+        `
+          import { A, B, C as c } from 'foo';
+          const d = c;
+        `,
+        `
+          import {} from 'foo'; // empty
+        `,
+        {
+          code: `
+let foo: import('foo');
+let bar: import('foo').Bar;
+          `,
+          options: [{ disallowTypeAnnotations: false }],
         },
         {
           code: `
-import { /* comment */ A, B } from 'foo';
-type T = A;
+import Foo from 'foo';
+let foo: Foo;
           `,
-          output: `
-import { /* comment */ type A, B } from 'foo';
-type T = A;
+          options: [{ prefer: 'no-type-imports' }],
+        },
+        // type queries
+        `
+          import type Type from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
+        `
+          import type { Type } from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
+        `
+          import type * as Type from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
+        {
+          code: `
+import Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { B, /* comment */ A } from 'foo';
-type T = A;
-          `,
-          output: `
-import { B, /* comment */ type A } from 'foo';
-type T = A;
+import { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { A, B, C } from 'foo';
-import type { D } from 'deez';
-
-const foo: A = B();
-let bar: C;
-let baz: D;
-          `,
-          output: `
-import { type A, B, type C } from 'foo';
-import type { D } from 'deez';
+import * as Type from 'foo';
 
-const foo: A = B();
-let bar: C;
-let baz: D;
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { A, B, type C } from 'foo';
-import type { D } from 'deez';
-const foo: A = B();
-let bar: C;
-let baz: D;
-          `,
-          output: `
-import { type A, B, type C } from 'foo';
-import type { D } from 'deez';
-const foo: A = B();
-let bar: C;
-let baz: D;
+import * as Type from 'foo' assert { type: 'json' };
+const a: typeof Type = Type;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'someImportsAreOnlyTypes',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
+        `
+          import { type A } from 'foo';
+          type T = A;
+        `,
+        `
+          import { type A, B } from 'foo';
+          type T = A;
+          const b = B;
+        `,
+        `
+          import { type A, type B } from 'foo';
+          type T = A;
+          type Z = B;
+        `,
+        `
+          import { B } from 'foo';
+          import { type A } from 'foo';
+          type T = A;
+          const b = B;
+        `,
         {
           code: `
-import A from 'foo';
-export = {} as A;
-          `,
-          output: `
-import type A from 'foo';
-export = {} as A;
+import { B, type A } from 'foo';
+type T = A;
+const b = B;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import { A } from 'foo';
-export = {} as A;
-          `,
-          output: `
-import { type A } from 'foo';
-export = {} as A;
+import { B } from 'foo';
+import type A from 'baz';
+type T = A;
+const b = B;
           `,
-          options: [
-            { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
-          ],
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-            import Foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: Foo) {}
-            }
+import { type B } from 'foo';
+import type { A } from 'foo';
+type T = A;
+const b = B;
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              foo: Foo;
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              foo: Foo;
-            }
+import { B, type C } from 'foo';
+import type A from 'baz';
+type T = A;
+type Z = C;
+const b = B;
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
           ],
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              foo(foo: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              foo(foo: Foo) {}
-            }
+import { B } from 'foo';
+import type { A } from 'foo';
+type T = A;
+const b = B;
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
           ],
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              foo(): Foo {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              foo(): Foo {}
-            }
+import { B } from 'foo';
+import { A } from 'foo';
+type T = A;
+const b = B;
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'no-type-imports' },
           ],
         },
+        // exports
+        `
+          import Type from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type Type from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+        `
+          import { Type } from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type { Type } from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+        `
+          import * as Type from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type * as Type from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              foo(@deco foo: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              foo(@deco foo: Foo) {}
-            }
+import Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              set foo(value: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              set foo(value: Foo) {}
-            }
+import { Type } from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set foo(value: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
+import * as Type from 'foo';
 
-              set foo(value: Foo) {}
-            }
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
-            },
-          ],
+          options: [{ prefer: 'no-type-imports' }],
         },
+        // https://github.com/typescript-eslint/typescript-eslint/issues/2455
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set ['foo'](value: Foo) {}
-            }
-          `,
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
+import React from 'react';
 
-              set ['foo'](value: Foo) {}
-            }
+export const ComponentFoo: React.FC = () => {
+  return <div>Foo Foo</div>;
+};
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
             },
-          ],
+          },
         },
         {
           code: `
-            import * as foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: foo.Foo) {}
-            }
-          `,
-          output: `
-            import type * as foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: foo.Foo) {}
-            }
+import { h } from 'some-other-jsx-lib';
+
+export const ComponentFoo: h.FC = () => {
+  return <div>Foo Foo</div>;
+};
           `,
-          errors: [
-            {
-              messageId: 'typeOverValue',
-              line: 2,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxPragma: 'h',
             },
-          ],
-        },
-        // https://github.com/typescript-eslint/typescript-eslint/issues/7209
-        {
-          code: `
-import 'foo';
-import { Foo, Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-          output: `
-import 'foo';
-import type { Foo} from 'foo';
-import { Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-          errors: [
-            { messageId: 'someImportsAreOnlyTypes', line: 3, column: 1 },
-          ],
+          },
         },
         {
           code: `
-import {} from 'foo';
-import { Foo, Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-          output: `
-import {} from 'foo';
-import type { Foo} from 'foo';
-import { Bar } from 'foo';
-function test(foo: Foo) {}
+import { Fragment } from 'react';
+
+export const ComponentFoo: Fragment = () => {
+  return <>Foo Foo</>;
+};
           `,
-          errors: [
-            { messageId: 'someImportsAreOnlyTypes', line: 3, column: 1 },
-          ],
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxFragmentName: 'Fragment',
+            },
+          },
         },
+        `
+          import Default, * as Rest from 'module';
+          const a: typeof Default = Default;
+          const b: typeof Rest = Rest;
+        `,
+
+        // https://github.com/typescript-eslint/typescript-eslint/issues/2989
+        `
+          import type * as constants from './constants';
+
+          export type Y = {
+            [constants.X]: ReadonlyArray<string>;
+          };
+        `,
+        `
+          import A from 'foo';
+          export = A;
+        `,
+        `
+          import type A from 'foo';
+          export = A;
+        `,
+        `
+          import type A from 'foo';
+          export = {} as A;
+        `,
+        `
+          import { type A } from 'foo';
+          export = {} as A;
+        `,
+
+        // semantically these are insane but syntactically they are valid
+        // we don't want to handle them because it means changing invalid code
+        // to valid code which is dangerous "undefined" behavior.
+        `
+import type T from 'mod';
+const x = T;
+        `,
+        `
+import type { T } from 'mod';
+const x = T;
+        `,
+        `
+import { type T } from 'mod';
+const x = T;
+        `,
       ],
     });
   });
@@ -1953,13 +1953,31 @@ describe('experimentalDecorators: true + emitDecoratorMetadata: true', () => {
   const ruleTester = new RuleTester({
     languageOptions: {
       parserOptions: {
-        experimentalDecorators: true,
         emitDecoratorMetadata: true,
+        experimentalDecorators: true,
       },
     },
   });
 
   ruleTester.run('consistent-type-imports', rule, {
+    invalid: [
+      {
+        code: `
+          import Foo from 'foo';
+          export type T = Foo;
+        `,
+        errors: [
+          {
+            line: 2,
+            messageId: 'typeOverValue',
+          },
+        ],
+        output: `
+          import type Foo from 'foo';
+          export type T = Foo;
+        `,
+      },
+    ],
     valid: [
       `
         import Foo from 'foo';
@@ -2104,23 +2122,5 @@ describe('experimentalDecorators: true + emitDecoratorMetadata: true', () => {
         }
       `,
     ],
-    invalid: [
-      {
-        code: `
-          import Foo from 'foo';
-          export type T = Foo;
-        `,
-        output: `
-          import type Foo from 'foo';
-          export type T = Foo;
-        `,
-        errors: [
-          {
-            messageId: 'typeOverValue',
-            line: 2,
-          },
-        ],
-      },
-    ],
   });
 });
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 bcad5e8a6d62..ac95d9a51766 100644
--- a/packages/eslint-plugin/tests/rules/default-param-last.test.ts
+++ b/packages/eslint-plugin/tests/rules/default-param-last.test.ts
@@ -5,121 +5,15 @@ import rule from '../../src/rules/default-param-last';
 const ruleTester = new RuleTester();
 
 ruleTester.run('default-param-last', rule, {
-  valid: [
-    'function foo() {}',
-    'function foo(a: number) {}',
-    'function foo(a = 1) {}',
-    'function foo(a?: number) {}',
-    'function foo(a: number, b: number) {}',
-    'function foo(a: number, b: number, c?: number) {}',
-    'function foo(a: number, b = 1) {}',
-    'function foo(a: number, b = 1, c = 1) {}',
-    'function foo(a: number, b = 1, c?: number) {}',
-    '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 = () => {};',
-    '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) {}
-}
-    `,
-    `
-class Foo {
-  constructor(a: number, b?: number, c = 1) {}
-}
-    `,
-    `
-class Foo {
-  constructor(a: number, b = 1, c?: number) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b: number,
-    private c: number,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b?: number,
-    private c = 10,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b = 10,
-    private c?: number,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    protected b?: number,
-    private c = 0,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    b?: number,
-    private c = 0,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    private b?: number,
-    c = 0,
-  ) {}
-}
-    `,
-  ],
   invalid: [
     {
       code: 'function foo(a = 1, b: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -127,16 +21,16 @@ class Foo {
       code: 'function foo(a = 1, b = 2, c: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 21,
           endColumn: 26,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -144,16 +38,16 @@ class Foo {
       code: 'function foo(a = 1, b: number, c = 2, d: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 32,
           endColumn: 37,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -161,10 +55,10 @@ class Foo {
       code: 'function foo(a = 1, b: number, c = 2) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -172,10 +66,10 @@ class Foo {
       code: 'function foo(a = 1, b: number, ...c) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -183,10 +77,10 @@ class Foo {
       code: 'function foo(a?: number, b: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 24,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -194,10 +88,10 @@ class Foo {
       code: 'function foo(a: number, b?: number, c: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 25,
           endColumn: 35,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -205,16 +99,16 @@ class Foo {
       code: 'function foo(a = 1, b?: number, c: number) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 21,
           endColumn: 31,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -222,10 +116,10 @@ class Foo {
       code: 'function foo(a = 1, { b }) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -233,10 +127,10 @@ class Foo {
       code: 'function foo({ a } = {}, b) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 24,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -244,10 +138,10 @@ class Foo {
       code: 'function foo({ a, b } = { a: 1, b: 2 }, c) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 39,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -255,10 +149,10 @@ class Foo {
       code: 'function foo([a] = [], b) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 22,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -266,10 +160,10 @@ class Foo {
       code: 'function foo([a, b] = [1, 2], c) {}',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 29,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -277,10 +171,10 @@ class Foo {
       code: 'const foo = function (a = 1, b: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -288,16 +182,16 @@ class Foo {
       code: 'const foo = function (a = 1, b = 2, c: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 30,
           endColumn: 35,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -305,16 +199,16 @@ class Foo {
       code: 'const foo = function (a = 1, b: number, c = 2, d: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 41,
           endColumn: 46,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -322,10 +216,10 @@ class Foo {
       code: 'const foo = function (a = 1, b: number, c = 2) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -333,10 +227,10 @@ class Foo {
       code: 'const foo = function (a = 1, b: number, ...c) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -344,10 +238,10 @@ class Foo {
       code: 'const foo = function (a?: number, b: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 33,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -355,10 +249,10 @@ class Foo {
       code: 'const foo = function (a: number, b?: number, c: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 34,
           endColumn: 44,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -366,16 +260,16 @@ class Foo {
       code: 'const foo = function (a = 1, b?: number, c: number) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 30,
           endColumn: 40,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -383,10 +277,10 @@ class Foo {
       code: 'const foo = function (a = 1, { b }) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 28,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -394,10 +288,10 @@ class Foo {
       code: 'const foo = function ({ a } = {}, b) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 33,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -405,10 +299,10 @@ class Foo {
       code: 'const foo = function ({ a, b } = { a: 1, b: 2 }, c) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 48,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -416,10 +310,10 @@ class Foo {
       code: 'const foo = function ([a] = [], b) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 31,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -427,10 +321,10 @@ class Foo {
       code: 'const foo = function ([a, b] = [1, 2], c) {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 23,
           endColumn: 38,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -438,10 +332,10 @@ class Foo {
       code: 'const foo = (a = 1, b: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -449,16 +343,16 @@ class Foo {
       code: 'const foo = (a = 1, b = 2, c: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 21,
           endColumn: 26,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -466,16 +360,16 @@ class Foo {
       code: 'const foo = (a = 1, b: number, c = 2, d: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 32,
           endColumn: 37,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -483,10 +377,10 @@ class Foo {
       code: 'const foo = (a = 1, b: number, c = 2) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -494,10 +388,10 @@ class Foo {
       code: 'const foo = (a = 1, b: number, ...c) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -505,10 +399,10 @@ class Foo {
       code: 'const foo = (a?: number, b: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 24,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -516,10 +410,10 @@ class Foo {
       code: 'const foo = (a: number, b?: number, c: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 25,
           endColumn: 35,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -527,16 +421,16 @@ class Foo {
       code: 'const foo = (a = 1, b?: number, c: number) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 21,
           endColumn: 31,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -544,10 +438,10 @@ class Foo {
       code: 'const foo = (a = 1, { b }) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 19,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -555,10 +449,10 @@ class Foo {
       code: 'const foo = ({ a } = {}, b) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 24,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -566,10 +460,10 @@ class Foo {
       code: 'const foo = ({ a, b } = { a: 1, b: 2 }, c) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 39,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -577,10 +471,10 @@ class Foo {
       code: 'const foo = ([a] = [], b) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 22,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -588,10 +482,10 @@ class Foo {
       code: 'const foo = ([a, b] = [1, 2], c) => {};',
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 1,
           column: 14,
           endColumn: 29,
+          line: 1,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -607,10 +501,10 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 5,
           column: 5,
           endColumn: 25,
+          line: 5,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -626,10 +520,10 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 5,
           column: 5,
           endColumn: 20,
+          line: 5,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -644,10 +538,10 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 4,
           column: 5,
           endColumn: 22,
+          line: 4,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -662,10 +556,10 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 4,
           column: 5,
           endColumn: 17,
+          line: 4,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -677,10 +571,10 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 3,
           column: 15,
           endColumn: 20,
+          line: 3,
+          messageId: 'shouldBeLast',
         },
       ],
     },
@@ -692,12 +586,118 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'shouldBeLast',
-          line: 3,
           column: 15,
           endColumn: 25,
+          line: 3,
+          messageId: 'shouldBeLast',
         },
       ],
     },
   ],
+  valid: [
+    'function foo() {}',
+    'function foo(a: number) {}',
+    'function foo(a = 1) {}',
+    'function foo(a?: number) {}',
+    'function foo(a: number, b: number) {}',
+    'function foo(a: number, b: number, c?: number) {}',
+    'function foo(a: number, b = 1) {}',
+    'function foo(a: number, b = 1, c = 1) {}',
+    'function foo(a: number, b = 1, c?: number) {}',
+    '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 = () => {};',
+    '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) {}
+}
+    `,
+    `
+class Foo {
+  constructor(a: number, b?: number, c = 1) {}
+}
+    `,
+    `
+class Foo {
+  constructor(a: number, b = 1, c?: number) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b: number,
+    private c: number,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b?: number,
+    private c = 10,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b = 10,
+    private c?: number,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    protected b?: number,
+    private c = 0,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    b?: number,
+    private c = 0,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    private b?: number,
+    c = 0,
+  ) {}
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/dot-notation.test.ts b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
index 580ddef5715c..6b7f445e5d9f 100644
--- a/packages/eslint-plugin/tests/rules/dot-notation.test.ts
+++ b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
@@ -8,8 +8,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -23,134 +23,6 @@ function q(str: string): string {
 }
 
 ruleTester.run('dot-notation', rule, {
-  valid: [
-    //  baseRule
-    'a.b;',
-    'a.b.c;',
-    "a['12'];",
-    'a[b];',
-    'a[0];',
-    { code: 'a.b.c;', options: [{ allowKeywords: false }] },
-    { code: 'a.arguments;', options: [{ allowKeywords: false }] },
-    { code: 'a.let;', options: [{ allowKeywords: false }] },
-    { code: 'a.yield;', options: [{ allowKeywords: false }] },
-    { code: 'a.eval;', options: [{ allowKeywords: false }] },
-    { code: 'a[0];', options: [{ allowKeywords: false }] },
-    { code: "a['while'];", options: [{ allowKeywords: false }] },
-    { code: "a['true'];", options: [{ allowKeywords: false }] },
-    { code: "a['null'];", options: [{ allowKeywords: false }] },
-    { code: 'a[true];', options: [{ allowKeywords: false }] },
-    { code: 'a[null];', options: [{ allowKeywords: false }] },
-    { code: 'a.true;', options: [{ allowKeywords: true }] },
-    { code: 'a.null;', options: [{ allowKeywords: true }] },
-    {
-      code: "a['snake_case'];",
-      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-    },
-    {
-      code: "a['lots_of_snake_case'];",
-      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-    },
-    {
-      code: 'a[`time${range}`];',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'a[`while`];',
-      options: [{ allowKeywords: false }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'a[`time range`];',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    'a.true;',
-    'a.null;',
-    'a[undefined];',
-    'a[void 0];',
-    'a[b()];',
-    {
-      code: 'a[/(?<zero>0)/];',
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-    },
-
-    {
-      code: `
-class X {
-  private priv_prop = 123;
-}
-
-const x = new X();
-x['priv_prop'] = 123;
-      `,
-      options: [{ allowPrivateClassPropertyAccess: true }],
-    },
-
-    {
-      code: `
-class X {
-  protected protected_prop = 123;
-}
-
-const x = new X();
-x['protected_prop'] = 123;
-      `,
-      options: [{ allowProtectedClassPropertyAccess: true }],
-    },
-    {
-      code: `
-class X {
-  prop: string;
-  [key: string]: number;
-}
-
-const x = new X();
-x['hello'] = 3;
-      `,
-      options: [{ allowIndexSignaturePropertyAccess: true }],
-    },
-    {
-      code: `
-interface Nested {
-  property: string;
-  [key: string]: number | string;
-}
-
-class Dingus {
-  nested: Nested;
-}
-
-let dingus: Dingus | undefined;
-
-dingus?.nested.property;
-dingus?.nested['hello'];
-      `,
-      options: [{ allowIndexSignaturePropertyAccess: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-    },
-    {
-      code: `
-class X {
-  private priv_prop = 123;
-}
-
-let x: X | undefined;
-console.log(x?.['priv_prop']);
-      `,
-      options: [{ allowPrivateClassPropertyAccess: true }],
-    },
-    {
-      code: `
-class X {
-  protected priv_prop = 123;
-}
-
-let x: X | undefined;
-console.log(x?.['priv_prop']);
-      `,
-      options: [{ allowProtectedClassPropertyAccess: true }],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -161,6 +33,7 @@ class X {
 const x = new X();
 x['priv_prop'] = 123;
       `,
+      errors: [{ messageId: 'useDot' }],
       options: [{ allowPrivateClassPropertyAccess: false }],
       output: `
 class X {
@@ -170,7 +43,6 @@ class X {
 const x = new X();
 x.priv_prop = 123;
       `,
-      errors: [{ messageId: 'useDot' }],
     },
     {
       code: `
@@ -181,6 +53,7 @@ class X {
 const x = new X();
 x['pub_prop'] = 123;
       `,
+      errors: [{ messageId: 'useDot' }],
       output: `
 class X {
   public pub_prop = 123;
@@ -189,7 +62,6 @@ class X {
 const x = new X();
 x.pub_prop = 123;
       `,
-      errors: [{ messageId: 'useDot' }],
     },
     //  baseRule
 
@@ -201,69 +73,69 @@ x.pub_prop = 123;
     // },
     {
       code: "a['true'];",
+      errors: [{ data: { key: q('true') }, messageId: 'useDot' }],
       output: 'a.true;',
-      errors: [{ messageId: 'useDot', data: { key: q('true') } }],
     },
     {
       code: "a['time'];",
-      output: 'a.time;',
+      errors: [{ data: { key: '"time"' }, messageId: 'useDot' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [{ messageId: 'useDot', data: { key: '"time"' } }],
+      output: 'a.time;',
     },
     {
       code: 'a[null];',
+      errors: [{ data: { key: 'null' }, messageId: 'useDot' }],
       output: 'a.null;',
-      errors: [{ messageId: 'useDot', data: { key: 'null' } }],
     },
     {
       code: 'a[true];',
+      errors: [{ data: { key: 'true' }, messageId: 'useDot' }],
       output: 'a.true;',
-      errors: [{ messageId: 'useDot', data: { key: 'true' } }],
     },
     {
       code: 'a[false];',
+      errors: [{ data: { key: 'false' }, messageId: 'useDot' }],
       output: 'a.false;',
-      errors: [{ messageId: 'useDot', data: { key: 'false' } }],
     },
     {
       code: "a['b'];",
+      errors: [{ data: { key: q('b') }, messageId: 'useDot' }],
       output: 'a.b;',
-      errors: [{ messageId: 'useDot', data: { key: q('b') } }],
     },
     {
       code: "a.b['c'];",
+      errors: [{ data: { key: q('c') }, messageId: 'useDot' }],
       output: 'a.b.c;',
-      errors: [{ messageId: 'useDot', data: { key: q('c') } }],
     },
     {
       code: "a['_dangle'];",
-      output: 'a._dangle;',
+      errors: [{ data: { key: q('_dangle') }, messageId: 'useDot' }],
       options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-      errors: [{ messageId: 'useDot', data: { key: q('_dangle') } }],
+      output: 'a._dangle;',
     },
     {
       code: "a['SHOUT_CASE'];",
-      output: 'a.SHOUT_CASE;',
+      errors: [{ data: { key: q('SHOUT_CASE') }, messageId: 'useDot' }],
       options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-      errors: [{ messageId: 'useDot', data: { key: q('SHOUT_CASE') } }],
+      output: 'a.SHOUT_CASE;',
     },
     {
       code: noFormat`
 a
   ['SHOUT_CASE'];
-      `,
-      output: `
-a
-  .SHOUT_CASE;
       `,
       errors: [
         {
-          messageId: 'useDot',
+          column: 4,
           data: { key: q('SHOUT_CASE') },
           line: 3,
-          column: 4,
+          messageId: 'useDot',
         },
       ],
+      output: `
+a
+  .SHOUT_CASE;
+      `,
     },
     {
       code:
@@ -272,75 +144,75 @@ a
         '    ["catch"](function(){})\n' +
         '    .then(function(){})\n' +
         '    ["catch"](function(){});',
-      output:
-        'getResource()\n' +
-        '    .then(function(){})\n' +
-        '    .catch(function(){})\n' +
-        '    .then(function(){})\n' +
-        '    .catch(function(){});',
       errors: [
         {
-          messageId: 'useDot',
+          column: 6,
           data: { key: q('catch') },
           line: 3,
-          column: 6,
+          messageId: 'useDot',
         },
         {
-          messageId: 'useDot',
+          column: 6,
           data: { key: q('catch') },
           line: 5,
-          column: 6,
+          messageId: 'useDot',
         },
       ],
+      output:
+        'getResource()\n' +
+        '    .then(function(){})\n' +
+        '    .catch(function(){})\n' +
+        '    .then(function(){})\n' +
+        '    .catch(function(){});',
     },
     {
       code: noFormat`
 foo
   .while;
       `,
+      errors: [{ data: { key: 'while' }, messageId: 'useBrackets' }],
+      options: [{ allowKeywords: false }],
       output: `
 foo
   ["while"];
       `,
-      options: [{ allowKeywords: false }],
-      errors: [{ messageId: 'useBrackets', data: { key: 'while' } }],
     },
     {
       code: "foo[/* comment */ 'bar'];",
+      errors: [{ data: { key: q('bar') }, messageId: 'useDot' }],
       output: null, // Not fixed due to comment
-      errors: [{ messageId: 'useDot', data: { key: q('bar') } }],
     },
     {
       code: "foo['bar' /* comment */];",
+      errors: [{ data: { key: q('bar') }, messageId: 'useDot' }],
       output: null, // Not fixed due to comment
-      errors: [{ messageId: 'useDot', data: { key: q('bar') } }],
     },
     {
       code: "foo['bar'];",
+      errors: [{ data: { key: q('bar') }, messageId: 'useDot' }],
       output: 'foo.bar;',
-      errors: [{ messageId: 'useDot', data: { key: q('bar') } }],
     },
     {
       code: 'foo./* comment */ while;',
-      output: null, // Not fixed due to comment
+      errors: [{ data: { key: 'while' }, messageId: 'useBrackets' }],
       options: [{ allowKeywords: false }],
-      errors: [{ messageId: 'useBrackets', data: { key: 'while' } }],
+      output: null, // Not fixed due to comment
     },
     {
       code: 'foo[null];',
+      errors: [{ data: { key: 'null' }, messageId: 'useDot' }],
       output: 'foo.null;',
-      errors: [{ messageId: 'useDot', data: { key: 'null' } }],
     },
     {
       code: "foo['bar'] instanceof baz;",
+      errors: [{ data: { key: q('bar') }, messageId: 'useDot' }],
       output: 'foo.bar instanceof baz;',
-      errors: [{ messageId: 'useDot', data: { key: q('bar') } }],
     },
     {
       code: 'let.if();',
-      output: null, // `let["if"]()` is a syntax error because `let[` indicates a destructuring variable declaration
+      errors: [{ data: { key: 'if' }, messageId: 'useBrackets' }],
       options: [{ allowKeywords: false }],
-      errors: [{ messageId: 'useBrackets', data: { key: 'if' } }],
+      output: null, // `let["if"]()` is a syntax error because `let[` indicates a destructuring variable declaration
     },
     {
       code: `
@@ -351,6 +223,7 @@ class X {
 const x = new X();
 x['protected_prop'] = 123;
       `,
+      errors: [{ messageId: 'useDot' }],
       options: [{ allowProtectedClassPropertyAccess: false }],
       output: `
 class X {
@@ -360,7 +233,6 @@ class X {
 const x = new X();
 x.protected_prop = 123;
       `,
-      errors: [{ messageId: 'useDot' }],
     },
     {
       code: `
@@ -372,8 +244,8 @@ class X {
 const x = new X();
 x['prop'] = 'hello';
       `,
-      options: [{ allowIndexSignaturePropertyAccess: true }],
       errors: [{ messageId: 'useDot' }],
+      options: [{ allowIndexSignaturePropertyAccess: true }],
       output: `
 class X {
   prop: string;
@@ -385,4 +257,132 @@ x.prop = 'hello';
       `,
     },
   ],
+  valid: [
+    //  baseRule
+    'a.b;',
+    'a.b.c;',
+    "a['12'];",
+    'a[b];',
+    'a[0];',
+    { code: 'a.b.c;', options: [{ allowKeywords: false }] },
+    { code: 'a.arguments;', options: [{ allowKeywords: false }] },
+    { code: 'a.let;', options: [{ allowKeywords: false }] },
+    { code: 'a.yield;', options: [{ allowKeywords: false }] },
+    { code: 'a.eval;', options: [{ allowKeywords: false }] },
+    { code: 'a[0];', options: [{ allowKeywords: false }] },
+    { code: "a['while'];", options: [{ allowKeywords: false }] },
+    { code: "a['true'];", options: [{ allowKeywords: false }] },
+    { code: "a['null'];", options: [{ allowKeywords: false }] },
+    { code: 'a[true];', options: [{ allowKeywords: false }] },
+    { code: 'a[null];', options: [{ allowKeywords: false }] },
+    { code: 'a.true;', options: [{ allowKeywords: true }] },
+    { code: 'a.null;', options: [{ allowKeywords: true }] },
+    {
+      code: "a['snake_case'];",
+      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
+    },
+    {
+      code: "a['lots_of_snake_case'];",
+      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
+    },
+    {
+      code: 'a[`time${range}`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'a[`while`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ allowKeywords: false }],
+    },
+    {
+      code: 'a[`time range`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    'a.true;',
+    'a.null;',
+    'a[undefined];',
+    'a[void 0];',
+    'a[b()];',
+    {
+      code: 'a[/(?<zero>0)/];',
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+    },
+
+    {
+      code: `
+class X {
+  private priv_prop = 123;
+}
+
+const x = new X();
+x['priv_prop'] = 123;
+      `,
+      options: [{ allowPrivateClassPropertyAccess: true }],
+    },
+
+    {
+      code: `
+class X {
+  protected protected_prop = 123;
+}
+
+const x = new X();
+x['protected_prop'] = 123;
+      `,
+      options: [{ allowProtectedClassPropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  prop: string;
+  [key: string]: number;
+}
+
+const x = new X();
+x['hello'] = 3;
+      `,
+      options: [{ allowIndexSignaturePropertyAccess: true }],
+    },
+    {
+      code: `
+interface Nested {
+  property: string;
+  [key: string]: number | string;
+}
+
+class Dingus {
+  nested: Nested;
+}
+
+let dingus: Dingus | undefined;
+
+dingus?.nested.property;
+dingus?.nested['hello'];
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ allowIndexSignaturePropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  private priv_prop = 123;
+}
+
+let x: X | undefined;
+console.log(x?.['priv_prop']);
+      `,
+      options: [{ allowPrivateClassPropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  protected priv_prop = 123;
+}
+
+let x: X | undefined;
+console.log(x?.['priv_prop']);
+      `,
+      options: [{ allowProtectedClassPropertyAccess: true }],
+    },
+  ],
 });
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 ae80f009727b..151b7e3f4c42 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
@@ -5,184 +5,395 @@ import rule from '../../src/rules/explicit-function-return-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-function-return-type', rule, {
-  valid: [
-    'return;',
+  invalid: [
     {
       code: `
-function test(): void {
+function test(a: number, b: number) {
   return;
 }
       `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 14,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-var fn = function (): number {
+function test() {
+  return;
+}
+      `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 14,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+    },
+    {
+      code: `
+var fn = function () {
   return 1;
 };
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-var arrowFn = (): string => 'test';
+var arrowFn = () => 'test';
       `,
+      errors: [
+        {
+          column: 18,
+          endColumn: 20,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
 class Test {
   constructor() {}
-  get prop(): number {
+  get prop() {
     return 1;
   }
   set prop() {}
-  method(): void {
+  method() {
+    return;
+  }
+  arrow = () => 'arrow';
+  private method() {
     return;
   }
-  arrow = (): string => 'arrow';
 }
       `,
-    },
-    {
-      code: 'fn(() => {});',
-      options: [
+      errors: [
         {
-          allowExpressions: true,
+          column: 3,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 17,
+          endLine: 12,
+          line: 12,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
-      code: 'fn(function () {});',
-      options: [
+      code: `
+function test() {
+  return;
+}
+      `,
+      errors: [
         {
-          allowExpressions: true,
+          column: 1,
+          endColumn: 14,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: '[function () {}, () => {}];',
-      options: [
+      code: 'const foo = () => {};',
+      errors: [
         {
-          allowExpressions: true,
+          column: 16,
+          endColumn: 18,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: '(function () {});',
-      options: [
+      code: 'const foo = function () {};',
+      errors: [
         {
-          allowExpressions: true,
+          column: 13,
+          endColumn: 22,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: '(() => {})();',
-      options: [
+      code: 'export default () => {};',
+      errors: [
         {
-          allowExpressions: true,
+          column: 19,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: 'export default (): void => {};',
-      options: [
+      code: 'export default function () {}',
+      errors: [
         {
-          allowExpressions: true,
+          column: 16,
+          endColumn: 25,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
       code: `
-var arrowFn: Foo = () => 'test';
+class Foo {
+  public a = () => {};
+  public b = function () {};
+  public c = function test() {};
+
+  static d = () => {};
+  static e = function () {};
+}
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 27,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowExpressions: true }],
+    },
+    {
+      code: "var arrowFn = () => 'test';",
+      errors: [
+        {
+          column: 18,
+          endColumn: 20,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-var funcExpr: Foo = function () {
-  return 'test';
-};
+function foo(): any {
+  const bar = () => () => console.log('aa');
+}
       `,
+      errors: [
+        {
+          column: 24,
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
           allowTypedFunctionExpressions: true,
         },
       ],
     },
-    {
-      code: 'const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: 'const x = <Foo>(() => {});',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
     {
       code: `
-const x = {
-  foo: () => {},
-} as Foo;
+let anyValue: any;
+function foo(): any {
+  anyValue = () => () => console.log('aa');
+}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 23,
+          endColumn: 25,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowTypedFunctionExpressions: true,
+        },
+      ],
     },
     {
       code: `
-const x = <Foo>{
-  foo: () => {},
-};
+class Foo {
+  foo(): any {
+    const bar = () => () => {
+      return console.log('foo');
+    };
+  }
+}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 26,
+          endColumn: 28,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowTypedFunctionExpressions: true,
+        },
+      ],
     },
     {
       code: `
-const x: Foo = {
-  foo: () => {},
+var funcExpr = function () {
+  return 'test';
 };
       `,
+      errors: [
+        {
+          column: 16,
+          endColumn: 25,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowTypedFunctionExpressions: true }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
+
     {
-      code: `
-const x = {
-  foo: { bar: () => {} },
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: 'const x = (() => {}) as Foo;',
+      errors: [
+        {
+          column: 15,
+          endColumn: 17,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
-const x = <Foo>{
-  foo: { bar: () => {} },
-};
+interface Foo {}
+const x = {
+  foo: () => {},
+} as Foo;
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
+interface Foo {}
 const x: Foo = {
-  foo: { bar: () => {} },
+  foo: () => {},
 };
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/484
-    {
-      code: `
-type MethodType = () => void;
-
-class App {
-  private method: MethodType = () => {};
-}
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/7552
     {
       code: 'const foo = <button onClick={() => {}} />;',
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 33,
+          endColumn: 35,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -190,10 +401,19 @@ class App {
           },
         },
       },
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 27,
+          endColumn: 34,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -201,10 +421,19 @@ class App {
           },
         },
       },
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -212,10 +441,19 @@ class App {
           },
         },
       },
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 21,
+          endColumn: 25,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -223,10 +461,19 @@ class App {
           },
         },
       },
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 27,
+          endColumn: 36,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -234,96 +481,162 @@ class App {
           },
         },
       },
-    },
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/525
-    {
-      code: `
-const myObj = {
-  set myProp(val) {
-    this.myProp = val;
-  },
-};
-      `,
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
-() => (): void => {};
+function foo(): any {
+  class Foo {
+    foo = () => () => {
+      return console.log('foo');
+    };
+  }
+}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 20,
+          endColumn: 22,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowTypedFunctionExpressions: true,
+        },
+      ],
     },
     {
-      code: `
-() => function (): void {};
-      `,
+      code: '() => () => {};',
+      errors: [
+        {
+          column: 10,
+          endColumn: 12,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: `
-() => {
-  return (): void => {};
-};
-      `,
+      code: '() => function () {};',
+      errors: [
+        {
+          column: 7,
+          endColumn: 16,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  return function (): void {};
+  return () => {};
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  const foo = 'foo';
-  return function (): string {
-    return foo;
-  };
+  return function () {};
 };
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return (): void => {};
+  return () => {};
 }
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return function (): void {};
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
   const bar = () => (): number => 1;
+  const baz = () => () => 'baz';
   return function (): void {};
 }
       `,
+      errors: [
+        {
+          column: 24,
+          endColumn: 26,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn(arg: boolean) {
-  if (arg) {
-    return () => (): number => 1;
-  } else {
-    return function (): string {
-      return 'foo';
-    };
-  }
-
+  if (arg) return 'string';
   return function (): void {};
 }
       `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 12,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -335,23 +648,41 @@ function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number =>
+          () =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => () => {
-  return (): void => {
+  return () => {
     return;
   };
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/679
@@ -364,24 +695,46 @@ foo(() => null);
 foo(() => true);
 foo(() => '');
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 8,
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-declare function foo(arg: () => void): void;
-foo?.(() => 1);
-foo?.bar(() => {});
-foo?.bar?.(() => null);
-foo.bar?.(() => true);
-foo?.(() => '');
-      `,
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
@@ -397,9 +750,35 @@ class Accumulator {
 
 new Accumulator().accumulate(() => 1);
       `,
+      errors: [
+        {
+          column: 33,
+          endColumn: 35,
+          endLine: 10,
+          line: 10,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
+        },
+      ],
+    },
+    {
+      code: '(() => true)();',
+      errors: [
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
@@ -422,177 +801,32 @@ foo({
   },
 });
       `,
-      options: [
-        {
-          allowTypedFunctionExpressions: true,
-        },
-      ],
-    },
-    {
-      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) => x as const;
-      `,
-      options: [
-        {
-          allowDirectConstAssertionInArrowFunctions: true,
-        },
-      ],
-    },
-    {
-      code: `
-new Promise(resolve => {});
-new Foo(1, () => {});
-      `,
-      options: [
-        {
-          allowTypedFunctionExpressions: true,
-        },
-      ],
-    },
-    {
-      code: 'const log = (message: string) => void console.log(message);',
-      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
-    },
-    {
-      code: 'const log = (a: string) => a;',
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      code: 'const log = <A,>(a: A): A => a;',
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      code: `
-function log<A>(a: A): A {
-  return a;
-}
-      `,
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      code: `
-function log(a: string) {
-  return a;
-}
-      `,
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      code: `
-const log = function <A>(a: A): A {
-  return a;
-};
-      `,
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      code: `
-const log = function (a: A): string {
-  return a;
-};
-      `,
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
-    {
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-      code: `
-function test1() {
-  return;
-}
-
-const foo = function test2() {
-  return;
-};
-      `,
-    },
-    {
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-      code: `
-const test1 = function () {
-  return;
-};
-const foo = function () {
-  return function test2() {};
-};
-      `,
-    },
-    {
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-      code: `
-const test1 = () => {
-  return;
-};
-export const foo = {
-  test2() {
-    return 0;
-  },
-};
-      `,
-    },
-    {
-      code: `
-class Test {
-  constructor() {}
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  arrow = () => 'arrow';
-  private method() {
-    return;
-  }
-}
-      `,
-      options: [
+      errors: [
         {
-          allowedNames: ['prop', 'method', 'arrow'],
-        },
-      ],
-    },
-    {
-      code: `
-const x = {
-  arrowFn: () => {
-    return;
-  },
-  fn: function () {
-    return;
-  },
-};
-      `,
-      options: [
+          column: 3,
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
         {
-          allowedNames: ['arrowFn', 'fn'],
+          column: 3,
+          endColumn: 18,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 14,
+          line: 14,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
-      `,
       options: [
         {
-          allowTypedFunctionExpressions: true,
-          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
@@ -601,590 +835,583 @@ const x: HigherOrderType = () => arg1 => arg2 => 'foo';
 type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
 const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
-          allowHigherOrderFunctions: false,
+          column: 47,
+          endColumn: 49,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-interface Foo {
-  foo: string;
-  arrowFn: () => string;
-}
-
-function foo(): Foo {
-  return {
-    foo: 'foo',
-    arrowFn: () => 'test',
-  };
-}
-      `,
       options: [
         {
-          allowTypedFunctionExpressions: true,
           allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
       code: `
-type Foo = (arg1: string) => string;
-type Bar<T> = (arg2: string) => T;
-const x: Bar<Foo> = arg1 => arg2 => arg1 + arg2;
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
-          allowHigherOrderFunctions: true,
+          column: 31,
+          endColumn: 33,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-let foo = function (): number {
-  return 1;
-};
-      `,
-      options: [
         {
-          allowIIFEs: true,
+          column: 39,
+          endColumn: 41,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-const foo = (function () {
-  return 1;
-})();
-      `,
-      options: [
         {
-          allowIIFEs: true,
+          column: 47,
+          endColumn: 49,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-const foo = (() => {
-  return 1;
-})();
-      `,
       options: [
         {
-          allowIIFEs: true,
+          allowHigherOrderFunctions: false,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
       code: `
-const foo = ((arg: number): number => {
-  return arg;
-})(0);
+const func = (value: number) => ({ type: 'X', value }) as any;
+const func = (value: number) => ({ type: 'X', value }) as Action;
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 30,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-const foo = (() => (() => 'foo')())();
-      `,
-      options: [
         {
-          allowIIFEs: true,
+          column: 30,
+          endColumn: 32,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-let foo = (() => (): string => {
-  return 'foo';
-})()();
-      `,
       options: [
         {
-          allowIIFEs: true,
+          allowDirectConstAssertionInArrowFunctions: true,
         },
       ],
     },
     {
       code: `
-let foo = (() => (): string => {
-  return 'foo';
-})();
+const func = (value: number) => ({ type: 'X', value }) as const;
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
-          allowHigherOrderFunctions: false,
+          column: 30,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-let foo = (() => (): string => {
-  return 'foo';
-})()();
-      `,
       options: [
         {
-          allowIIFEs: true,
-          allowHigherOrderFunctions: true,
+          allowDirectConstAssertionInArrowFunctions: false,
         },
       ],
     },
     {
-      code: `
-let foo = (() => (): void => {})()();
-      `,
-      options: [
+      code: 'const log = (message: string) => void console.log(message);',
+      errors: [
         {
-          allowIIFEs: true,
+          column: 31,
+          endColumn: 33,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [
+        { allowConciseArrowFunctionExpressionsStartingWithVoid: false },
+      ],
     },
     {
       code: `
-let foo = (() => (() => {})())();
+        const log = (message: string) => {
+          void console.log(message);
+        };
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 39,
+          endColumn: 41,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
     },
     {
-      code: `
-class Bar {
-  bar: Foo = {
-    foo: x => x + 1,
-  };
-}
-      `,
+      code: 'const log = <A,>(a: A) => a;',
+      errors: [{ messageId: 'missingReturnType' }],
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-class Bar {
-  bar: Foo[] = [
-    {
-      foo: x => x + 1,
-    },
-  ];
+function log<A>(a: A) {
+  return a;
 }
       `,
+      errors: [{ messageId: 'missingReturnType' }],
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-type CallBack = () => void;
-
-function f(gotcha: CallBack = () => {}): void {}
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-type CallBack = () => void;
-
-const f = (gotcha: CallBack = () => {}): void => {};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-type ObjectWithCallback = { callback: () => void };
-
-const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
+const log = function <A>(a: A) {
+  return a;
+};
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [{ messageId: 'missingReturnType' }],
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
-  ],
-
-  invalid: [
     {
       code: `
-function test(a: number, b: number) {
+function hoge() {
+  return;
+}
+const foo = () => {
+  return;
+};
+const baz = function () {
+  return;
+};
+let [test, test] = function () {
   return;
+};
+class X {
+  [test] = function () {
+    return;
+  };
 }
+const x = {
+  1: function () {
+    reutrn;
+  },
+};
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
           column: 1,
           endColumn: 14,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 16,
+          endColumn: 18,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 13,
+          endColumn: 22,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 20,
+          endColumn: 29,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 21,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 15,
+          endLine: 20,
+          line: 20,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowedNames: ['test', '1'],
         },
       ],
     },
     {
       code: `
-function test() {
-  return;
+const ignoredName = 'notIgnoredName';
+class Foo {
+  [ignoredName]() {}
 }
       `,
       errors: [
         {
+          column: 3,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
           messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 1,
-          endColumn: 14,
         },
       ],
+      options: [{ allowedNames: ['ignoredName'] }],
     },
     {
       code: `
-var fn = function () {
-  return 1;
-};
+class Bar {
+  bar = [
+    {
+      foo: x => x + 1,
+    },
+  ];
+}
       `,
       errors: [
         {
+          column: 7,
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
           messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 10,
-          endColumn: 19,
         },
       ],
     },
     {
       code: `
-var arrowFn = () => 'test';
+const foo = (function () {
+  return 'foo';
+})();
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
+          column: 14,
+          endColumn: 23,
           endLine: 2,
-          column: 18,
-          endColumn: 20,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowIIFEs: false,
         },
       ],
     },
     {
       code: `
-class Test {
-  constructor() {}
-  get prop() {
+const foo = (function () {
+  return () => {
     return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  arrow = () => 'arrow';
-  private method() {
-    return;
-  }
-}
+  };
+})();
       `,
       errors: [
         {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
           messageId: 'missingReturnType',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 11,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 9,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 11,
-          column: 3,
-          endLine: 11,
-          endColumn: 11,
         },
+      ],
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 12,
-          column: 3,
-          endLine: 12,
-          endColumn: 17,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-function test() {
-  return;
-}
+let foo = function () {
+  return 'foo';
+};
       `,
-      options: [{ allowExpressions: true }],
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
+          column: 11,
+          endColumn: 20,
           endLine: 2,
-          column: 1,
-          endColumn: 14,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: 'const foo = () => {};',
-      options: [{ allowExpressions: true }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 16,
-          endColumn: 18,
+          allowIIFEs: true,
         },
       ],
     },
     {
-      code: 'const foo = function () {};',
-      options: [{ allowExpressions: true }],
+      code: `
+let foo = (() => () => {})()();
+      `,
       errors: [
         {
+          column: 21,
+          endColumn: 23,
+          endLine: 2,
+          line: 2,
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 13,
-          endColumn: 22,
         },
       ],
-    },
-    {
-      code: 'export default () => {};',
-      options: [{ allowExpressions: true }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 19,
-          endColumn: 21,
+          allowIIFEs: true,
         },
       ],
     },
     {
-      code: 'export default function () {}',
-      options: [{ allowExpressions: true }],
+      code: `
+type CallBack = () => void;
+
+function f(gotcha: CallBack = () => {}): void {}
+      `,
       errors: [
         {
+          column: 34,
+          endColumn: 36,
+          endLine: 4,
+          line: 4,
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 16,
-          endColumn: 25,
         },
       ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
-class Foo {
-  public a = () => {};
-  public b = function () {};
-  public c = function test() {};
+type CallBack = () => void;
 
-  static d = () => {};
-  static e = function () {};
-}
+const f = (gotcha: CallBack = () => {}): void => {};
       `,
-      options: [{ allowExpressions: true }],
       errors: [
         {
+          column: 34,
+          endColumn: 36,
+          endLine: 4,
+          line: 4,
           messageId: 'missingReturnType',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 14,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 23,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 5,
-          column: 3,
-          endLine: 5,
-          endColumn: 27,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 7,
-          column: 3,
-          endLine: 7,
-          endColumn: 14,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 23,
         },
       ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
-      code: "var arrowFn = () => 'test';",
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: `
+type ObjectWithCallback = { callback: () => void };
+
+const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
+      `,
       errors: [
         {
+          column: 43,
+          line: 4,
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 18,
-          endColumn: 20,
         },
       ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
+  ],
+
+  valid: [
+    'return;',
     {
       code: `
-function foo(): any {
-  const bar = () => () => console.log('aa');
+function test(): void {
+  return;
+}
+      `,
+    },
+    {
+      code: `
+var fn = function (): number {
+  return 1;
+};
+      `,
+    },
+    {
+      code: `
+var arrowFn = (): string => 'test';
+      `,
+    },
+    {
+      code: `
+class Test {
+  constructor() {}
+  get prop(): number {
+    return 1;
+  }
+  set prop() {}
+  method(): void {
+    return;
+  }
+  arrow = (): string => 'arrow';
 }
       `,
+    },
+    {
+      code: 'fn(() => {});',
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowExpressions: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: 'fn(function () {});',
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 24,
-          endColumn: 26,
+          allowExpressions: true,
         },
       ],
     },
     {
-      code: `
-let anyValue: any;
-function foo(): any {
-  anyValue = () => () => console.log('aa');
-}
-      `,
+      code: '[function () {}, () => {}];',
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowExpressions: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: '(function () {});',
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 23,
-          endColumn: 25,
+          allowExpressions: true,
         },
       ],
     },
     {
-      code: `
-class Foo {
-  foo(): any {
-    const bar = () => () => {
-      return console.log('foo');
-    };
-  }
-}
-      `,
+      code: '(() => {})();',
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowExpressions: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: 'export default (): void => {};',
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 26,
-          endColumn: 28,
+          allowExpressions: true,
         },
       ],
     },
     {
       code: `
-var funcExpr = function () {
-  return 'test';
-};
+var arrowFn: Foo = () => 'test';
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 16,
-          endColumn: 25,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
-
     {
-      code: 'const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
+      code: `
+var funcExpr: Foo = function () {
+  return 'test';
+};
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 15,
-          endColumn: 17,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
+    {
+      code: 'const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: 'const x = <Foo>(() => {});',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
     {
       code: `
-interface Foo {}
 const x = {
   foo: () => {},
 } as Foo;
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 3,
-          endColumn: 8,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+const x = <Foo>{
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-interface Foo {}
 const x: Foo = {
   foo: () => {},
 };
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 3,
-          endColumn: 8,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
+    {
+      code: `
+const x = {
+  foo: { bar: () => {} },
+} as Foo;
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+const x = <Foo>{
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+const x: Foo = {
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/484
+    {
+      code: `
+type MethodType = () => void;
+
+class App {
+  private method: MethodType = () => {};
+}
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/7552
     {
       code: 'const foo = <button onClick={() => {}} />;',
-      options: [{ allowTypedFunctionExpressions: false }],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1192,19 +1419,10 @@ const x: Foo = {
           },
         },
       },
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 33,
-          endColumn: 35,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
-      options: [{ allowTypedFunctionExpressions: false }],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1212,39 +1430,21 @@ const x: Foo = {
           },
         },
       },
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 27,
-          endColumn: 34,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
-      options: [{ allowTypedFunctionExpressions: false }],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 22,
-          endColumn: 24,
+            jsx: true,
+          },
         },
-      ],
+      },
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
-      options: [{ allowTypedFunctionExpressions: false }],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1252,19 +1452,10 @@ const x: Foo = {
           },
         },
       },
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 21,
-          endColumn: 25,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
-      options: [{ allowTypedFunctionExpressions: false }],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1272,171 +1463,98 @@ const x: Foo = {
           },
         },
       },
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 27,
-          endColumn: 36,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/525
     {
       code: `
-function foo(): any {
-  class Foo {
-    foo = () => () => {
-      return console.log('foo');
-    };
-  }
-}
+const myObj = {
+  set myProp(val) {
+    this.myProp = val;
+  },
+};
       `,
-      options: [
-        {
-          allowTypedFunctionExpressions: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 20,
-          endColumn: 22,
-        },
-      ],
     },
     {
-      code: '() => () => {};',
+      code: `
+() => (): void => {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 10,
-          endColumn: 12,
-        },
-      ],
     },
     {
-      code: '() => function () {};',
+      code: `
+() => function (): void {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 7,
-          endColumn: 16,
-        },
-      ],
     },
     {
       code: `
 () => {
-  return () => {};
+  return (): void => {};
 };
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
     {
       code: `
 () => {
-  return function () {};
+  return function (): void {};
+};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: `
+() => {
+  const foo = 'foo';
+  return function (): string {
+    return foo;
+  };
 };
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 10,
-          endColumn: 19,
-        },
-      ],
     },
     {
       code: `
 function fn() {
-  return () => {};
+  return (): void => {};
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
     {
       code: `
 function fn() {
-  return function () {};
+  return function (): void {};
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 10,
-          endColumn: 19,
-        },
-      ],
     },
     {
       code: `
 function fn() {
   const bar = () => (): number => 1;
-  const baz = () => () => 'baz';
   return function (): void {};
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 24,
-          endColumn: 26,
-        },
-      ],
     },
     {
       code: `
 function fn(arg: boolean) {
-  if (arg) return 'string';
+  if (arg) {
+    return () => (): number => 1;
+  } else {
+    return function (): string {
+      return 'foo';
+    };
+  }
+
   return function (): void {};
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 1,
-          endColumn: 12,
-        },
-      ],
     },
     {
       code: `
@@ -1447,7 +1565,7 @@ function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          () =>
+          (): number =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
@@ -1455,34 +1573,16 @@ function FunctionDeclaration() {
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 9,
-          endLine: 9,
-          column: 14,
-          endColumn: 16,
-        },
-      ],
     },
     {
       code: `
 () => () => {
-  return () => {
+  return (): void => {
     return;
   };
 };
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/679
     {
@@ -1496,44 +1596,22 @@ foo(() => '');
       `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
+          allowTypedFunctionExpressions: true,
         },
       ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          column: 8,
-          endLine: 3,
-          endColumn: 10,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 8,
-          endLine: 4,
-          endColumn: 10,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 5,
-          column: 8,
-          endLine: 5,
-          endColumn: 10,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 6,
-          column: 8,
-          endLine: 6,
-          endColumn: 10,
-        },
+    },
+    {
+      code: `
+declare function foo(arg: () => void): void;
+foo?.(() => 1);
+foo?.bar(() => {});
+foo?.bar?.(() => null);
+foo.bar?.(() => true);
+foo?.(() => '');
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 7,
-          column: 8,
-          endLine: 7,
-          endColumn: 10,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
@@ -1544,40 +1622,14 @@ class Accumulator {
 
   public accumulate(fn: () => number): void {
     this.count += fn();
-  }
-}
-
-new Accumulator().accumulate(() => 1);
-      `,
-      options: [
-        {
-          allowTypedFunctionExpressions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 10,
-          endLine: 10,
-          column: 33,
-          endColumn: 35,
-        },
-      ],
-    },
-    {
-      code: '(() => true)();',
+  }
+}
+
+new Accumulator().accumulate(() => 1);
+      `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 5,
-          endColumn: 7,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
@@ -1602,403 +1654,367 @@ foo({
       `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 7,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 9,
-          column: 3,
-          endLine: 9,
-          endColumn: 18,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 14,
-          column: 3,
-          endLine: 14,
-          endColumn: 9,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
+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: [
         {
-          allowTypedFunctionExpressions: false,
-          allowHigherOrderFunctions: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 47,
-          endColumn: 49,
+          allowDirectConstAssertionInArrowFunctions: true,
         },
       ],
     },
     {
       code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
+new Promise(resolve => {});
+new Foo(1, () => {});
       `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
-          allowHigherOrderFunctions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 31,
-          endColumn: 33,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 39,
-          endColumn: 41,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 47,
-          endColumn: 49,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
+    {
+      code: 'const log = (message: string) => void console.log(message);',
+      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
+    },
+    {
+      code: 'const log = (a: string) => a;',
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: 'const log = <A,>(a: A): A => a;',
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
     {
       code: `
-const func = (value: number) => ({ type: 'X', value }) as any;
-const func = (value: number) => ({ type: 'X', value }) as Action;
+function log<A>(a: A): A {
+  return a;
+}
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+function log(a: string) {
+  return a;
+}
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+const log = function <A>(a: A): A {
+  return a;
+};
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+const log = function (a: A): string {
+  return a;
+};
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+function test1() {
+  return;
+}
+
+const foo = function test2() {
+  return;
+};
       `,
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 30,
-          endColumn: 32,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 30,
-          endColumn: 32,
+          allowedNames: ['test1', 'test2'],
         },
       ],
     },
     {
       code: `
-const func = (value: number) => ({ type: 'X', value }) as const;
+const test1 = function () {
+  return;
+};
+const foo = function () {
+  return function test2() {};
+};
       `,
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 30,
-          endColumn: 32,
+          allowedNames: ['test1', 'test2'],
         },
       ],
     },
     {
-      code: 'const log = (message: string) => void console.log(message);',
+      code: `
+const test1 = () => {
+  return;
+};
+export const foo = {
+  test2() {
+    return 0;
+  },
+};
+      `,
       options: [
-        { allowConciseArrowFunctionExpressionsStartingWithVoid: false },
-      ],
-      errors: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 31,
-          endColumn: 33,
+          allowedNames: ['test1', 'test2'],
         },
       ],
     },
     {
       code: `
-        const log = (message: string) => {
-          void console.log(message);
-        };
+class Test {
+  constructor() {}
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
+    return;
+  }
+  arrow = () => 'arrow';
+  private method() {
+    return;
+  }
+}
       `,
-      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 39,
-          endColumn: 41,
+          allowedNames: ['prop', 'method', 'arrow'],
         },
       ],
     },
-    {
-      code: 'const log = <A,>(a: A) => a;',
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
-    },
     {
       code: `
-function log<A>(a: A) {
-  return a;
-}
+const x = {
+  arrowFn: () => {
+    return;
+  },
+  fn: function () {
+    return;
+  },
+};
       `,
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      options: [
+        {
+          allowedNames: ['arrowFn', 'fn'],
+        },
+      ],
     },
     {
       code: `
-const log = function <A>(a: A) {
-  return a;
-};
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      options: [
+        {
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: true,
+        },
+      ],
     },
     {
+      code: `
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
+      `,
       options: [
         {
-          allowedNames: ['test', '1'],
+          allowHigherOrderFunctions: false,
+          allowTypedFunctionExpressions: true,
         },
       ],
+    },
+    {
       code: `
-function hoge() {
-  return;
+interface Foo {
+  foo: string;
+  arrowFn: () => string;
 }
-const foo = () => {
-  return;
-};
-const baz = function () {
-  return;
-};
-let [test, test] = function () {
-  return;
-};
-class X {
-  [test] = function () {
-    return;
+
+function foo(): Foo {
+  return {
+    foo: 'foo',
+    arrowFn: () => 'test',
   };
 }
-const x = {
-  1: function () {
-    reutrn;
-  },
-};
       `,
-      errors: [
-        {
-          line: 2,
-          column: 1,
-          messageId: 'missingReturnType',
-          endLine: 2,
-          endColumn: 14,
-        },
-        {
-          line: 5,
-          column: 16,
-          messageId: 'missingReturnType',
-          endLine: 5,
-          endColumn: 18,
-        },
-        {
-          line: 8,
-          column: 13,
-          messageId: 'missingReturnType',
-          endLine: 8,
-          endColumn: 22,
-        },
-        {
-          line: 11,
-          column: 20,
-          messageId: 'missingReturnType',
-          endLine: 11,
-          endColumn: 29,
-        },
+      options: [
         {
-          line: 15,
-          column: 3,
-          messageId: 'missingReturnType',
-          endLine: 15,
-          endColumn: 21,
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      code: `
+type Foo = (arg1: string) => string;
+type Bar<T> = (arg2: string) => T;
+const x: Bar<Foo> = arg1 => arg2 => arg1 + arg2;
+      `,
+      options: [
         {
-          line: 20,
-          column: 3,
-          messageId: 'missingReturnType',
-          endLine: 20,
-          endColumn: 15,
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-const ignoredName = 'notIgnoredName';
-class Foo {
-  [ignoredName]() {}
-}
+let foo = function (): number {
+  return 1;
+};
       `,
-      options: [{ allowedNames: ['ignoredName'] }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
-          column: 3,
-          endColumn: 16,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-class Bar {
-  bar = [
-    {
-      foo: x => x + 1,
-    },
-  ];
-}
+const foo = (function () {
+  return 1;
+})();
       `,
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 5,
-          endLine: 5,
-          column: 7,
-          endColumn: 12,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-const foo = (function () {
-  return 'foo';
+const foo = (() => {
+  return 1;
 })();
       `,
       options: [
         {
-          allowIIFEs: false,
+          allowIIFEs: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+const foo = ((arg: number): number => {
+  return arg;
+})(0);
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 14,
-          endColumn: 23,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-const foo = (function () {
-  return () => {
-    return 1;
-  };
-})();
+const foo = (() => (() => 'foo')())();
       `,
       options: [
         {
           allowIIFEs: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+let foo = (() => (): string => {
+  return 'foo';
+})()();
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-let foo = function () {
+let foo = (() => (): string => {
   return 'foo';
-};
+})();
       `,
       options: [
         {
+          allowHigherOrderFunctions: false,
           allowIIFEs: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+let foo = (() => (): string => {
+  return 'foo';
+})()();
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 11,
-          endColumn: 20,
+          allowHigherOrderFunctions: true,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-let foo = (() => () => {})()();
+let foo = (() => (): void => {})()();
       `,
       options: [
         {
           allowIIFEs: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+let foo = (() => (() => {})())();
+      `,
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 21,
-          endColumn: 23,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
+class Bar {
+  bar: Foo = {
+    foo: x => x + 1,
+  };
+}
+      `,
+    },
+    {
+      code: `
+class Bar {
+  bar: Foo[] = [
+    {
+      foo: x => x + 1,
+    },
+  ];
+}
+      `,
+    },
+    {
+      code: `
 type CallBack = () => void;
 
 function f(gotcha: CallBack = () => {}): void {}
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 34,
-          endLine: 4,
-          endColumn: 36,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
@@ -2006,16 +2022,7 @@ type CallBack = () => void;
 
 const f = (gotcha: CallBack = () => {}): void => {};
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 34,
-          endLine: 4,
-          endColumn: 36,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
@@ -2023,14 +2030,7 @@ type ObjectWithCallback = { callback: () => void };
 
 const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 43,
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
   ],
 });
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 000981497e59..d02c8ea8c7ea 100644
--- a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
@@ -5,71 +5,162 @@ import rule from '../../src/rules/explicit-member-accessibility';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-member-accessibility', rule, {
-  valid: [
+  invalid: [
     {
       code: `
-class Test {
-  public constructor(private foo: string) {}
+export class XXXX {
+  public constructor(readonly value: string) {}
 }
       `,
-      options: [
+      errors: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(private readonly foo: string) {}
+          column: 22,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(public readonly value: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(private readonly value: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(protected readonly value: string) {}
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
+          accessibility: 'off',
+          overrides: {
+            parameterProperties: 'explicit',
+          },
         },
       ],
+      output: null,
     },
     {
       code: `
-class Test {
-  public constructor(private foo: string) {}
+export class WithParameterProperty {
+  public constructor(readonly value: string) {}
 }
       `,
-      options: [
+      errors: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
+          column: 22,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(public readonly value: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(private readonly value: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(protected readonly value: string) {}
+}
+      `,
+            },
+          ],
         },
       ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
     },
     {
       code: `
-class Test {
-  public constructor(protected foo: string) {}
+export class XXXX {
+  public constructor(readonly samosa: string) {}
 }
       `,
-      options: [
+      errors: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(public foo: string) {}
+          column: 22,
+          endColumn: 37,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(public readonly samosa: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(private readonly samosa: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class XXXX {
+  public constructor(protected readonly samosa: string) {}
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
+          accessibility: 'off',
+          overrides: {
+            constructors: 'explicit',
+            parameterProperties: 'explicit',
+          },
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -77,576 +168,796 @@ class Test {
   public constructor(readonly foo: string) {}
 }
       `,
-      options: [
+      errors: [
         {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
+          column: 22,
+          endColumn: 34,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(public readonly foo: string) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
   public constructor(private readonly foo: string) {}
 }
       `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(protected readonly foo: string) {}
+}
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
+          overrides: { parameterProperties: 'explicit' },
         },
       ],
+      output: null,
     },
     {
       code: `
 class Test {
-  protected name: string;
-  private x: number;
+  x: number;
   public getX() {
     return this.x;
   }
 }
       `,
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  public 'foo-bar'?: string;
-}
-      `,
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'x',
+            type: 'class property',
+          },
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+
+              output: `
 class Test {
-  public constructor({ x, y }: { x: number; y: number }) {}
+  public x: number;
+  public getX() {
+    return this.x;
+  }
 }
       `,
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+
+              output: `
 class Test {
-  protected name: string;
-  protected foo?: string;
+  private x: number;
   public getX() {
     return this.x;
   }
 }
       `,
-      options: [{ accessibility: 'explicit' }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+
+              output: `
 class Test {
-  protected name: string;
-  protected foo?: string;
-  getX() {
+  protected x: number;
+  public getX() {
     return this.x;
   }
 }
       `,
-      options: [{ accessibility: 'no-public' }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 class Test {
-  name: string;
-  foo?: string;
+  private x: number;
   getX() {
     return this.x;
   }
-  get fooName(): string {
-    return this.foo + ' ' + this.name;
-  }
 }
       `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
   private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  public getX() {
     return this.x;
   }
-  private set internalValue(value: number) {
-    this.x = value;
-  }
-  public square(): number {
-    return this.x * this.x;
-  }
 }
       `,
-      options: [{ overrides: { constructors: 'off', accessors: 'off' } }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
   private x: number;
-  public constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
+  private getX() {
     return this.x;
   }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
-  public square(): number {
-    return this.x * this.x;
-  }
-  half(): number {
-    return this.x / 2;
-  }
 }
       `,
-      options: [{ overrides: { methods: 'off' } }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  constructor(private x: number) {}
+  private x: number;
+  protected getX() {
+    return this.x;
+  }
 }
       `,
-      options: [{ accessibility: 'no-public' }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 class Test {
-  constructor(public x: number) {}
+  x?: number;
+  getX?() {
+    return this.x;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
+          column: 3,
+          data: {
+            name: 'x',
+            type: 'class property',
+          },
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  constructor(public foo: number) {}
+  public x?: number;
+  getX?() {
+    return this.x;
+  }
 }
       `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  public getX() {
+  private x?: number;
+  getX?() {
     return this.x;
   }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  public static getX() {
+  protected x?: number;
+  getX?() {
     return this.x;
   }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
+            },
+          ],
+        },
+        {
+          column: 3,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  get getX() {
+  x?: number;
+  public getX?() {
     return this.x;
   }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  getX() {
+  x?: number;
+  private getX?() {
     return this.x;
   }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  x = 2;
+  x?: number;
+  protected getX?() {
+    return this.x;
+  }
 }
       `,
-      options: [{ overrides: { properties: 'off' } }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 class Test {
-  private x = 2;
+  protected name: string;
+  protected foo?: string;
+  public getX() {
+    return this.x;
+  }
 }
       `,
-      options: [{ overrides: { properties: 'explicit' } }],
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 9,
+          endLine: 5,
+          line: 5,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [{ accessibility: 'no-public' }],
+      output: `
 class Test {
-  x = 2;
-  private x = 2;
+  protected name: string;
+  protected foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
-      options: [{ overrides: { properties: 'no-public' } }],
     },
     {
       code: `
 class Test {
-  constructor(private { x }: any[]) {}
+  protected name: string;
+  public foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    // private members
-    {
-      code: `
-class Test {
-  #foo = 1;
-  #bar() {}
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'foo',
+            type: 'class property',
+          },
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [{ accessibility: 'no-public' }],
+      output: `
+class Test {
+  protected name: string;
+  foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
-      options: [{ accessibility: 'explicit' }],
     },
-  ],
-  invalid: [
     {
       code: `
-export class XXXX {
-  public constructor(readonly value: string) {}
+class Test {
+  public x: number;
+  public getX() {
+    return this.x;
+  }
 }
       `,
-      output: null,
-      options: [
+      errors: [
         {
-          accessibility: 'off',
-          overrides: {
-            parameterProperties: 'explicit',
-          },
+          column: 3,
+          endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
+      options: [{ accessibility: 'no-public' }],
+      output: `
+class Test {
+  x: number;
+  getX() {
+    return this.x;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
       errors: [
         {
+          column: 3,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
           messageId: 'missingAccessibility',
-          line: 3,
-          column: 22,
-          endLine: 3,
-          endColumn: 36,
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(public readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(private readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  private get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(protected readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  protected get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-export class WithParameterProperty {
-  public constructor(readonly value: string) {}
-}
-      `,
-      output: null,
-      options: [{ accessibility: 'explicit' }],
-      errors: [
         {
+          column: 3,
+          endColumn: 20,
+          endLine: 10,
+          line: 10,
           messageId: 'missingAccessibility',
-          line: 3,
-          column: 22,
-          endLine: 3,
-          endColumn: 36,
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class WithParameterProperty {
-  public constructor(public readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class WithParameterProperty {
-  public constructor(private readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class WithParameterProperty {
-  public constructor(protected readonly value: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  protected set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
       ],
+      options: [{ overrides: { constructors: 'no-public' } }],
+      output: null,
     },
     {
       code: `
-export class XXXX {
-  public constructor(readonly samosa: string) {}
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
-      output: null,
-      options: [
-        {
-          accessibility: 'off',
-          overrides: {
-            constructors: 'explicit',
-            parameterProperties: 'explicit',
-          },
-        },
-      ],
       errors: [
         {
+          column: 3,
+          endColumn: 14,
+          endLine: 4,
+          line: 4,
           messageId: 'missingAccessibility',
-          line: 3,
-          column: 22,
-          endLine: 3,
-          endColumn: 37,
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(public readonly samosa: string) {}
+class Test {
+  private x: number;
+  public constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(private readonly samosa: string) {}
+class Test {
+  private x: number;
+  private constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
-export class XXXX {
-  public constructor(protected readonly samosa: string) {}
+class Test {
+  private x: number;
+  protected constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(readonly foo: string) {}
-}
-      `,
-      output: null,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
-        },
-      ],
-      errors: [
         {
+          column: 3,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
           messageId: 'missingAccessibility',
-          line: 3,
-          column: 22,
-          endLine: 3,
-          endColumn: 34,
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(public readonly foo: string) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(private readonly foo: string) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  private get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(protected readonly foo: string) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  protected get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-class Test {
-  x: number;
-  public getX() {
-    return this.x;
-  }
-}
-      `,
-      output: null,
-      errors: [
         {
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'class property',
-            name: 'x',
-          },
-          line: 3,
           column: 3,
-          endLine: 3,
-          endColumn: 4,
+          endColumn: 20,
+          endLine: 10,
+          line: 10,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
-
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public x: number;
-  public getX() {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
     return this.x;
   }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
-
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
   private x: number;
-  public getX() {
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
     return this.x;
   }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
-
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  protected x: number;
-  public getX() {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
     return this.x;
   }
+  protected set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
 class Test {
-  private x: number;
-  getX() {
-    return this.x;
+  constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
   }
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'method definition',
-            name: 'getX',
-          },
-          line: 4,
           column: 3,
-          endLine: 4,
-          endColumn: 7,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  public getX() {
-    return this.x;
+  public constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
   }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  private getX() {
-    return this.x;
+  private constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
   }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  protected getX() {
-    return this.x;
+  protected constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
   }
 }
       `,
@@ -654,1021 +965,396 @@ class Test {
           ],
         },
       ],
+      options: [
+        {
+          overrides: { parameterProperties: 'no-public' },
+        },
+      ],
+      output: null,
     },
     {
       code: `
 class Test {
-  x?: number;
-  getX?() {
-    return this.x;
-  }
+  constructor(public x: number) {}
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'class property',
-            name: 'x',
-          },
-          line: 3,
           column: 3,
+          endColumn: 14,
           endLine: 3,
-          endColumn: 4,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public x?: number;
-  getX?() {
-    return this.x;
-  }
+  public constructor(public x: number) {}
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x?: number;
-  getX?() {
-    return this.x;
-  }
+  private constructor(public x: number) {}
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  protected x?: number;
-  getX?() {
-    return this.x;
-  }
+  protected constructor(public x: number) {}
 }
       `,
             },
           ],
         },
-        {
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'method definition',
-            name: 'getX',
-          },
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 7,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
+      ],
+      output: null,
+    },
+    {
+      code: `
 class Test {
-  x?: number;
-  public getX?() {
-    return this.x;
-  }
+  constructor(public readonly x: number) {}
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
+      errors: [
+        {
+          column: 15,
+          endColumn: 21,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { parameterProperties: 'no-public' },
+        },
+      ],
+      output: `
+class Test {
+  constructor(readonly x: number) {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  x = 2;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  x?: number;
-  private getX?() {
-    return this.x;
-  }
+  public x = 2;
 }
       `,
             },
             {
+              data: { type: 'private' },
               messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x = 2;
+}
+      `,
+            },
+            {
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  x?: number;
-  protected getX?() {
-    return this.x;
-  }
+  protected x = 2;
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { properties: 'explicit' },
+        },
+      ],
+      output: null,
     },
     {
       code: `
 class Test {
-  protected name: string;
-  protected foo?: string;
-  public getX() {
-    return this.x;
-  }
+  public x = 2;
+  private x = 2;
 }
       `,
-      options: [{ accessibility: 'no-public' }],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          data: {
-            type: 'method definition',
-            name: 'getX',
-          },
-          line: 5,
           column: 3,
-          endLine: 5,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { properties: 'no-public' },
         },
       ],
       output: `
 class Test {
-  protected name: string;
-  protected foo?: string;
-  getX() {
-    return this.x;
-  }
+  x = 2;
+  private x = 2;
 }
       `,
     },
     {
       code: `
 class Test {
-  protected name: string;
-  public foo?: string;
-  getX() {
-    return this.x;
-  }
+  constructor(public x: any[]) {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(public x: any[]) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private constructor(public x: any[]) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  protected constructor(public x: any[]) {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
+    },
+    {
+      code: noFormat`
+class Test {
+  public /*public*/constructor(private foo: string) {}
 }
       `,
-      options: [{ accessibility: 'no-public' }],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          data: {
-            type: 'class property',
-            name: 'foo',
-          },
-          line: 4,
           column: 3,
-          endLine: 4,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
         },
       ],
       output: `
 class Test {
-  protected name: string;
-  foo?: string;
-  getX() {
-    return this.x;
-  }
+  /*public*/constructor(private foo: string) {}
 }
       `,
     },
     {
       code: `
 class Test {
-  public x: number;
-  public getX() {
-    return this.x;
-  }
+  @public
+  public foo() {}
 }
       `,
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
         },
+      ],
+      options: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 9,
+          accessibility: 'no-public',
         },
       ],
-      options: [{ accessibility: 'no-public' }],
       output: `
 class Test {
-  x: number;
-  getX() {
-    return this.x;
-  }
+  @public
+  foo() {}
 }
       `,
     },
     {
       code: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+  @public
+  public foo;
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'missingAccessibility',
-          line: 7,
           column: 3,
-          endLine: 7,
-          endColumn: 20,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+      output: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+  @public
+  foo;
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
+    },
+    {
+      code: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  private get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  protected get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'missingAccessibility',
-          line: 10,
-          column: 3,
-          endLine: 10,
-          endColumn: 20,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  private set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  protected set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-          ],
-        },
-      ],
-      options: [{ overrides: { constructors: 'no-public' } }],
-    },
-    {
-      code: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 14,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  private x: number;
-  public constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private x: number;
-  private constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  private x: number;
-  protected constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'missingAccessibility',
-          line: 7,
-          column: 3,
-          endLine: 7,
-          endColumn: 20,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  private get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  protected get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'missingAccessibility',
-          line: 10,
-          column: 3,
-          endLine: 10,
-          endColumn: 20,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  private set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  protected set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
-  }
-}
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 14,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  public constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
-  }
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  protected constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
-  }
-}
-      `,
-            },
-          ],
-        },
-      ],
-      options: [
-        {
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  constructor(public x: number) {}
-}
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 14,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  public constructor(public x: number) {}
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private constructor(public x: number) {}
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  protected constructor(public x: number) {}
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  constructor(public readonly x: number) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'off',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 15,
-          endLine: 3,
-          endColumn: 21,
-        },
-      ],
-      output: `
-class Test {
-  constructor(readonly x: number) {}
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  x = 2;
-}
-      `,
-      output: null,
-      options: [
-        {
-          accessibility: 'off',
-          overrides: { properties: 'explicit' },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 4,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  public x = 2;
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private x = 2;
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  protected x = 2;
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public x = 2;
-  private x = 2;
+  public foo = '';
 }
       `,
-      options: [
-        {
-          accessibility: 'off',
-          overrides: { properties: 'no-public' },
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 9,
-        },
-      ],
-      output: `
-class Test {
-  x = 2;
-  private x = 2;
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  constructor(public x: any[]) {}
-}
-      `,
-      output: null,
-      options: [{ accessibility: 'explicit' }],
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 3,
-          column: 3,
           endLine: 3,
-          endColumn: 14,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class Test {
-  public constructor(public x: any[]) {}
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class Test {
-  private constructor(public x: any[]) {}
-}
-      `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class Test {
-  protected constructor(public x: any[]) {}
-}
-      `,
-            },
-          ],
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
-    },
-    {
-      code: noFormat`
-class Test {
-  public /*public*/constructor(private foo: string) {}
-}
-      `,
       options: [
         {
           accessibility: 'no-public',
         },
       ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 9,
-        },
-      ],
       output: `
 class Test {
-  /*public*/constructor(private foo: string) {}
+  foo = '';
 }
       `,
     },
     {
-      code: `
+      code: noFormat`
 class Test {
-  @public
-  public foo() {}
+  constructor(public/* Hi there */ readonly foo) {}
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
       errors: [
         {
+          column: 15,
+          endColumn: 21,
+          endLine: 3,
+          line: 3,
           messageId: 'unwantedPublicAccessibility',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 9,
         },
       ],
-      output: `
-class Test {
-  @public
-  foo() {}
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  @public
-  public foo;
-}
-      `,
       options: [
         {
           accessibility: 'no-public',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 9,
+          overrides: { parameterProperties: 'no-public' },
         },
       ],
       output: `
 class Test {
-  @public
-  foo;
+  constructor(/* Hi there */ readonly foo) {}
 }
       `,
     },
     {
       code: `
 class Test {
-  public foo = '';
+  constructor(public readonly foo: string) {}
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 3,
+          column: 15,
+          endColumn: 21,
           endLine: 3,
-          endColumn: 9,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
-      output: `
-class Test {
-  foo = '';
-}
-      `,
-    },
-    {
-      code: noFormat`
-class Test {
-  constructor(public/* Hi there */ readonly foo) {}
-}
-      `,
       options: [
         {
           accessibility: 'no-public',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 15,
-          endLine: 3,
-          endColumn: 21,
         },
       ],
       output: `
 class Test {
-  constructor(/* Hi there */ readonly foo) {}
+  constructor(readonly foo: string) {}
 }
       `,
     },
     {
       code: `
-class Test {
-  constructor(public readonly foo: string) {}
+class EnsureWhiteSPaceSpan {
+  public constructor() {}
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 15,
+          column: 3,
+          endColumn: 9,
           endLine: 3,
-          endColumn: 21,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
-      output: `
-class Test {
-  constructor(readonly foo: string) {}
-}
-      `,
-    },
-    {
-      code: `
-class EnsureWhiteSPaceSpan {
-  public constructor() {}
-}
-      `,
       options: [
         {
           accessibility: 'no-public',
           overrides: { parameterProperties: 'no-public' },
         },
       ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 9,
-        },
-      ],
       output: `
 class EnsureWhiteSPaceSpan {
   constructor() {}
@@ -1681,19 +1367,19 @@ class EnsureWhiteSPaceSpan {
   public /* */ constructor() {}
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'no-public' },
         },
       ],
       output: `
@@ -1712,53 +1398,53 @@ class Test {
   public 'bar bar'() {}
 }
       `,
-      options: [{ accessibility: 'no-public' }],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
+          column: 3,
           data: {
-            type: 'class property',
             name: 'foo',
+            type: 'class property',
           },
-          line: 3,
-          column: 3,
-          endLine: 3,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
         },
         {
-          messageId: 'unwantedPublicAccessibility',
+          column: 3,
           data: {
-            type: 'class property',
             name: '"foo foo"',
+            type: 'class property',
           },
-          line: 4,
-          column: 3,
-          endLine: 4,
           endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
         },
         {
-          messageId: 'unwantedPublicAccessibility',
+          column: 3,
           data: {
-            type: 'method definition',
             name: 'bar',
+            type: 'method definition',
           },
-          line: 5,
-          column: 3,
-          endLine: 5,
           endColumn: 9,
+          endLine: 5,
+          line: 5,
+          messageId: 'unwantedPublicAccessibility',
         },
         {
-          messageId: 'unwantedPublicAccessibility',
+          column: 3,
           data: {
-            type: 'method definition',
             name: '"bar bar"',
+            type: 'method definition',
           },
-          line: 6,
-          column: 3,
-          endLine: 6,
           endColumn: 9,
+          endLine: 6,
+          line: 6,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
+      options: [{ accessibility: 'no-public' }],
       output: `
 class Test {
   'foo' = 1;
@@ -1774,19 +1460,17 @@ abstract class SomeClass {
   abstract method(): string;
 }
       `,
-      output: null,
-      options: [{ accessibility: 'explicit' }],
       errors: [
         {
-          messageId: 'missingAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 18,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   public abstract method(): string;
@@ -1794,8 +1478,8 @@ abstract class SomeClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   private abstract method(): string;
@@ -1803,8 +1487,8 @@ abstract class SomeClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   protected abstract method(): string;
@@ -1814,6 +1498,8 @@ abstract class SomeClass {
           ],
         },
       ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
     },
     {
       code: `
@@ -1821,19 +1507,19 @@ abstract class SomeClass {
   public abstract method(): string;
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'no-public' },
         },
       ],
       output: `
@@ -1849,19 +1535,17 @@ abstract class SomeClass {
   abstract x: string;
 }
       `,
-      output: null,
-      options: [{ accessibility: 'explicit' }],
       errors: [
         {
-          messageId: 'missingAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 13,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   public abstract x: string;
@@ -1869,8 +1553,8 @@ abstract class SomeClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   private abstract x: string;
@@ -1878,8 +1562,8 @@ abstract class SomeClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 abstract class SomeClass {
   protected abstract x: string;
@@ -1889,6 +1573,8 @@ abstract class SomeClass {
           ],
         },
       ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
     },
     {
       code: `
@@ -1896,19 +1582,19 @@ abstract class SomeClass {
   public abstract x: string;
 }
       `,
-      options: [
-        {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
       errors: [
         {
-          messageId: 'unwantedPublicAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'no-public' },
         },
       ],
       output: `
@@ -1935,18 +1621,17 @@ class DecoratedClass {
   }
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'missingAccessibility',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   public constructor(@foo @bar() readonly arg: string) {}
@@ -1966,8 +1651,8 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   private constructor(@foo @bar() readonly arg: string) {}
@@ -1987,8 +1672,8 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   protected constructor(@foo @bar() readonly arg: string) {}
@@ -2010,15 +1695,15 @@ class DecoratedClass {
           ],
         },
         {
-          messageId: 'missingAccessibility',
-          line: 3,
           column: 27,
-          endLine: 3,
           endColumn: 39,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() public readonly arg: string) {}
@@ -2038,13 +1723,157 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() private readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() protected readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 15,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() public x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() private x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() protected x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 15,
+          endColumn: 19,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() public getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  constructor(@foo @bar() private readonly arg: string) {}
+  constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() getX() {
+  @foo @bar() private getX() {
     return this.x;
   }
   @foo
@@ -2059,13 +1888,13 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  constructor(@foo @bar() protected readonly arg: string) {}
+  constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() getX() {
+  @foo @bar() protected getX() {
     return this.x;
   }
   @foo
@@ -2082,25 +1911,25 @@ class DecoratedClass {
           ],
         },
         {
+          column: 3,
+          endColumn: 8,
+          endLine: 10,
+          line: 10,
           messageId: 'missingAccessibility',
-          line: 4,
-          column: 15,
-          endLine: 4,
-          endColumn: 16,
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() public x: string;
+  @foo @bar() x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  get y() {
+  public get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -2110,18 +1939,18 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() private x: string;
+  @foo @bar() x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  get y() {
+  private get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -2131,18 +1960,18 @@ class DecoratedClass {
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() protected x: string;
+  @foo @bar() x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  get y() {
+  protected get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -2154,20 +1983,20 @@ class DecoratedClass {
           ],
         },
         {
-          messageId: 'missingAccessibility',
-          line: 5,
           column: 15,
-          endLine: 5,
-          endColumn: 19,
+          endColumn: 20,
+          endLine: 13,
+          line: 13,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() public getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -2175,20 +2004,20 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
+  @foo @bar() public set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() private getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -2196,20 +2025,20 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
+  @foo @bar() private set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
       `,
             },
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() protected getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -2217,7 +2046,7 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
+  @foo @bar() protected set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
@@ -2225,198 +2054,369 @@ class DecoratedClass {
             },
           ],
         },
+      ],
+      output: null,
+    },
+    {
+      code: `
+abstract class SomeClass {
+  abstract ['computed-method-name'](): string;
+}
+      `,
+      errors: [
         {
-          messageId: 'missingAccessibility',
-          line: 10,
           column: 3,
-          endLine: 10,
-          endColumn: 8,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
           suggestions: [
             {
-              messageId: 'addExplicitAccessibility',
               data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
               output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
+abstract class SomeClass {
+  public abstract ['computed-method-name'](): string;
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+abstract class SomeClass {
+  private abstract ['computed-method-name'](): string;
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+abstract class SomeClass {
+  protected abstract ['computed-method-name'](): string;
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
+    },
+  ],
+  valid: [
+    {
+      code: `
+class Test {
+  public constructor(private foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'explicit' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(private readonly foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'explicit' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(private foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(protected foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(public foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(readonly foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(private readonly foo: string) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  protected name: string;
+  private x: number;
+  public getX() {
     return this.x;
   }
-  @foo
-  @bar()
-  public get y() {
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  protected name: string;
+  protected foo?: string;
+  public 'foo-bar'?: string;
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  public constructor({ x, y }: { x: number; y: number }) {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  protected name: string;
+  protected foo?: string;
+  public getX() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
+}
+      `,
+      options: [{ accessibility: 'explicit' }],
+    },
+    {
+      code: `
+class Test {
+  protected name: string;
+  protected foo?: string;
+  getX() {
+    return this.x;
   }
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  private get y() {
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  name: string;
+  foo?: string;
+  getX() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
+  get fooName(): string {
+    return this.foo + ' ' + this.name;
   }
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
   }
-  @foo
-  @bar()
-  protected get y() {
+  get internalValue() {
     return this.x;
   }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
+  private set internalValue(value: number) {
+    this.x = value;
+  }
+  public square(): number {
+    return this.x * this.x;
   }
 }
       `,
-            },
-          ],
-        },
-        {
-          messageId: 'missingAccessibility',
-          line: 13,
-          column: 15,
-          endLine: 13,
-          endColumn: 20,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
+      options: [{ overrides: { accessors: 'off', constructors: 'off' } }],
+    },
+    {
+      code: `
+class Test {
+  private x: number;
+  public constructor(x: number) {
+    this.x = x;
   }
-  @foo
-  @bar()
-  get y() {
+  public get internalValue() {
     return this.x;
   }
-  @foo @bar() public set z(@foo @bar() value: x) {
-    this.x = x;
+  public set internalValue(value: number) {
+    this.x = value;
+  }
+  public square(): number {
+    return this.x * this.x;
+  }
+  half(): number {
+    return this.x / 2;
   }
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
+      options: [{ overrides: { methods: 'off' } }],
+    },
+    {
+      code: `
+class Test {
+  constructor(private x: number) {}
+}
+      `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  constructor(public x: number) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
+class Test {
+  constructor(public foo: number) {}
+}
+      `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  public getX() {
     return this.x;
   }
-  @foo
-  @bar()
-  get y() {
+}
+      `,
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
+class Test {
+  public static getX() {
     return this.x;
   }
-  @foo @bar() private set z(@foo @bar() value: x) {
-    this.x = x;
-  }
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
+class Test {
+  get getX() {
     return this.x;
   }
-  @foo
-  @bar()
-  get y() {
+}
+      `,
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
+class Test {
+  getX() {
     return this.x;
   }
-  @foo @bar() protected set z(@foo @bar() value: x) {
-    this.x = x;
-  }
 }
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ ignoredMethodNames: ['getX'] }],
     },
     {
       code: `
-abstract class SomeClass {
-  abstract ['computed-method-name'](): string;
+class Test {
+  x = 2;
 }
       `,
-      output: null,
-      options: [{ accessibility: 'explicit' }],
-      errors: [
-        {
-          messageId: 'missingAccessibility',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 36,
-          suggestions: [
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'public' },
-              output: `
-abstract class SomeClass {
-  public abstract ['computed-method-name'](): string;
+      options: [{ overrides: { properties: 'off' } }],
+    },
+    {
+      code: `
+class Test {
+  private x = 2;
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'private' },
-              output: `
-abstract class SomeClass {
-  private abstract ['computed-method-name'](): string;
+      options: [{ overrides: { properties: 'explicit' } }],
+    },
+    {
+      code: `
+class Test {
+  x = 2;
+  private x = 2;
 }
       `,
-            },
-            {
-              messageId: 'addExplicitAccessibility',
-              data: { type: 'protected' },
-              output: `
-abstract class SomeClass {
-  protected abstract ['computed-method-name'](): string;
+      options: [{ overrides: { properties: 'no-public' } }],
+    },
+    {
+      code: `
+class Test {
+  constructor(private { x }: any[]) {}
 }
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ accessibility: 'no-public' }],
+    },
+    // private members
+    {
+      code: `
+class Test {
+  #foo = 1;
+  #bar() {}
+}
+      `,
+      options: [{ accessibility: 'explicit' }],
     },
   ],
 });
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 eda213576ff8..35be0f278525 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
@@ -5,283 +5,349 @@ import rule from '../../src/rules/explicit-module-boundary-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-module-boundary-types', rule, {
-  valid: [
+  invalid: [
     {
       code: `
-function test(): void {
+export function test(a: number, b: number) {
   return;
 }
       `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 21,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export function test(): void {
+export function test() {
   return;
 }
       `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 21,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export var fn = function (): number {
+export var fn = function () {
   return 1;
 };
       `,
+      errors: [
+        {
+          column: 17,
+          endColumn: 26,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export var arrowFn = (): string => 'test';
+export var arrowFn = () => 'test';
       `,
+      errors: [
+        {
+          column: 25,
+          endColumn: 27,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
-      // not exported
       code: `
-class Test {
-  constructor(one) {}
-  get prop(one) {
+export class Test {
+  constructor() {}
+  get prop() {
     return 1;
   }
-  set prop(one) {}
-  method(one) {
+  set prop(value) {}
+  method() {
     return;
   }
-  arrow = one => 'arrow';
-  abstract abs(one);
-}
-      `,
-    },
-    {
-      code: `
-export class Test {
-  constructor(one: string) {}
-  get prop(one: string): void {
-    return 1;
-  }
-  set prop(one: string): void {}
-  method(one: string): void {
+  arrow = arg => 'arrow';
+  private method() {
     return;
   }
-  arrow = (one: string): string => 'arrow';
-  abstract abs(one: string): void;
+  abstract abs(arg);
 }
       `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 12,
+          data: {
+            name: 'value',
+          },
+          endColumn: 17,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 11,
+          data: {
+            name: 'arg',
+          },
+          endColumn: 14,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 15,
+          endColumn: 21,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 16,
+          data: {
+            name: 'arg',
+          },
+          endColumn: 19,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-export class Test {
-  private constructor(one) {}
-  private get prop(one) {
-    return 1;
-  }
-  private set prop(one) {}
-  private method(one) {
-    return;
-  }
-  private arrow = one => 'arrow';
-  private abstract abs(one);
+export class Foo {
+  public a = () => {};
+  public b = function () {};
+  public c = function test() {};
+
+  static d = () => {};
+  static e = function () {};
 }
       `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 27,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
-    `
-export class PrivateProperty {
-  #property = () => null;
-}
-    `,
-    `
-export class PrivateMethod {
-  #method() {}
-}
-    `,
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/2150
-      code: `
-export class Test {
-  constructor();
-  constructor(value?: string) {
-    console.log(value);
-  }
-}
-      `,
+      code: 'export default () => (true ? () => {} : (): void => {});',
+      errors: [
+        {
+          column: 19,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
-      code: `
-declare class MyClass {
-  constructor(options?: MyClass.Options);
-}
-export { MyClass };
-      `,
+      code: "export var arrowFn = () => 'test';",
+      errors: [
+        {
+          column: 25,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-export function test(): void {
-  nested();
-  return;
-
-  function nested() {}
-}
+export var funcExpr = function () {
+  return 'test';
+};
       `,
+      errors: [
+        {
+          column: 23,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-export function test(): string {
-  const nested = () => 'value';
-  return nested();
-}
-      `,
-    },
-    {
-      code: `
-export function test(): string {
-  class Nested {
-    public method() {
-      return 'value';
-    }
-  }
-  return new Nested().method();
-}
-      `,
-    },
-    {
-      code: `
-export var arrowFn: Foo = () => 'test';
+interface Foo {}
+export const x: Foo = {
+  foo: () => {},
+};
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
-      code: `
-export var funcExpr: Foo = function () {
-  return 'test';
-};
-      `,
-      options: [
+      code: 'export default () => () => {};',
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 25,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: 'const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: 'const x = <Foo>(() => {});',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x = {
-  foo: () => {},
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x = <Foo>{
-  foo: () => {},
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x: Foo = {
-  foo: () => {},
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
-    {
-      code: `
-export const x = {
-  foo: { bar: () => {} },
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x = <Foo>{
-  foo: { bar: () => {} },
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x: Foo = {
-  foo: { bar: () => {} },
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/484
-    {
-      code: `
-type MethodType = () => void;
-
-export class App {
-  public method: MethodType = () => {};
-}
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/525
-    {
-      code: `
-export const myObj = {
-  set myProp(val: number) {
-    this.myProp = val;
-  },
-};
-      `,
-    },
-    {
-      code: `
-export default () => (): void => {};
-      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: `
-export default () => function (): void {};
-      `,
+      code: 'export default () => function () {};',
+      errors: [
+        {
+          column: 22,
+          endColumn: 31,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return (): void => {};
+  return () => {};
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return function (): void {};
+  return function () {};
 };
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return (): void => {};
+  return () => {};
 }
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return function (): void {};
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -293,1660 +359,1594 @@ export function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number =>
+          () =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => () => {
-  return (): void => {
+  return () => {
     return;
   };
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => () => {
-  const foo = 'foo';
-  return (): void => {
-    return;
-  };
-};
+export const func1 = (value: number) => ({ type: 'X', value }) as any;
+export const func2 = (value: number) => ({ type: 'X', value }) as Action;
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowDirectConstAssertionInArrowFunctions: true,
+        },
+      ],
     },
     {
       code: `
-export default () => () => {
-  const foo = () => (): string => 'foo';
-  return (): void => {
-    return;
-  };
-};
-      `,
-      options: [{ allowHigherOrderFunctions: true }],
-    },
-    {
-      code: `
-export class Accumulator {
-  private count: number = 0;
-
-  public accumulate(fn: () => number): void {
-    this.count += fn();
-  }
-}
-
-new Accumulator().accumulate(() => 1);
+export const func = (value: number) => ({ type: 'X', value }) as const;
       `,
+      errors: [
+        {
+          column: 37,
+          endColumn: 39,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowDirectConstAssertionInArrowFunctions: false,
         },
       ],
     },
     {
       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 func4 = (value: number) => x as const;
+export class Test {
+  constructor() {}
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
+    return;
+  }
+  arrow = (): string => 'arrow';
+  foo = () => 'bar';
+}
       `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 12,
+          line: 12,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: true,
+          allowedNames: ['prop'],
         },
       ],
     },
     {
       code: `
-export const func1 = (value: string) => value;
-export const func2 = (value: number) => ({ type: 'X', value });
+export class Test {
+  constructor(
+    public foo,
+    private ...bar,
+  ) {}
+}
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['func1', 'func2'],
+          column: 12,
+          data: {
+            name: 'foo',
+          },
+          line: 4,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 5,
+          data: {
+            name: 'bar',
+          },
+          line: 5,
+          messageId: 'missingArgType',
         },
       ],
     },
     {
       code: `
-export function func1() {
-  return 0;
-}
-export const foo = {
-  func2() {
-    return 0;
-  },
-};
+export const func1 = (value: number) => value;
+export const func2 = (value: number) => value;
       `,
+      errors: [
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowedNames: ['func1', 'func2'],
+          allowedNames: ['func2'],
         },
       ],
     },
     {
       code: `
-export class Test {
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  // prettier-ignore
-  'method'() {}
-  ['prop']() {}
-  [\`prop\`]() {}
-  [\`\${v}\`](): void {}
-
-  foo = () => {
-    bar: 5;
-  };
+export function fn(test): string {
+  return '123';
 }
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['prop', 'method', 'foo'],
+          column: 20,
+          data: {
+            name: 'test',
+          },
+          endColumn: 24,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingArgType',
         },
       ],
     },
     {
       code: `
-        export function foo(outer: string) {
-          return function (inner: string): void {};
-        }
+export const fn = (one: number, two): string => '123';
       `,
-      options: [
+      errors: [
         {
-          allowHigherOrderFunctions: true,
+          column: 33,
+          data: {
+            name: 'two',
+          },
+          endColumn: 36,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingArgType',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1552
     {
       code: `
-        export type Ensurer = (blocks: TFBlock[]) => TFBlock[];
-
-        export const myEnsurer: Ensurer = blocks => {
-          return blocks;
-        };
+export function foo(outer) {
+  return function (inner) {};
+}
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          data: {
+            name: 'outer',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'inner',
+          },
+          line: 3,
+          messageId: 'missingArgType',
         },
       ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: `
-export const Foo: FC = () => (
-  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
-);
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { jsx: true },
+      code: 'export const baz = arg => arg as const;',
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 1,
+          messageId: 'missingArgType',
         },
-      },
+      ],
+      options: [{ allowDirectConstAssertionInArrowFunctions: true }],
     },
     {
       code: `
-export const Foo: JSX.Element = (
-  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
-);
+const foo = arg => arg;
+export default foo;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { jsx: true },
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
         },
-      },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-const test = (): void => {
-  return;
-};
-export default test;
+const foo = arg => arg;
+export = foo;
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-function test(): void {
-  return;
-}
-export default test;
+let foo = (arg: number): number => arg;
+foo = arg => arg;
+export default foo;
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-const test = (): void => {
-  return;
-};
-export default [test];
+const foo = arg => arg;
+export default [foo];
       `,
-    },
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+    },
     {
       code: `
-function test(): void {
-  return;
-}
-export default [test];
+const foo = arg => arg;
+export default { foo };
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-const test = (): void => {
-  return;
-};
-export default { test };
+function foo(arg) {
+  return arg;
+}
+export default foo;
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-function test(): void {
-  return;
+function foo(arg) {
+  return arg;
 }
-export default { test };
+export default [foo];
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-const foo = (arg => arg) as Foo;
-export default foo;
+function foo(arg) {
+  return arg;
+}
+export default { foo };
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-let foo = (arg => arg) as Foo;
-foo = 3;
-export default foo;
+const bar = function foo(arg) {
+  return arg;
+};
+export default { bar };
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  bar = (arg: string): string => arg;
+  bool(arg) {
+    return arg;
+  }
 }
-export default { Foo };
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  bar(): void {
-    return;
-  }
+  bool = arg => {
+    return arg;
+  };
 }
-export default { Foo };
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-export function foo(): (n: number) => string {
-  return n => String(n);
+class Foo {
+  bool = function (arg) {
+    return arg;
+  };
 }
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-export const foo = (a: string): ((n: number) => string) => {
-  return function (n) {
-    return String(n);
+class Foo {
+  bool = function (arg) {
+    return arg;
   };
-};
+}
+export default [Foo];
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-export function a(): void {
-  function b() {}
-  const x = () => {};
-  (function () {});
-
-  function c() {
-    return () => {};
-  }
-
+let test = arg => argl;
+test = (): void => {
   return;
-}
+};
+export default test;
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export function a(): void {
-  function b() {
-    function c() {}
-  }
-  const x = () => {
-    return () => 100;
-  };
-  (function () {
-    (function () {});
-  });
-
-  function c() {
-    return () => {
-      (function () {});
-    };
-  }
-
+let test = arg => argl;
+test = (): void => {
   return;
-}
+};
+export { test };
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export function a() {
-  return function b(): () => void {
-    return function c() {};
+export const foo =
+  () =>
+  (a: string): ((n: number) => string) => {
+    return function (n) {
+      return String(n);
+    };
   };
-}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 6,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: false }],
     },
     {
       code: `
-export var arrowFn = () => (): void => {};
+export var arrowFn = () => () => {};
       `,
+      errors: [
+        {
+          column: 31,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return function (): void {};
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function foo(outer: string) {
-  return function (inner: string): void {};
+export function foo(outer) {
+  return function (inner): void {};
 }
       `,
-    },
-    // shouldn't check functions that aren't directly exported - https://github.com/typescript-eslint/typescript-eslint/issues/2134
-    `
-export function foo(): unknown {
-  return new Proxy(apiInstance, {
-    get: (target, property) => {
-      // implementation
-    },
-  });
-}
-    `,
-    {
-      code: 'export default (() => true)();',
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: false,
+          column: 21,
+          data: {
+            name: 'outer',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 20,
+          data: {
+            name: 'inner',
+          },
+          line: 3,
+          messageId: 'missingArgType',
         },
       ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
-    // explicit assertions are allowed
-    {
-      code: 'export const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: false }],
-    },
-    {
-      code: `
-interface Foo {}
-export const x = {
-  foo: () => {},
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: false }],
-    },
-    // allowArgumentsExplicitlyTypedAsAny
-    {
-      code: `
-export function foo(foo: any): void {}
-      `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
-    },
-    {
-      code: `
-export function foo({ foo }: any): void {}
-      `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
-    },
-    {
-      code: `
-export function foo([bar]: any): void {}
-      `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
-    },
-    {
-      code: `
-export function foo(...bar: any): void {}
-      `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
-    },
-    {
-      code: `
-export function foo(...[a]: any): void {}
-      `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
-    },
-    // assignment patterns are ignored
-    `
-export function foo(arg = 1): void {}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2161
     {
       code: `
-export const foo = (): ((n: number) => string) => n => String(n);
+export function foo(outer: boolean) {
+  if (outer) {
+    return 'string';
+  }
+  return function (inner): void {};
+}
       `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            name: 'inner',
+          },
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2173
-    `
-export function foo(): (n: number) => (m: number) => string {
-  return function (n) {
-    return function (m) {
-      return String(n + m);
-    };
-  };
-}
-    `,
-    `
-export const foo = (): ((n: number) => (m: number) => string) => n => m =>
-  String(n + m);
-    `,
-    `
-export const bar: () => (n: number) => string = () => n => String(n);
-    `,
-    `
-type Buz = () => (n: number) => string;
-
-export const buz: Buz = () => n => String(n);
-    `,
-    `
-export abstract class Foo<T> {
-  abstract set value(element: T);
-}
-    `,
-    `
-export declare class Foo {
-  set time(seconds: number);
-}
-    `,
-    `
-export class A {
-  b = A;
-}
-    `,
-    `
-interface Foo {
-  f: (x: boolean) => boolean;
-}
-
-export const a: Foo[] = [
-  {
-    f: (x: boolean) => x,
-  },
-];
-    `,
-    `
-interface Foo {
-  f: (x: boolean) => boolean;
-}
-
-export const a: Foo = {
-  f: (x: boolean) => x,
-};
-    `,
-  ],
-  invalid: [
+    // test a few different argument patterns
     {
       code: `
-export function test(a: number, b: number) {
-  return;
-}
+export function foo({ foo }): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
+          column: 21,
+          data: {
+            type: 'Object pattern',
+          },
           line: 2,
-          endLine: 2,
-          column: 8,
-          endColumn: 21,
+          messageId: 'missingArgTypeUnnamed',
         },
       ],
     },
     {
       code: `
-export function test() {
-  return;
-}
+export function foo([bar]): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
+          column: 21,
+          data: {
+            type: 'Array pattern',
+          },
           line: 2,
-          endLine: 2,
-          column: 8,
-          endColumn: 21,
+          messageId: 'missingArgTypeUnnamed',
         },
       ],
     },
     {
       code: `
-export var fn = function () {
-  return 1;
-};
+export function foo(...bar): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
+          column: 21,
+          data: {
+            name: 'bar',
+          },
           line: 2,
-          endLine: 2,
-          column: 17,
-          endColumn: 26,
+          messageId: 'missingArgType',
         },
       ],
     },
     {
       code: `
-export var arrowFn = () => 'test';
+export function foo(...[a]): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
+          column: 21,
+          data: {
+            type: 'Rest',
+          },
           line: 2,
-          endLine: 2,
-          column: 25,
-          endColumn: 27,
+          messageId: 'missingArgTypeUnnamed',
         },
       ],
     },
+    // allowArgumentsExplicitlyTypedAsAny
     {
       code: `
-export class Test {
-  constructor() {}
-  get prop() {
-    return 1;
-  }
-  set prop(value) {}
-  method() {
-    return;
-  }
-  arrow = arg => 'arrow';
-  private method() {
-    return;
-  }
-  abstract abs(arg);
-}
+export function foo(foo: any): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 11,
-        },
-        {
-          messageId: 'missingArgType',
-          line: 7,
-          column: 12,
-          endLine: 7,
-          endColumn: 17,
-          data: {
-            name: 'value',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 9,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 11,
-          column: 3,
-          endLine: 11,
-          endColumn: 11,
-        },
-        {
-          messageId: 'missingArgType',
-          line: 11,
-          column: 11,
-          endLine: 11,
-          endColumn: 14,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 15,
-          column: 15,
-          endLine: 15,
-          endColumn: 21,
-        },
-        {
-          messageId: 'missingArgType',
-          line: 15,
-          column: 16,
-          endLine: 15,
-          endColumn: 19,
+          column: 21,
           data: {
-            name: 'arg',
+            name: 'foo',
           },
+          line: 2,
+          messageId: 'anyTypedArg',
         },
       ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
-export class Foo {
-  public a = () => {};
-  public b = function () {};
-  public c = function test() {};
-
-  static d = () => {};
-  static e = function () {};
-}
+export function foo({ foo }: any): void {}
       `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 14,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 23,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 5,
-          column: 3,
-          endLine: 5,
-          endColumn: 27,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 7,
-          column: 3,
-          endLine: 7,
-          endColumn: 14,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 23,
+          column: 21,
+          data: {
+            type: 'Object pattern',
+          },
+          line: 2,
+          messageId: 'anyTypedArgUnnamed',
         },
       ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
-      code: 'export default () => (true ? () => {} : (): void => {});',
+      code: `
+export function foo([bar]: any): void {}
+      `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 19,
-          endColumn: 21,
+          column: 21,
+          data: {
+            type: 'Array pattern',
+          },
+          line: 2,
+          messageId: 'anyTypedArgUnnamed',
         },
       ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
-      code: "export var arrowFn = () => 'test';",
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: `
+export function foo(...bar: any): void {}
+      `,
       errors: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 25,
-          endColumn: 27,
+          column: 21,
+          data: {
+            name: 'bar',
+          },
+          line: 2,
+          messageId: 'anyTypedArg',
         },
       ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
-export var funcExpr = function () {
-  return 'test';
-};
+export function foo(...[a]: any): void {}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
       errors: [
         {
-          messageId: 'missingReturnType',
+          column: 21,
+          data: {
+            type: 'Rest',
+          },
           line: 2,
-          endLine: 2,
-          column: 23,
-          endColumn: 32,
+          messageId: 'anyTypedArgUnnamed',
         },
       ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
-interface Foo {}
-export const x: Foo = {
-  foo: () => {},
+export function func1() {
+  return 0;
+}
+export const foo = {
+  func2() {
+    return 0;
+  },
 };
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
       errors: [
         {
+          column: 8,
+          endColumn: 22,
+          endLine: 2,
+          line: 2,
           messageId: 'missingReturnType',
-          line: 4,
-          endLine: 4,
+        },
+        {
           column: 3,
           endColumn: 8,
+          endLine: 6,
+          line: 6,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: 'export default () => () => {};',
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
+      options: [
         {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 25,
-          endColumn: 27,
+          allowedNames: [],
         },
       ],
     },
+  ],
+  valid: [
     {
-      code: 'export default () => function () {};',
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 22,
-          endColumn: 31,
-        },
-      ],
+      code: `
+function test(): void {
+  return;
+}
+      `,
     },
     {
       code: `
-export default () => {
-  return () => {};
-};
+export function test(): void {
+  return;
+}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
     {
       code: `
-export default () => {
-  return function () {};
+export var fn = function (): number {
+  return 1;
 };
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 10,
-          endColumn: 19,
-        },
-      ],
     },
     {
       code: `
-export function fn() {
-  return () => {};
-}
+export var arrowFn = (): string => 'test';
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
     {
+      // not exported
       code: `
-export function fn() {
-  return function () {};
+class Test {
+  constructor(one) {}
+  get prop(one) {
+    return 1;
+  }
+  set prop(one) {}
+  method(one) {
+    return;
+  }
+  arrow = one => 'arrow';
+  abstract abs(one);
 }
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 10,
-          endColumn: 19,
-        },
-      ],
     },
     {
       code: `
-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
-      };
-    };
-  };
+export class Test {
+  constructor(one: string) {}
+  get prop(one: string): void {
+    return 1;
+  }
+  set prop(one: string): void {}
+  method(one: string): void {
+    return;
+  }
+  arrow = (one: string): string => 'arrow';
+  abstract abs(one: string): void;
 }
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 9,
-          endLine: 9,
-          column: 14,
-          endColumn: 16,
-        },
-      ],
     },
     {
       code: `
-export default () => () => {
-  return () => {
+export class Test {
+  private constructor(one) {}
+  private get prop(one) {
+    return 1;
+  }
+  private set prop(one) {}
+  private method(one) {
     return;
-  };
-};
+  }
+  private arrow = one => 'arrow';
+  private abstract abs(one);
+}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 13,
-          endColumn: 15,
-        },
-      ],
     },
+    `
+export class PrivateProperty {
+  #property = () => null;
+}
+    `,
+    `
+export class PrivateMethod {
+  #method() {}
+}
+    `,
     {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/2150
       code: `
-export const func1 = (value: number) => ({ type: 'X', value }) as any;
-export const func2 = (value: number) => ({ type: 'X', value }) as Action;
+export class Test {
+  constructor();
+  constructor(value?: string) {
+    console.log(value);
+  }
+}
       `,
-      options: [
-        {
-          allowDirectConstAssertionInArrowFunctions: true,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 38,
-          endColumn: 40,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          endLine: 3,
-          column: 38,
-          endColumn: 40,
-        },
-      ],
     },
     {
       code: `
-export const func = (value: number) => ({ type: 'X', value }) as const;
+declare class MyClass {
+  constructor(options?: MyClass.Options);
+}
+export { MyClass };
       `,
-      options: [
-        {
-          allowDirectConstAssertionInArrowFunctions: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 37,
-          endColumn: 39,
-        },
-      ],
     },
     {
       code: `
-export class Test {
-  constructor() {}
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  arrow = (): string => 'arrow';
-  foo = () => 'bar';
+export function test(): void {
+  nested();
+  return;
+
+  function nested() {}
 }
       `,
-      options: [
-        {
-          allowedNames: ['prop'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 8,
-          endLine: 8,
-          column: 3,
-          endColumn: 9,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 12,
-          endLine: 12,
-          column: 3,
-          endColumn: 9,
-        },
-      ],
     },
     {
       code: `
-export class Test {
-  constructor(
-    public foo,
-    private ...bar,
-  ) {}
+export function test(): string {
+  const nested = () => 'value';
+  return nested();
 }
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 4,
-          column: 12,
-          data: {
-            name: 'foo',
-          },
-        },
-        {
-          messageId: 'missingArgType',
-          line: 5,
-          column: 5,
-          data: {
-            name: 'bar',
-          },
-        },
-      ],
     },
     {
       code: `
-export const func1 = (value: number) => value;
-export const func2 = (value: number) => value;
+export function test(): string {
+  class Nested {
+    public method() {
+      return 'value';
+    }
+  }
+  return new Nested().method();
+}
+      `,
+    },
+    {
+      code: `
+export var arrowFn: Foo = () => 'test';
       `,
       options: [
         {
-          allowedNames: ['func2'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 38,
-          endColumn: 40,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-export function fn(test): string {
-  return '123';
-}
+export var funcExpr: Foo = function () {
+  return 'test';
+};
       `,
-      errors: [
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          endLine: 2,
-          column: 20,
-          endColumn: 24,
-          data: {
-            name: 'test',
-          },
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
+    {
+      code: 'const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: 'const x = <Foo>(() => {});',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
     {
       code: `
-export const fn = (one: number, two): string => '123';
+export const x = {
+  foo: () => {},
+} as Foo;
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          endLine: 2,
-          column: 33,
-          endColumn: 36,
-          data: {
-            name: 'two',
-          },
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-export function foo(outer) {
-  return function (inner) {};
+export const x = <Foo>{
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x: Foo = {
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
+    {
+      code: `
+export const x = {
+  foo: { bar: () => {} },
+} as Foo;
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x = <Foo>{
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x: Foo = {
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/484
+    {
+      code: `
+type MethodType = () => void;
+
+export class App {
+  public method: MethodType = () => {};
 }
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/525
+    {
+      code: `
+export const myObj = {
+  set myProp(val: number) {
+    this.myProp = val;
+  },
+};
+      `,
+    },
+    {
+      code: `
+export default () => (): void => {};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: `
+export default () => function (): void {};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: `
+export default () => {
+  return (): void => {};
+};
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'outer',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-        },
-        {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'inner',
-          },
-        },
-      ],
     },
     {
-      code: 'export const baz = arg => arg as const;',
-      options: [{ allowDirectConstAssertionInArrowFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 1,
-          data: {
-            name: 'arg',
-          },
-        },
-      ],
+      code: `
+export default () => {
+  return function (): void {};
+};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-const foo = arg => arg;
-export default foo;
+export function fn() {
+  return (): void => {};
+}
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-const foo = arg => arg;
-export = foo;
+export function fn() {
+  return function (): void {};
+}
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-let foo = (arg: number): number => arg;
-foo = arg => arg;
-export default foo;
+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
+      };
+    };
+  };
+}
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-const foo = arg => arg;
-export default [foo];
+export default () => () => {
+  return (): void => {
+    return;
+  };
+};
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-const foo = arg => arg;
-export default { foo };
+export default () => () => {
+  const foo = 'foo';
+  return (): void => {
+    return;
+  };
+};
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
+export default () => () => {
+  const foo = () => (): string => 'foo';
+  return (): void => {
+    return;
+  };
+};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: `
+export class Accumulator {
+  private count: number = 0;
+
+  public accumulate(fn: () => number): void {
+    this.count += fn();
+  }
 }
-export default foo;
+
+new Accumulator().accumulate(() => 1);
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
-}
-export default [foo];
+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;
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
+          allowDirectConstAssertionInArrowFunctions: true,
         },
       ],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
-}
-export default { foo };
+export const func1 = (value: string) => value;
+export const func2 = (value: number) => ({ type: 'X', value });
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
+          allowedNames: ['func1', 'func2'],
         },
       ],
     },
     {
       code: `
-const bar = function foo(arg) {
-  return arg;
+export function func1() {
+  return 0;
+}
+export const foo = {
+  func2() {
+    return 0;
+  },
 };
-export default { bar };
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
+          allowedNames: ['func1', 'func2'],
         },
       ],
     },
     {
       code: `
-class Foo {
-  bool(arg) {
-    return arg;
+export class Test {
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
+    return;
   }
+  // prettier-ignore
+  'method'() {}
+  ['prop']() {}
+  [\`prop\`]() {}
+  [\`\${v}\`](): void {}
+
+  foo = () => {
+    bar: 5;
+  };
 }
-export default Foo;
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'arg',
-          },
+          allowedNames: ['prop', 'method', 'foo'],
         },
       ],
     },
     {
       code: `
-class Foo {
-  bool = arg => {
-    return arg;
-  };
-}
-export default Foo;
+        export function foo(outer: string) {
+          return function (inner: string): void {};
+        }
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'arg',
-          },
+          allowHigherOrderFunctions: true,
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1552
     {
       code: `
-class Foo {
-  bool = function (arg) {
-    return arg;
-  };
-}
-export default Foo;
+        export type Ensurer = (blocks: TFBlock[]) => TFBlock[];
+
+        export const myEnsurer: Ensurer = blocks => {
+          return blocks;
+        };
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-        },
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'arg',
-          },
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-class Foo {
-  bool = function (arg) {
-    return arg;
-  };
-}
-export default [Foo];
+export const Foo: FC = () => (
+  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
+);
       `,
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
         },
-        {
-          messageId: 'missingArgType',
-          line: 3,
-          data: {
-            name: 'arg',
-          },
+      },
+    },
+    {
+      code: `
+export const Foo: JSX.Element = (
+  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
+);
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
         },
-      ],
+      },
     },
     {
       code: `
-let test = arg => argl;
-test = (): void => {
+const test = (): void => {
   return;
 };
 export default test;
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
     },
     {
       code: `
-let test = arg => argl;
-test = (): void => {
+function test(): void {
+  return;
+}
+export default test;
+      `,
+    },
+    {
+      code: `
+const test = (): void => {
   return;
 };
-export { test };
+export default [test];
       `,
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          data: {
-            name: 'arg',
-          },
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-        },
-      ],
     },
     {
       code: `
-export const foo =
-  () =>
-  (a: string): ((n: number) => string) => {
-    return function (n) {
-      return String(n);
-    };
-  };
+function test(): void {
+  return;
+}
+export default [test];
       `,
-      options: [{ allowHigherOrderFunctions: false }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          column: 6,
-        },
-      ],
     },
     {
       code: `
-export var arrowFn = () => () => {};
+const test = (): void => {
+  return;
+};
+export default { test };
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          column: 31,
-        },
-      ],
     },
     {
       code: `
-export function fn() {
-  return function () {};
+function test(): void {
+  return;
 }
+export default { test };
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 3,
-          column: 10,
-        },
-      ],
     },
     {
       code: `
-export function foo(outer) {
-  return function (inner): void {};
+const foo = (arg => arg) as Foo;
+export default foo;
+      `,
+    },
+    {
+      code: `
+let foo = (arg => arg) as Foo;
+foo = 3;
+export default foo;
+      `,
+    },
+    {
+      code: `
+class Foo {
+  bar = (arg: string): string => arg;
+}
+export default { Foo };
+      `,
+    },
+    {
+      code: `
+class Foo {
+  bar(): void {
+    return;
+  }
+}
+export default { Foo };
+      `,
+    },
+    {
+      code: `
+export function foo(): (n: number) => string {
+  return n => String(n);
+}
+      `,
+    },
+    {
+      code: `
+export const foo = (a: string): ((n: number) => string) => {
+  return function (n) {
+    return String(n);
+  };
+};
+      `,
+    },
+    {
+      code: `
+export function a(): void {
+  function b() {}
+  const x = () => {};
+  (function () {});
+
+  function c() {
+    return () => {};
+  }
+
+  return;
+}
+      `,
+    },
+    {
+      code: `
+export function a(): void {
+  function b() {
+    function c() {}
+  }
+  const x = () => {
+    return () => 100;
+  };
+  (function () {
+    (function () {});
+  });
+
+  function c() {
+    return () => {
+      (function () {});
+    };
+  }
+
+  return;
 }
       `,
-      options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingArgType',
-          line: 2,
-          column: 21,
-          data: {
-            name: 'outer',
-          },
-        },
-        {
-          messageId: 'missingArgType',
-          line: 3,
-          column: 20,
-          data: {
-            name: 'inner',
-          },
-        },
-      ],
     },
     {
       code: `
-export function foo(outer: boolean) {
-  if (outer) {
-    return 'string';
-  }
-  return function (inner): void {};
+export function a() {
+  return function b(): () => void {
+    return function c() {};
+  };
 }
       `,
       options: [{ allowHigherOrderFunctions: true }],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          column: 8,
-          data: {
-            name: 'inner',
-          },
-        },
-      ],
     },
-    // test a few different argument patterns
     {
       code: `
-export function foo({ foo }): void {}
+export var arrowFn = () => (): void => {};
       `,
-      errors: [
-        {
-          messageId: 'missingArgTypeUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Object pattern',
-          },
-        },
-      ],
     },
     {
       code: `
-export function foo([bar]): void {}
+export function fn() {
+  return function (): void {};
+}
       `,
-      errors: [
-        {
-          messageId: 'missingArgTypeUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Array pattern',
-          },
-        },
-      ],
     },
     {
       code: `
-export function foo(...bar): void {}
+export function foo(outer: string) {
+  return function (inner: string): void {};
+}
       `,
-      errors: [
+    },
+    // shouldn't check functions that aren't directly exported - https://github.com/typescript-eslint/typescript-eslint/issues/2134
+    `
+export function foo(): unknown {
+  return new Proxy(apiInstance, {
+    get: (target, property) => {
+      // implementation
+    },
+  });
+}
+    `,
+    {
+      code: 'export default (() => true)();',
+      options: [
         {
-          messageId: 'missingArgType',
-          line: 2,
-          column: 21,
-          data: {
-            name: 'bar',
-          },
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
+    // explicit assertions are allowed
+    {
+      code: 'export const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: false }],
+    },
     {
       code: `
-export function foo(...[a]): void {}
+interface Foo {}
+export const x = {
+  foo: () => {},
+} as Foo;
       `,
-      errors: [
-        {
-          messageId: 'missingArgTypeUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Rest',
-          },
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     // allowArgumentsExplicitlyTypedAsAny
     {
       code: `
 export function foo(foo: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-      errors: [
-        {
-          messageId: 'anyTypedArg',
-          line: 2,
-          column: 21,
-          data: {
-            name: 'foo',
-          },
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo({ foo }: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-      errors: [
-        {
-          messageId: 'anyTypedArgUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Object pattern',
-          },
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo([bar]: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-      errors: [
-        {
-          messageId: 'anyTypedArgUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Array pattern',
-          },
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo(...bar: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-      errors: [
-        {
-          messageId: 'anyTypedArg',
-          line: 2,
-          column: 21,
-          data: {
-            name: 'bar',
-          },
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo(...[a]: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-      errors: [
-        {
-          messageId: 'anyTypedArgUnnamed',
-          line: 2,
-          column: 21,
-          data: {
-            type: 'Rest',
-          },
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
+    // assignment patterns are ignored
+    `
+export function foo(arg = 1): void {}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2161
     {
       code: `
-export function func1() {
-  return 0;
+export const foo = (): ((n: number) => string) => n => String(n);
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2173
+    `
+export function foo(): (n: number) => (m: number) => string {
+  return function (n) {
+    return function (m) {
+      return String(n + m);
+    };
+  };
 }
-export const foo = {
-  func2() {
-    return 0;
+    `,
+    `
+export const foo = (): ((n: number) => (m: number) => string) => n => m =>
+  String(n + m);
+    `,
+    `
+export const bar: () => (n: number) => string = () => n => String(n);
+    `,
+    `
+type Buz = () => (n: number) => string;
+
+export const buz: Buz = () => n => String(n);
+    `,
+    `
+export abstract class Foo<T> {
+  abstract set value(element: T);
+}
+    `,
+    `
+export declare class Foo {
+  set time(seconds: number);
+}
+    `,
+    `
+export class A {
+  b = A;
+}
+    `,
+    `
+interface Foo {
+  f: (x: boolean) => boolean;
+}
+
+export const a: Foo[] = [
+  {
+    f: (x: boolean) => x,
   },
+];
+    `,
+    `
+interface Foo {
+  f: (x: boolean) => boolean;
+}
+
+export const a: Foo = {
+  f: (x: boolean) => x,
 };
-      `,
-      options: [
-        {
-          allowedNames: [],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'missingReturnType',
-          line: 2,
-          endLine: 2,
-          column: 8,
-          endColumn: 22,
-        },
-        {
-          messageId: 'missingReturnType',
-          line: 6,
-          endLine: 6,
-          column: 3,
-          endColumn: 8,
-        },
-      ],
-    },
+    `,
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/init-declarations.test.ts b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
index 7b55d034f0d8..ae5ff0264df8 100644
--- a/packages/eslint-plugin/tests/rules/init-declarations.test.ts
+++ b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
@@ -5,748 +5,760 @@ import rule from '../../src/rules/init-declarations';
 const ruleTester = new RuleTester();
 
 ruleTester.run('init-declarations', rule, {
-  valid: [
+  invalid: [
     // checking compatibility with base rule
-    'var foo = null;',
-    'foo = true;',
-    `
-var foo = 1,
+    {
+      code: 'var foo;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 8,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
+    },
+    {
+      code: 'for (var a in []) var foo;',
+      errors: [
+        {
+          column: 23,
+          data: { idName: 'foo' },
+          endColumn: 26,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
+    },
+    {
+      code: `
+var foo,
   bar = false,
-  baz = {};
-    `,
-    `
+  baz;
+      `,
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 8,
+          endLine: 2,
+          line: 2,
+          messageId: 'initialized',
+        },
+        {
+          column: 3,
+          data: { idName: 'baz' },
+          endColumn: 6,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
+    },
+    {
+      code: `
 function foo() {
   var foo = 0;
-  var bar = [];
-}
-    `,
-    'var fn = function () {};',
-    'var foo = (bar = 2);',
-    'for (var i = 0; i < 1; i++) {}',
-    `
-for (var foo in []) {
+  var bar;
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
+    },
     {
       code: `
-for (var foo of []) {
+function foo() {
+  var foo;
+  var bar = foo;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'let a = true;',
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'foo' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'const a = {};',
+      code: 'let a;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'a' },
+          endColumn: 6,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
   let a = 1,
-    b = false;
+    b;
   if (a) {
     let c = 3,
       d = null;
   }
 }
       `,
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'b' },
+          endColumn: 6,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
-  const a = 1,
-    b = true;
-  if (a) {
-    const c = 3,
-      d = null;
-  }
+  let a;
+  const b = false;
+  var c;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'a' },
+          endColumn: 8,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+        {
+          column: 7,
+          data: { idName: 'c' },
+          endColumn: 8,
+          endLine: 5,
+          line: 5,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: `
-function foo() {
-  let a = 1;
-  const b = false;
-  var c = true;
-}
-      `,
-      options: ['always'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'var foo = (bar = 2);',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 20,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
-      code: 'var foo;',
+      code: 'var foo = true;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 15,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'var foo, bar, baz;',
+      code: `
+var foo,
+  bar = 5,
+  baz = 3;
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+        {
+          column: 3,
+          data: { idName: 'baz' },
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
   var foo;
-  var bar;
+  var bar = foo;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'let a;',
-      options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'const a = 1;',
+      code: 'let a = 1;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'a' },
+          endColumn: 10,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
-  let a, b;
+  let a = 'foo',
+    b;
   if (a) {
     let c, d;
   }
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'a' },
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-function foo() {
-  const a = 1,
-    b = true;
-  if (a) {
-    const c = 3,
-      d = null;
-  }
-}
-      `,
-      options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
   let a;
   const b = false;
-  var c;
+  var c = 1;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'c' },
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'for (var i = 0; i < 1; i++) {}',
-      options: ['never', { ignoreForLoopInit: true }],
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'i' },
+          endColumn: 15,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
 for (var foo in []) {
 }
       `,
-      options: ['never', { ignoreForLoopInit: true }],
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'foo' },
+          endColumn: 13,
+          endLine: 2,
+          line: 2,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
 for (var foo of []) {
 }
       `,
-      options: ['never', { ignoreForLoopInit: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'foo' },
+          endColumn: 13,
+          endLine: 2,
+          line: 2,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
 function foo() {
-  var bar = 1;
-  let baz = 2;
-  const qux = 3;
+  var bar;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
 
     // typescript-eslint
     {
-      code: 'declare const foo: number;',
-      options: ['always'],
+      code: "let arr: string[] = ['arr', 'ar'];",
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 34,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
-      code: 'declare const foo: number;',
+      code: 'let arr: string = function () {};',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 33,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
       code: `
-declare namespace myLib {
-  let numberOfGreetings: number;
-}
+const class1 = class NAME {
+  constructor() {
+    var name1: string = 'hello';
+  }
+};
       `,
+      errors: [
+        {
+          column: 9,
+          data: { idName: 'name1' },
+          endColumn: 32,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
+    },
+    {
+      code: 'let arr: string;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 8,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
     {
       code: `
-declare namespace myLib {
+namespace myLib {
   let numberOfGreetings: number;
 }
       `,
-      options: ['never'],
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'numberOfGreetings' },
+          endColumn: 24,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
-interface GreetingSettings {
-  greeting: string;
-  duration?: number;
-  color?: string;
+namespace myLib {
+  let numberOfGreetings: number = 2;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'numberOfGreetings' },
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
-interface GreetingSettings {
-  greeting: string;
-  duration?: number;
-  color?: string;
+namespace myLib1 {
+  const foo: number;
+  namespace myLib2 {
+    let bar: string;
+    namespace myLib3 {
+      let baz: object;
+    }
+  }
 }
       `,
-      options: ['never'],
-    },
-    'type GreetingLike = string | (() => string) | Greeter;',
-    {
-      code: 'type GreetingLike = string | (() => string) | Greeter;',
-      options: ['never'],
+      errors: [
+        {
+          column: 9,
+          data: { idName: 'foo' },
+          endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+        {
+          column: 9,
+          data: { idName: 'bar' },
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
+          messageId: 'initialized',
+        },
+        {
+          column: 11,
+          data: { idName: 'baz' },
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
+  ],
+  valid: [
+    // checking compatibility with base rule
+    'var foo = null;',
+    'foo = true;',
+    `
+var foo = 1,
+  bar = false,
+  baz = {};
+    `,
+    `
+function foo() {
+  var foo = 0;
+  var bar = [];
+}
+    `,
+    'var fn = function () {};',
+    'var foo = (bar = 2);',
+    'for (var i = 0; i < 1; i++) {}',
+    `
+for (var foo in []) {
+}
+    `,
     {
       code: `
-function foo() {
-  var bar: string;
+for (var foo of []) {
 }
       `,
-      options: ['never'],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'var bar: string;',
-      options: ['never'],
+      code: 'let a = true;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['always'],
     },
     {
-      code: `
-var bar: string = function (): string {
-  return 'string';
-};
-      `,
+      code: 'const a = {};',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
     {
       code: `
-var bar: string = function (arg1: stirng): string {
-  return 'string';
-};
+function foo() {
+  let a = 1,
+    b = false;
+  if (a) {
+    let c = 3,
+      d = null;
+  }
+}
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
-    {
-      code: "function foo(arg1: string = 'string'): void {}",
-      options: ['never'],
-    },
-    {
-      code: "const foo: string = 'hello';",
-      options: ['never'],
-    },
     {
       code: `
-const class1 = class NAME {
-  constructor() {
-    var name1: string = 'hello';
+function foo() {
+  const a = 1,
+    b = true;
+  if (a) {
+    const c = 3,
+      d = null;
   }
-};
+}
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['always'],
     },
     {
       code: `
-const class1 = class NAME {
-  static pi: number = 3.14;
-};
+function foo() {
+  let a = 1;
+  const b = false;
+  var c = true;
+}
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['always'],
     },
     {
-      code: `
-const class1 = class NAME {
-  static pi: number = 3.14;
-};
-      `,
+      code: 'var foo;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: `
-interface IEmployee {
-  empCode: number;
-  empName: string;
-  getSalary: (number) => number; // arrow function
-  getManagerName(number): string;
-}
-      `,
+      code: 'var foo, bar, baz;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
     },
     {
       code: `
-interface IEmployee {
-  empCode: number;
-  empName: string;
-  getSalary: (number) => number; // arrow function
-  getManagerName(number): string;
+function foo() {
+  var foo;
+  var bar;
 }
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: "const foo: number = 'asd';",
-      options: ['always'],
-    },
-    {
-      code: 'const foo: number;',
+      code: 'let a;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: `
-namespace myLib {
-  let numberOfGreetings: number;
-}
-      `,
+      code: 'const a = 1;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
       code: `
-namespace myLib {
-  let numberOfGreetings: number = 2;
+function foo() {
+  let a, b;
+  if (a) {
+    let c, d;
+  }
 }
       `,
-      options: ['always'],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
     },
     {
       code: `
-declare namespace myLib1 {
-  const foo: number;
-  namespace myLib2 {
-    let bar: string;
-    namespace myLib3 {
-      let baz: object;
-    }
+function foo() {
+  const a = 1,
+    b = true;
+  if (a) {
+    const c = 3,
+      d = null;
   }
 }
       `,
-      options: ['always'],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
     },
-
     {
       code: `
-declare namespace myLib1 {
-  const foo: number;
-  namespace myLib2 {
-    let bar: string;
-    namespace myLib3 {
-      let baz: object;
-    }
-  }
+function foo() {
+  let a;
+  const b = false;
+  var c;
 }
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
-  ],
-  invalid: [
-    // checking compatibility with base rule
-    {
-      code: 'var foo;',
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'foo' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 8,
-        },
-      ],
-    },
     {
-      code: 'for (var a in []) var foo;',
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'foo' },
-          line: 1,
-          column: 23,
-          endLine: 1,
-          endColumn: 26,
-        },
-      ],
-    },
-    {
-      code: `
-var foo,
-  bar = false,
-  baz;
-      `,
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'foo' },
-          line: 2,
-          column: 5,
-          endLine: 2,
-          endColumn: 8,
-        },
-        {
-          messageId: 'initialized',
-          data: { idName: 'baz' },
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 6,
-        },
-      ],
+      code: 'for (var i = 0; i < 1; i++) {}',
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
-function foo() {
-  var foo = 0;
-  var bar;
+for (var foo in []) {
 }
       `,
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'bar' },
-          line: 4,
-          column: 7,
-          endLine: 4,
-          endColumn: 10,
-        },
-      ],
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
-function foo() {
-  var foo;
-  var bar = foo;
+for (var foo of []) {
 }
       `,
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'foo' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 10,
-        },
-      ],
-    },
-    {
-      code: 'let a;',
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'a' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 6,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
 function foo() {
-  let a = 1,
-    b;
-  if (a) {
-    let c = 3,
-      d = null;
-  }
+  var bar = 1;
+  let baz = 2;
+  const qux = 3;
 }
       `,
       options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'b' },
-          line: 4,
-          column: 5,
-          endLine: 4,
-          endColumn: 6,
-        },
-      ],
     },
+
+    // typescript-eslint
     {
-      code: `
-function foo() {
-  let a;
-  const b = false;
-  var c;
-}
-      `,
+      code: 'declare const foo: number;',
       options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'a' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 8,
-        },
-        {
-          messageId: 'initialized',
-          data: { idName: 'c' },
-          line: 5,
-          column: 7,
-          endLine: 5,
-          endColumn: 8,
-        },
-      ],
-    },
-    {
-      code: 'var foo = (bar = 2);',
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'foo' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 20,
-        },
-      ],
     },
     {
-      code: 'var foo = true;',
+      code: 'declare const foo: number;',
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'foo' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 15,
-        },
-      ],
     },
     {
       code: `
-var foo,
-  bar = 5,
-  baz = 3;
+declare namespace myLib {
+  let numberOfGreetings: number;
+}
       `,
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'bar' },
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 10,
-        },
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'baz' },
-          line: 4,
-          column: 3,
-          endLine: 4,
-          endColumn: 10,
-        },
-      ],
+      options: ['always'],
     },
     {
       code: `
-function foo() {
-  var foo;
-  var bar = foo;
+declare namespace myLib {
+  let numberOfGreetings: number;
 }
       `,
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'bar' },
-          line: 4,
-          column: 7,
-          endLine: 4,
-          endColumn: 16,
-        },
-      ],
-    },
-    {
-      code: 'let a = 1;',
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'a' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 10,
-        },
-      ],
     },
     {
       code: `
-function foo() {
-  let a = 'foo',
-    b;
-  if (a) {
-    let c, d;
-  }
+interface GreetingSettings {
+  greeting: string;
+  duration?: number;
+  color?: string;
 }
       `,
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'a' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 16,
-        },
-      ],
     },
     {
       code: `
-function foo() {
-  let a;
-  const b = false;
-  var c = 1;
+interface GreetingSettings {
+  greeting: string;
+  duration?: number;
+  color?: string;
 }
       `,
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'c' },
-          line: 5,
-          column: 7,
-          endLine: 5,
-          endColumn: 12,
-        },
-      ],
     },
+    'type GreetingLike = string | (() => string) | Greeter;',
     {
-      code: 'for (var i = 0; i < 1; i++) {}',
+      code: 'type GreetingLike = string | (() => string) | Greeter;',
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'i' },
-          line: 1,
-          column: 10,
-          endLine: 1,
-          endColumn: 15,
-        },
-      ],
     },
     {
       code: `
-for (var foo in []) {
+function foo() {
+  var bar: string;
 }
       `,
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'foo' },
-          line: 2,
-          column: 10,
-          endLine: 2,
-          endColumn: 13,
-        },
-      ],
+    },
+    {
+      code: 'var bar: string;',
+      options: ['never'],
     },
     {
       code: `
-for (var foo of []) {
-}
+var bar: string = function (): string {
+  return 'string';
+};
       `,
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'foo' },
-          line: 2,
-          column: 10,
-          endLine: 2,
-          endColumn: 13,
-        },
-      ],
+      options: ['always'],
     },
     {
       code: `
-function foo() {
-  var bar;
-}
+var bar: string = function (arg1: stirng): string {
+  return 'string';
+};
       `,
       options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'bar' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 10,
-        },
-      ],
     },
-
-    // typescript-eslint
     {
-      code: "let arr: string[] = ['arr', 'ar'];",
+      code: "function foo(arg1: string = 'string'): void {}",
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'arr' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 34,
-        },
-      ],
     },
     {
-      code: 'let arr: string = function () {};',
+      code: "const foo: string = 'hello';",
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'arr' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 33,
-        },
-      ],
     },
     {
       code: `
@@ -754,33 +766,52 @@ const class1 = class NAME {
   constructor() {
     var name1: string = 'hello';
   }
+};
+      `,
+    },
+    {
+      code: `
+const class1 = class NAME {
+  static pi: number = 3.14;
+};
+      `,
+    },
+    {
+      code: `
+const class1 = class NAME {
+  static pi: number = 3.14;
 };
       `,
       options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'name1' },
-          line: 4,
-          column: 9,
-          endLine: 4,
-          endColumn: 32,
-        },
-      ],
     },
     {
-      code: 'let arr: string;',
+      code: `
+interface IEmployee {
+  empCode: number;
+  empName: string;
+  getSalary: (number) => number; // arrow function
+  getManagerName(number): string;
+}
+      `,
+    },
+    {
+      code: `
+interface IEmployee {
+  empCode: number;
+  empName: string;
+  getSalary: (number) => number; // arrow function
+  getManagerName(number): string;
+}
+      `,
+      options: ['never'],
+    },
+    {
+      code: "const foo: number = 'asd';",
       options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'arr' },
-          line: 1,
-          column: 5,
-          endLine: 1,
-          endColumn: 8,
-        },
-      ],
+    },
+    {
+      code: 'const foo: number;',
+      options: ['never'],
     },
     {
       code: `
@@ -788,17 +819,7 @@ namespace myLib {
   let numberOfGreetings: number;
 }
       `,
-      options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'numberOfGreetings' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 24,
-        },
-      ],
+      options: ['never'],
     },
     {
       code: `
@@ -806,21 +827,11 @@ namespace myLib {
   let numberOfGreetings: number = 2;
 }
       `,
-      options: ['never'],
-      errors: [
-        {
-          messageId: 'notInitialized',
-          data: { idName: 'numberOfGreetings' },
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 36,
-        },
-      ],
+      options: ['always'],
     },
     {
       code: `
-namespace myLib1 {
+declare namespace myLib1 {
   const foo: number;
   namespace myLib2 {
     let bar: string;
@@ -831,32 +842,21 @@ namespace myLib1 {
 }
       `,
       options: ['always'],
-      errors: [
-        {
-          messageId: 'initialized',
-          data: { idName: 'foo' },
-          line: 3,
-          column: 9,
-          endLine: 3,
-          endColumn: 12,
-        },
-        {
-          messageId: 'initialized',
-          data: { idName: 'bar' },
-          line: 5,
-          column: 9,
-          endLine: 5,
-          endColumn: 12,
-        },
-        {
-          messageId: 'initialized',
-          data: { idName: 'baz' },
-          line: 7,
-          column: 11,
-          endLine: 7,
-          endColumn: 14,
-        },
-      ],
+    },
+
+    {
+      code: `
+declare namespace myLib1 {
+  const foo: number;
+  namespace myLib2 {
+    let bar: string;
+    namespace myLib3 {
+      let baz: object;
+    }
+  }
+}
+      `,
+      options: ['never'],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/max-params.test.ts b/packages/eslint-plugin/tests/rules/max-params.test.ts
index ad6bc8dcdd52..88bc13124a55 100644
--- a/packages/eslint-plugin/tests/rules/max-params.test.ts
+++ b/packages/eslint-plugin/tests/rules/max-params.test.ts
@@ -5,6 +5,47 @@ import rule from '../../src/rules/max-params';
 const ruleTester = new RuleTester();
 
 ruleTester.run('max-params', rule, {
+  invalid: [
+    { code: 'function foo(a, b, c, d) {}', errors: [{ messageId: 'exceed' }] },
+    {
+      code: 'const foo = function (a, b, c, d) {};',
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: 'const foo = (a, b, c, d) => {};',
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: 'const foo = a => {};',
+      errors: [{ messageId: 'exceed' }],
+      options: [{ max: 0 }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: void, a, b, c, d) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: void, a) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+      options: [{ countVoidThis: true, max: 1 }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: Foo, a, b, c) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+    },
+  ],
   valid: [
     'function foo() {}',
     'const foo = function () {};',
@@ -55,48 +96,7 @@ class Foo {
   method(this: void, a) {}
 }
       `,
-      options: [{ max: 2, countVoidThis: true }],
-    },
-  ],
-  invalid: [
-    { code: 'function foo(a, b, c, d) {}', errors: [{ messageId: 'exceed' }] },
-    {
-      code: 'const foo = function (a, b, c, d) {};',
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: 'const foo = (a, b, c, d) => {};',
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: 'const foo = a => {};',
-      options: [{ max: 0 }],
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: void, a, b, c, d) {}
-}
-      `,
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: void, a) {}
-}
-      `,
-      options: [{ max: 1, countVoidThis: true }],
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: Foo, a, b, c) {}
-}
-      `,
-      errors: [{ messageId: 'exceed' }],
+      options: [{ countVoidThis: true, max: 2 }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering.test.ts b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
index 7f04b83b7f3a..f5b41826e8a7 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
@@ -1,14 +1,17 @@
 import type { RunTests } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../src/rules/member-ordering';
+
 import rule from '../../src/rules/member-ordering';
 
 const ruleTester = new RuleTester();
 
 const grouped: RunTests<MessageIds, Options> = {
-  valid: [
-    `
+  invalid: [
+    {
+      code: `
 // no accessibility === public
 interface Foo {
   [Z: string]: any;
@@ -18,119 +21,252 @@ interface Foo {
   D: string;
   E: string;
   F: string;
-  new ();
   G();
   H();
   I();
   J();
   K();
   L();
+  new ();
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
     {
       code: `
-// no accessibility === public
-interface Foo {
-  A: string;
-  J();
-  K();
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  G();
-  H();
-  [Z: string]: any;
-  B: string;
-  C: string;
-  I();
-  L();
+interface X {
+  a: unknown;
+  (): void;
+  b(): void;
 }
       `,
-      options: [{ default: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'call',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['call-signature', 'field', 'method'] }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
-  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-  new ();
   G();
   H();
   I();
   J();
   K();
   L();
+  new ();
+  [Z: string]: any;
 }
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
-    },
-    {
-      code: `
-interface X {
-  (): void;
-  a: unknown;
-  b(): void;
-}
-      `,
-      options: [{ default: ['call-signature', 'field', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
   A: string;
-  J();
-  K();
+  B: string;
+  C: string;
   D: string;
-  [Z: string]: any;
   E: string;
   F: string;
-  new ();
   G();
-  B: string;
-  C: string;
   H();
   I();
+  J();
+  K();
   L();
+  new ();
+  [Z: string]: any;
 }
       `,
-      options: [{ interfaces: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        { interfaces: ['method', 'signature', 'constructor', 'field'] },
+      ],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
-  [Z: string]: any;
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  new ();
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-}
-      `,
-      options: [
-        { interfaces: ['signature', 'method', 'constructor', 'field'] },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-interface Foo {
   G();
   H();
   I();
@@ -138,19 +274,87 @@ interface Foo {
   K();
   L();
   new ();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['signature', 'field', 'constructor', 'method'],
-          interfaces: ['method', 'constructor', 'field', 'signature'],
+          default: ['field', 'method', 'constructor', 'signature'],
+          interfaces: ['method', 'signature', 'constructor', 'field'],
         },
       ],
     },
@@ -158,99 +362,75 @@ interface Foo {
       code: `
 // no accessibility === public
 interface Foo {
+  [Z: string]: any;
+  new ();
+  A: string;
   G();
+  B: string;
   H();
+  C: string;
   I();
-  new ();
-  [Z: string]: any;
   D: string;
-  E: string;
-  F: string;
-  G?: string;
   J();
+  E: string;
   K();
+  F: string;
   L();
-  A: string;
-  B: string;
-  C: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'private-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'method',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'method',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-// no accessibility === public
-interface Foo {
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  [Z: string]: any;
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  A: string;
-  B: string;
-  C: string;
-}
-      `,
       options: [
         {
-          default: ['method', 'public-constructor', 'protected-static-field'],
+          interfaces: ['signature', 'constructor', 'field', 'method'],
         },
       ],
     },
-    `
-// no accessibility === public
-type Foo = {
-  [Z: string]: any;
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-};
-    `,
-    {
-      code: `
-// no accessibility === public
-type Foo = {
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  [Z: string]: any;
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-};
-      `,
-      options: [{ default: 'never' }],
-    },
     {
       code: `
 // no accessibility === public
@@ -268,16 +448,25 @@ type Foo = {
   J();
   K();
   L();
+  new ();
 };
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  [Z: string]: any;
-  new ();
   A: string;
   B: string;
   C: string;
@@ -290,183 +479,354 @@ type Foo = {
   J();
   K();
   L();
-};
-      `,
-      options: [{ default: ['field', 'method'] }],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
-  G();
-  H();
   [Z: string]: any;
-  K();
-  L();
-  A: string;
-  B: string;
-  I();
-  J();
-  C: string;
-  D: string;
-  E: string;
-  F: string;
+  new ();
 };
       `,
-      options: [{ typeLiterals: 'never' }],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  [Z: string]: any;
-};
-      `,
-      options: [{ typeLiterals: ['method', 'field', 'signature'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
+  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-  [Z: string]: any;
-};
-      `,
-      options: [
-        { typeLiterals: ['method', 'constructor', 'field', 'signature'] },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
   G();
   H();
   I();
   J();
   K();
   L();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  [Z: string]: any;
+  new ();
 };
       `,
-      options: [
+      errors: [
         {
-          default: ['signature', 'field', 'constructor', 'method'],
-          typeLiterals: ['method', 'constructor', 'field', 'signature'],
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'signature',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'signature',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'signature',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'signature',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'signature',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
         },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'signature',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'signature',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        { typeLiterals: ['method', 'constructor', 'signature', 'field'] },
       ],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  [Z: string]: any;
-  D: string;
-  E: string;
-  F: string;
   A: string;
   B: string;
   C: string;
+  D: string;
+  E: string;
+  F: string;
   G();
   H();
   I();
   J();
   K();
   L();
+  new ();
+  [Z: string]: any;
 };
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          typeLiterals: ['signature', 'field', 'method'],
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
         },
-      ],
-    },
-    `
-class Foo {
-  [Z: string]: any;
-  public static A: string;
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
-}
-    `,
-    {
-      code: `
-class Foo {
-  [Z: string]: any;
-  public static A: string;
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
-}
-      `,
-      options: [{ default: 'never' }],
-    },
-    {
-      code: `
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: ['field', 'method', 'constructor', 'signature'],
+          typeLiterals: ['signature', 'method', 'constructor', 'field'],
+        },
+      ],
+    },
+    {
+      code: `
+// no accessibility === public
+type Foo = {
+  new ();
+  [Z: string]: any;
+  A: string;
+  G();
+  B: string;
+  H();
+  C: string;
+  I();
+  D: string;
+  J();
+  E: string;
+  K();
+  F: string;
+  L();
+};
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'method',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'method',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          typeLiterals: ['constructor', 'signature', 'field', 'method'],
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   [Z: string]: any;
-  public static A: string;
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -475,24 +835,60 @@ class Foo {
   private F: string = '';
   #F: string = '';
   constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
   #L() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  static #I() {}
 }
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'public instance method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 18,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 19,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 20,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  [Z: string]: any;
   constructor() {}
-  public static A: string;
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -500,269 +896,360 @@ class Foo {
   protected E: string = '';
   private F: string = '';
   #F: string = '';
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
   #L() {}
-}
-      `,
-      options: [{ default: ['field', 'method'] }],
-    },
-    {
-      code: `
-class Foo {
-  public static G() {}
-  protected K() {}
-  private L() {}
-  private static I() {}
-  public J() {}
-  public D: string = '';
-  [Z: string]: any;
-  protected static H() {}
-  public static A: string;
-  protected static B: string = '';
-  constructor() {}
-  private static C: string = '';
-  protected E: string = '';
-  private F: string = '';
-}
-      `,
-      options: [{ classes: 'never' }],
-    },
-    {
-      code: `
-class Foo {
   public static G() {}
   protected static H() {}
   private static I() {}
   static #I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
   [Z: string]: any;
-  public static A: string;
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  constructor() {}
 }
       `,
-      options: [{ classes: ['method', 'field'] }],
-    },
-    {
-      code: `
-class Foo {
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  constructor() {}
-  public static A: string;
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'constructor',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'constructor',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'constructor',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['field', 'constructor', 'method', 'signature'] }],
+    },
+    {
+      code: `
+class Foo {
+  constructor() {}
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  [Z: string]: any;
-}
-      `,
-      options: [{ classes: ['method', 'constructor', 'field', 'signature'] }],
-    },
-    {
-      code: `
-class Foo {
-  private required: boolean;
-  private typeChecker: (data: any) => boolean;
-  constructor(validator: (data: any) => boolean) {
-    this.typeChecker = validator;
-  }
-  check(data: any): boolean {
-    return this.typeChecker(data);
-  }
-}
-      `,
-      options: [{ classes: ['field', 'constructor', 'method'] }],
-    },
-    {
-      code: `
-class Foo {
   public static G() {}
+  public static A: string;
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  constructor() {}
-  public static A: string;
-  protected static B: string = '';
-  private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  [Z: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['signature', 'field', 'constructor', 'method'],
-          classes: ['method', 'constructor', 'field', 'signature'],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
 class Foo {
-  public J() {}
-  public static G() {}
   protected static H() {}
   private static I() {}
+  public J() {}
   protected K() {}
   private L() {}
-  [Z: string]: any;
-  constructor() {}
-  public D: string = '';
   public static A: string;
-  private static C: string = '';
-  private F: string = '';
-  static #M: string = '';
-  #N: string = '';
+  public static G() {}
   protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
   protected E: string = '';
+  private F: string = '';
+  constructor() {}
 }
       `,
-      options: [
+      errors: [
         {
-          classes: [
-            'public-method',
-            'signature',
-            'constructor',
-            'public-field',
-            'private-field',
-            '#private-field',
-            'protected-field',
-          ],
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['method', 'field'] }],
     },
     {
       code: `
 class Foo {
   public static G() {}
-  private static I() {}
   protected static H() {}
+  protected static B: string = '';
+  private static I() {}
   public J() {}
-  private L() {}
   protected K() {}
-  [Z: string]: any;
+  private L() {}
+  public static A: string;
   constructor() {}
+  private static C: string = '';
   public D: string = '';
-  public static A: string;
-  protected static B: string = '';
   protected E: string = '';
-  private static C: string = '';
   private F: string = '';
-  #M: string = '';
 }
       `,
-      options: [
+      errors: [
         {
-          classes: [
-            'public-static-method',
-            'static-method',
-            'public-instance-method',
-            'instance-method',
-            'signature',
-            'constructor',
-            'public-field',
-            'protected-field',
-            'private-field',
-            '#private-field',
-          ],
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ classes: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
 class Foo {
-  public J() {}
+  public static A: string;
   public static G() {}
-  public D: string = '';
-  public static A: string = '';
-  constructor() {}
-  protected K() {}
-  private L() {}
-  #P() {}
   protected static H() {}
   private static I() {}
-  static #O() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  constructor() {}
   protected static B: string = '';
   private static C: string = '';
-  static #N: string = '';
+  public D: string = '';
   protected E: string = '';
   private F: string = '';
-  #M: string = '';
-  [Z: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'public-method',
-            'public-field',
-            'constructor',
-            'method',
-            'field',
-            'signature',
-          ],
-        },
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          classes: ['method', 'constructor', 'field'],
+          default: ['field', 'constructor', 'method'],
+        },
       ],
     },
     {
       code: `
 class Foo {
+  private L() {}
   public J() {}
   public static G() {}
   protected static H() {}
   private static I() {}
-  static #I() {}
   protected K() {}
-  private L() {}
-  #L() {}
   constructor() {}
-  [Z: string]: any;
+  public D: string = '';
+  private static C: string = '';
   public static A: string;
+  private static C: string = '';
+  protected static B: string = '';
   private F: string = '';
-  #F: string = '';
   protected static B: string = '';
-  public D: string = '';
-  private static C: string = '';
-  static #C: string = '';
   protected E: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'private field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'protected field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classes: [
             'public-method',
-            'protected-static-method',
-            '#private-static-method',
-            'protected-instance-method',
-            'private-instance-method',
-            '#private-instance-method',
             'constructor',
-            'signature',
-            'field',
+            'public-field',
+            'private-field',
+            'protected-field',
           ],
         },
       ],
@@ -770,236 +1257,348 @@ class Foo {
     {
       code: `
 class Foo {
-  private L() {}
-  private static I() {}
-  protected static H() {}
-  protected static B: string = '';
   public static G() {}
+  private static I() {}
   public J() {}
+  protected static H() {}
+  private L() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
-  public static A: string;
   public D: string = '';
   constructor() {}
-  [Z: string]: any;
+  public static A: string;
+  protected static B: string = '';
+  protected E: string = '';
+  private static C: string = '';
+  private F: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: ['private-instance-method', 'protected-static-field'],
+          classes: [
+            'public-static-method',
+            'static-method',
+            'public-instance-method',
+            'instance-method',
+            'constructor',
+            'public-field',
+            'protected-field',
+            'private-field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
+  public J() {}
+  public static G() {}
+  public D: string = '';
+  public static A: string = '';
   private L() {}
+  constructor() {}
+  protected K() {}
+  protected static H() {}
   private static I() {}
-  static #H() {}
-  static #B: string = '';
-  public static G() {}
-  public J() {}
-  #K() {}
+  protected static B: string = '';
   private static C: string = '';
+  protected E: string = '';
   private F: string = '';
-  #E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
-  [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: ['private-instance-method', 'protected-static-field'],
+          default: [
+            'public-method',
+            'public-field',
+            'constructor',
+            'method',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  private L() {}
+  public J() {}
   private static I() {}
-  protected static H() {}
   public static G() {}
-  public J() {}
-  protected static B: string = '';
+  protected static H() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
+  private L() {}
+  constructor() {}
   public static A: string;
+  private F: string = '';
+  protected static B: string = '';
   public D: string = '';
-  constructor() {}
-  [Z: string]: any;
+  private static C: string = '';
+  protected E: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'private static method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'private static method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['public-instance-method', 'protected-static-field'],
+          classes: [
+            'public-method',
+            'protected-static-method',
+            'private-static-method',
+            'protected-instance-method',
+            'private-instance-method',
+            'constructor',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  private L() {}
   private static I() {}
   protected static H() {}
+  protected static B: string = '';
   public static G() {}
   public J() {}
-  protected static B: string = '';
   protected K() {}
   private static C: string = '';
+  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
   public D: string = '';
   constructor() {}
-  [Z: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          classes: ['public-instance-method', 'protected-static-field'],
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  [Z: string]: any;
-  public D: string = '';
-  private L() {}
-  private static I() {}
-  protected static H() {}
-  public static G() {}
-  public J() {}
-  private constructor() {}
-  protected static B: string = '';
-  protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
-  public static A: string;
-}
-      `,
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'protected static field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          classes: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
+          classes: ['private-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  public constructor() {}
-  public D: string = '';
   private L() {}
   private static I() {}
   protected static H() {}
   public static G() {}
-  public J() {}
-  [Z: string]: any;
   protected static B: string = '';
+  public J() {}
   protected K() {}
   private static C: string = '';
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'protected static field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          classes: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
+          default: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
-    `
+    {
+      code: `
 const foo = class Foo {
-  [Z: string]: any;
-  public static A: string;
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
   constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-};
-    `,
-    {
-      code: `
-const foo = class Foo {
-  constructor() {}
-  public static A: string;
-  protected static B: string = '';
-  private static I() {}
-  public J() {}
-  private F: string = '';
-  [Z: string]: any;
   public static G() {}
-  private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   protected static H() {}
-  protected K() {}
-  private L() {}
+  private static I() {}
 };
       `,
-      options: [{ default: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'public instance method',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   [Z: string]: any;
-  public static A: string;
+  constructor() {}
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
   public J() {}
   protected K() {}
   private L() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'constructor',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'constructor',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'constructor',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
@@ -1007,6 +1606,7 @@ const foo = class Foo {
   private F: string = '';
   [Z: string]: any;
   public static G() {}
+  public static A: string;
   protected static H() {}
   private static I() {}
   public J() {}
@@ -1014,85 +1614,129 @@ const foo = class Foo {
   private L() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
-const foo = class Foo {
-  private L() {}
-  protected static H() {}
-  constructor() {}
-  private static I() {}
-  public J() {}
-  private static C: string = '';
-  [Z: string]: any;
-  public D: string = '';
-  protected K() {}
-  public static G() {}
-  public static A: string;
-  protected static B: string = '';
-  protected E: string = '';
-  private F: string = '';
-};
-      `,
-      options: [{ classExpressions: 'never' }],
-    },
-    {
-      code: `
-const foo = class Foo {
-  public static G() {}
+const foo = class {
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
   public static A: string;
+  public static G() {}
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
   constructor() {}
-  [Z: string]: any;
 };
       `,
-      options: [{ classExpressions: ['method', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'field'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   public static G() {}
   protected static H() {}
+  protected static B: string = '';
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  [Z: string]: any;
-  constructor() {}
   public static A: string;
-  protected static B: string = '';
+  constructor() {}
+  [Z: string]: any;
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
 };
       `,
-      options: [
-        { classExpressions: ['method', 'signature', 'constructor', 'field'] },
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
       ],
+      options: [{ classExpressions: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
+  public static A: string;
   public static G() {}
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  [Z: string]: any;
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
@@ -1100,444 +1744,709 @@ const foo = class Foo {
   private F: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
+          classExpressions: ['method', 'constructor', 'field'],
           default: ['field', 'constructor', 'method'],
-          classExpressions: ['method', 'signature', 'constructor', 'field'],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  [Z: string]: any;
+const foo = class {
   private L() {}
-  private static I() {}
-  protected static H() {}
-  protected static B: string = '';
-  public static G() {}
   public J() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
   protected K() {}
+  constructor() {}
+  public D: string = '';
+  private static C: string = '';
+  public static A: string;
   private static C: string = '';
+  protected static B: string = '';
   private F: string = '';
+  protected static B: string = '';
   protected E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'private field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'protected field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classExpressions: [
-            'private-instance-method',
-            'protected-static-field',
+            'public-method',
+            'constructor',
+            'public-field',
+            'private-field',
+            'protected-field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  private L() {}
-  private static I() {}
-  protected static H() {}
+const foo = class {
   public static G() {}
+  private static I() {}
   public J() {}
-  [Z: string]: any;
-  protected static B: string = '';
+  protected static H() {}
+  private L() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
-  public static A: string;
   public D: string = '';
   constructor() {}
-};
-      `,
-      options: [
-        {
-          default: ['public-instance-method', 'protected-static-field'],
-        },
-      ],
-    },
-    {
-      code: `
-const foo = class Foo {
-  private L() {}
-  private static I() {}
-  protected static H() {}
-  public static G() {}
-  public J() {}
-  [Z: string]: any;
+  public static A: string;
   protected static B: string = '';
-  protected K() {}
+  protected E: string = '';
   private static C: string = '';
   private F: string = '';
-  protected E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classExpressions: [
+            'public-static-method',
+            'static-method',
             'public-instance-method',
-            'protected-static-field',
+            'instance-method',
+            'constructor',
+            'public-field',
+            'protected-field',
+            'private-field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
+  public J() {}
+  public static G() {}
   public D: string = '';
+  public static A: string = '';
   private L() {}
-  private static I() {}
+  constructor() {}
+  protected K() {}
   protected static H() {}
-  public static G() {}
-  public J() {}
-  [Z: string]: any;
-  private constructor() {}
+  private static I() {}
   protected static B: string = '';
-  protected K() {}
   private static C: string = '';
-  private F: string = '';
   protected E: string = '';
-  public static A: string;
+  private F: string = '';
 };
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          classes: [
-            'public-instance-method',
-            'protected-constructor',
-            'protected-static-method',
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: [
+            'public-method',
+            'public-field',
+            'constructor',
+            'method',
+            'field',
           ],
+        },
+      ],
+    },
+    {
+      code: `
+const foo = class {
+  public J() {}
+  private static I() {}
+  public static G() {}
+  protected static H() {}
+  protected K() {}
+  private L() {}
+  constructor() {}
+  public static A: string;
+  private F: string = '';
+  protected static B: string = '';
+  public D: string = '';
+  private static C: string = '';
+  protected E: string = '';
+};
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'private static method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'private static method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
           classExpressions: [
-            'public-instance-field',
-            'private-constructor',
+            'public-method',
+            'protected-static-method',
+            'private-static-method',
             'protected-instance-method',
+            'private-instance-method',
+            'constructor',
+            'field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  public constructor() {}
-  public D: string = '';
-  private L() {}
+const foo = class {
   private static I() {}
   protected static H() {}
+  protected static B: string = '';
   public static G() {}
   public J() {}
-  protected static B: string = '';
   protected K() {}
-  [Z: string]: any;
   private static C: string = '';
+  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'protected static field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          classes: [
-            'public-instance-method',
-            'protected-constructor',
-            'protected-static-method',
-          ],
           classExpressions: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
+            'private-instance-method',
+            'protected-static-field',
           ],
         },
       ],
     },
-    `
+    {
+      code: `
+const foo = class {
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  protected static B: string = '';
+  public J() {}
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
+};
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'protected static field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: ['public-instance-method', 'protected-static-field'],
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  [Z: string]: any;
+  K = () => {};
   A: string;
   constructor() {}
+  [Z: string]: any;
   J() {}
-  K = () => {};
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'public instance method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public instance method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
     {
       code: `
 class Foo {
   J() {}
-  K = () => {};
   constructor() {}
+  K = () => {};
   A: string;
   [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
     },
     {
       code: `
 class Foo {
   J() {}
-  K = () => {};
   constructor() {}
-  [Z: string]: any;
-  A: string;
+  K = () => {};
   L: () => {};
+  A: string;
 }
       `,
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
-class Foo {
-  static {}
-  m() {}
-  f = 1;
+interface Foo {
+  K: () => {};
+  J();
+  A: string;
 }
       `,
-      options: [{ default: ['static-initialization', 'method', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
-class Foo {
-  m() {}
-  f = 1;
-  static {}
-}
+type Foo = {
+  K: () => {};
+  J();
+  A: string;
+};
       `,
-      options: [{ default: ['method', 'field', 'static-initialization'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
-class Foo {
-  f = 1;
-  static {}
-  m() {}
-}
-      `,
-      options: [{ default: ['field', 'static-initialization', 'method'] }],
-    },
-    `
-interface Foo {
-  [Z: string]: any;
-  A: string;
-  K: () => {};
-  J();
-}
-    `,
-    {
-      code: `
-interface Foo {
-  [Z: string]: any;
-  J();
-  K: () => {};
-  A: string;
-}
-      `,
-      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
-    },
-    `
 type Foo = {
-  [Z: string]: any;
   A: string;
   K: () => {};
   J();
-};
-    `,
-    {
-      code: `
-type Foo = {
-  J();
-  [Z: string]: any;
-  K: () => {};
-  A: string;
 };
       `,
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
 abstract class Foo {
-  B: string;
-  abstract A: () => {};
-}
-      `,
-    },
-    {
-      code: `
-interface Foo {
-  [A: string]: number;
+  abstract A(): void;
   B: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 abstract class Foo {
-  [Z: string]: any;
-  private static C: string;
+  abstract A: () => {};
   B: string;
-  private D: string;
-  protected static F(): {};
-  public E(): {};
-  public abstract A(): void;
-  protected abstract G(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 abstract class Foo {
-  protected typeChecker: (data: any) => boolean;
-  public abstract required: boolean;
-  abstract verify(): void;
-}
-      `,
-      options: [{ classes: ['signature', 'field', 'constructor', 'method'] }],
-    },
-    {
-      code: `
-class Foo {
-  @Dec() B: string;
-  @Dec() A: string;
-  constructor() {}
-  D: string;
-  C: string;
-  E(): void;
-  F(): void;
-}
-      `,
-      options: [{ default: ['decorated-field', 'field'] }],
-    },
-    {
-      code: `
-class Foo {
-  A: string;
+  abstract A: () => {};
   B: string;
-  @Dec() private C: string;
-  private D: string;
+  public C() {}
+  private D() {}
+  abstract E() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['public-field', 'private-decorated-field', 'private-field'],
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor() {}
-  @Dec() public A(): void {}
-  @Dec() private B: string;
-  private C(): void;
-  private D: string;
+  C: number;
+  [A: string]: number;
+  public static D(): {};
+  static [B: string]: number;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'signature',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
-            'decorated-method',
-            'private-decorated-field',
-            'private-method',
+            'field',
+            'method',
+            'public-static-method',
+            'private-static-method',
+            'signature',
           ],
         },
       ],
     },
     {
       code: `
-class Foo {
-  @Dec() private A(): void {}
-  @Dec() private B: string;
-  constructor() {}
-  private C(): void;
-  private D: string;
+abstract class Foo {
+  abstract B: string;
+  abstract A(): void;
+  public C(): {};
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'private-decorated-method',
-            'private-decorated-field',
-            'constructor',
-            'private-field',
-          ],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  public A: string;
-  @Dec() private B: string;
+  B: string;
+  @Dec() A: string = '';
+  C: string = '';
+  constructor() {}
+  D() {}
+  E() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['private-decorated-field', 'public-instance-field'],
-          classes: ['public-instance-field', 'private-decorated-field'],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['decorated-field', 'field'] }],
     },
-    // class + ignore decorator
     {
       code: `
 class Foo {
-  public A(): string;
-  @Dec() public B(): string {}
-  public C(): string;
+  A() {}
 
-  d: string;
+  @Decorator()
+  B() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['public-method', 'field'],
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 5, // Symbol starts at the line with decorator
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['decorated-method', 'method'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  constructor() {}
-  get B() {}
-  set B() {}
-  get C() {}
-  set C() {}
-  D(): void;
+  @Decorator() C() {}
+  A() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['field', 'constructor', ['get', 'set'], 'method'],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'decorated method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['public-method', 'decorated-method'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  constructor() {}
+  A(): void;
   B(): void;
+  private C() {}
+  constructor() {}
+  @Dec() private D() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'private method',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['field', 'constructor', [], 'method'],
+          classes: ['public-method', 'decorated-method', 'private-method'],
         },
       ],
     },
@@ -1545,13 +2454,53 @@ class Foo {
       code: `
 class Foo {
   A: string;
+  get B() {}
   constructor() {}
-  @Dec() private B: string;
+  set B() {}
+  get C() {}
+  set C() {}
+  D(): void;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'get, set',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: ['field', 'constructor', ['get', 'set'], 'method'],
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  A: string;
   private C(): void;
+  constructor() {}
+  @Dec() private B: string;
   set D() {}
   E(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'private decorated field, public set, private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
@@ -1569,193 +2518,357 @@ class Foo {
   A: string;
   constructor() {}
   get B() {}
-  get C() {}
   set B() {}
+  get C() {}
   set C() {}
   D(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'set',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['field', 'constructor', ['get'], ['set'], 'method'],
+          default: ['field', 'constructor', 'get', ['set'], 'method'],
         },
       ],
     },
     {
-      name: 'with private identifier',
       code: `
-// no accessibility === public
 class Foo {
-  imPublic() {}
-  #imPrivate() {}
+  static {}
+  m() {}
+  f = 1;
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: ['public-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'm',
+            rank: 'static initialization',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'f',
+            rank: 'static initialization',
           },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['method', 'field', 'static-initialization'] }],
     },
     {
-      name: 'private and #private member order',
       code: `
-// no accessibility === public
 class Foo {
-  private imPrivate() {}
-  #imPrivate() {}
+  m() {}
+  f = 1;
+  static {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: ['private-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'method',
           },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['static-initialization', 'method', 'field'] }],
     },
     {
-      name: '#private and private member order',
       code: `
-// no accessibility === public
 class Foo {
-  #imPrivate() {}
-  private imPrivate() {}
+  f = 1;
+  static {}
+  m() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: ['#private-method', 'private-method'],
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'field',
           },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['static-initialization', 'field', 'method'] }],
     },
     {
-      name: 'default member types with alphabetically-case-insensitive order',
       code: `
-// no accessibility === public
 class Foo {
-  [A: string]: any;
-  [a: string]: any;
-  static C: boolean;
-  static d: boolean;
-  b: any;
-  B: any;
-  get e(): string {}
-  get E(): string {}
-  private imPrivate() {}
-  private ImPrivate() {}
+  static {}
+  f = 1;
+  m() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'f',
+            rank: 'static initialization',
           },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['field', 'static-initialization', 'method'] }],
     },
     {
       code: `
 class Foo {
-  readonly B: string;
-  readonly A: string;
-  constructor() {}
-  D: string;
-  C: string;
-  E(): void;
-  F(): void;
+  private mp() {}
+  static {}
+  public m() {}
+  @dec
+  md() {}
 }
       `,
-      options: [{ default: ['readonly-field', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'md',
+            rank: 'method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        { default: ['decorated-method', 'static-initialization', 'method'] },
+      ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  A: string;
-  B: string;
-  private readonly C: string;
-  private D: string;
+  #imPrivate() {}
+  imPublic() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPublic',
+            rank: '#private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'with private identifier',
       options: [
         {
-          default: ['public-field', 'private-readonly-field', 'private-field'],
+          default: {
+            memberTypes: ['public-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
+          },
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  private readonly A: string;
-  constructor() {}
-  private B: string;
+  #imPrivate() {}
+  private imPrivate() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPrivate',
+            rank: '#private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'private and #private member order',
       options: [
         {
-          default: ['private-readonly-field', 'constructor', 'private-field'],
+          default: {
+            memberTypes: ['private-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
+          },
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  public A: string;
-  private readonly B: string;
+  static C: boolean;
+  [B: string]: any;
+  private A() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['private-readonly-field', 'public-instance-field'],
-          classes: ['public-instance-field', 'private-readonly-field'],
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public static field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'default member types with alphabetically order',
+      options: [
+        {
+          default: {
+            order: 'alphabetically',
+          },
         },
       ],
     },
-    // class + ignore readonly
     {
       code: `
+// no accessibility === public
 class Foo {
-  public A(): string;
-  public B(): string;
-  public C(): string;
-
-  d: string;
-  readonly e: string;
-  f: string;
+  static C: boolean;
+  [B: string]: any;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            beforeMember: 'C',
+            member: 'B',
+          },
+          line: 5,
+          messageId: 'incorrectOrder',
+        },
+      ],
+      name: 'alphabetically order without member types',
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+    {
+      code: `
+// no accessibility === public
+class Foo {
+  private imPrivate() {}
+  #imPrivate() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPrivate',
+            rank: 'private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: '#private and private member order',
       options: [
         {
-          default: ['public-method', 'field'],
+          default: {
+            memberTypes: ['#private-method', 'private-method'],
+            order: 'alphabetically-case-insensitive',
+          },
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  private readonly A: string;
-  readonly B: string;
-  C: string;
+  B: string;
+  readonly A: string = '';
+  C: string = '';
   constructor() {}
-  @Dec() private D: string;
-  private E(): void;
-  set F() {}
-  G(): void;
+  D() {}
+  E() {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['readonly-field', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  A: string;
+  private C(): void;
+  constructor() {}
+  private readonly B: string;
+  set D() {}
+  E(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public set, private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
-            'readonly-field',
+            'private-readonly-field',
             'public-field',
             'constructor',
-            ['private-decorated-field', 'public-set', 'private-method'],
+            ['public-set', 'private-method'],
             'public-method',
           ],
         },
@@ -1764,58 +2877,51 @@ class Foo {
     {
       code: `
 abstract class Foo {
-  public static readonly SA: string;
-  protected static readonly SB: string;
-  private static readonly SC: string;
-  static readonly #SD: string;
-
-  public readonly IA: string;
-  protected readonly IB: string;
-  private readonly IC: string;
-  readonly #ID: string;
-
-  public abstract readonly AA: string;
-  protected abstract readonly AB: string;
+  @Dec public readonly A: string;
+  public readonly B: string;
+  public static readonly C: string;
+  static readonly #D: string;
+  readonly #E: string;
 
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
+  @Dec public F: string;
+  public G: string;
+  public static H: string;
+  static readonly #I: string;
+  readonly #J: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'readonly field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'public-static-readonly-field',
-            'protected-static-readonly-field',
-            'private-static-readonly-field',
-            '#private-static-readonly-field',
-
-            'static-readonly-field',
-
-            'public-instance-readonly-field',
-            'protected-instance-readonly-field',
-            'private-instance-readonly-field',
-            '#private-instance-readonly-field',
-
-            'instance-readonly-field',
-
-            'public-readonly-field',
-            'protected-readonly-field',
-            'private-readonly-field',
-            '#private-readonly-field',
-
-            'readonly-field',
-
-            'public-abstract-readonly-field',
-            'protected-abstract-readonly-field',
-
-            'abstract-readonly-field',
-
-            'public-decorated-readonly-field',
-            'protected-decorated-readonly-field',
-            'private-decorated-readonly-field',
-            'decorated-readonly-field',
-          ],
+          default: ['decorated-field', 'readonly-field', 'field'],
         },
       ],
     },
@@ -1840,143 +2946,109 @@ abstract class Foo {
   protected abstract readonly AB: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'AA',
+            rank: 'static readonly field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'AB',
+            rank: 'static readonly field',
+          },
+          line: 18,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
             'decorated-readonly-field',
+            'abstract-readonly-field',
             'static-readonly-field',
             'instance-readonly-field',
-            'abstract-readonly-field',
           ],
         },
       ],
     },
     {
       code: `
-abstract class Foo {
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
-
-  public static readonly SA: string;
-  public readonly IA: string;
-  public abstract readonly AA: string;
-
-  protected static readonly SB: string;
-  protected readonly IB: string;
-  protected abstract readonly AB: string;
-
-  private static readonly SC: string;
-  private readonly IC: string;
+interface Foo {
+  readonly A: string;
+  readonly B: string;
 
-  static readonly #SD: string;
-  readonly #ID: string;
+  C: string;
+  D: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'decorated-readonly-field',
-            'public-readonly-field',
-            'protected-readonly-field',
-            'private-readonly-field',
-          ],
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'readonly field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
         },
-      ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
-
-  public static readonly SA: string;
-  public readonly IA: string;
-  static readonly #SD: string;
-  readonly #ID: string;
-
-  protected static readonly SB: string;
-  protected readonly IB: string;
-
-  private static readonly SC: string;
-  private readonly IC: string;
-
-  public abstract readonly AA: string;
-  protected abstract readonly AB: string;
-}
-      `,
-      options: [
         {
-          default: [
-            'decorated-readonly-field',
-            ['public-readonly-field', 'readonly-field'],
-            'protected-readonly-field',
-            'private-readonly-field',
-            'abstract-readonly-field',
-          ],
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'readonly field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly A: string;
-  @Dec public B: string;
-
-  public readonly C: string;
-  public static readonly D: string;
-  public E: string;
-  public static F: string;
-
-  static readonly #G: string;
-  readonly #H: string;
-  static #I: string;
-  #J: string;
-}
-      `,
       options: [
         {
-          default: [
-            ['decorated-field', 'decorated-readonly-field'],
-            ['field', 'readonly-field'],
-            ['#private-field', '#private-readonly-field'],
-          ],
+          default: ['field', 'readonly-field'],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  readonly A: string;
-  readonly B: string;
+  [i: number]: string;
+  readonly [i: string]: string;
 
-  C: string;
-  D: string;
+  A: string;
+  readonly B: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['readonly-field', 'field'],
+          column: 3,
+          data: {
+            name: 'i',
+            rank: 'signature',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-interface Foo {
-  readonly [i: string]: string;
-  readonly A: string;
-
-  [i: number]: string;
-  B: string;
-}
-      `,
       options: [
         {
           default: [
             'readonly-signature',
-            'readonly-field',
             'signature',
+            'readonly-field',
             'field',
           ],
         },
@@ -1984,181 +3056,202 @@ interface Foo {
     },
     {
       code: `
-interface Foo {
-  readonly [i: string]: string;
-  [i: number]: string;
+class Foo {
+  accessor bar;
 
-  readonly A: string;
-  B: string;
+  baz() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'baz',
+            rank: 'accessor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'readonly-signature',
-            'signature',
-            'readonly-field',
-            'field',
-          ],
+          default: ['method', 'accessor'],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  readonly A: string;
-  B: string;
-
-  [i: number]: string;
-  readonly [i: string]: string;
+  y(): void;
+  get x(): number;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'x',
+            rank: 'method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['readonly-field', 'field', 'signature'],
+          default: ['get', 'method'],
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6812
     {
       code: `
-class Foo {
-  #bar: string;
-
-  get bar(): string {
-    return this.#bar;
-  }
-
-  set bar(value: string) {
-    this.#bar = value;
-  }
+interface Foo {
+  get x(): number;
+  y(): void;
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: [['get', 'set']],
-            order: 'alphabetically',
+          column: 3,
+          data: {
+            name: 'y',
+            rank: 'get',
           },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      name: 'default member types with alphabetically order',
-      code: `
-// no accessibility === public
-class Foo {
-  [A: string]: any;
-  [B: string]: any;
-  [a: string]: any;
-  [b: string]: any;
-  static C: boolean;
-  static d: boolean;
-  get E(): string {}
-  get e(): string {}
-  private ImPrivate() {}
-  private imPrivate() {}
-}
-      `,
       options: [
         {
-          default: {
-            order: 'alphabetically',
-          },
+          default: ['method', 'get'],
         },
       ],
     },
+  ],
+  valid: [
+    `
+// no accessibility === public
+interface Foo {
+  [Z: string]: any;
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+}
+    `,
     {
-      name: 'alphabetically order without member types',
       code: `
 // no accessibility === public
 interface Foo {
   A: string;
-  B: string;
-  [Z: string]: any;
-  c();
+  J();
+  K();
+  D: string;
+  E: string;
+  F: string;
   new ();
-  r();
+  G();
+  H();
+  [Z: string]: any;
+  B: string;
+  C: string;
+  I();
+  L();
 }
       `,
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      options: [{ default: 'never' }],
     },
     {
       code: `
-class Foo {
-  #bar: string;
-
-  get bar(): string {
-    return this.#bar;
-  }
-
-  set bar(value: string) {
-    this.#bar = value;
-  }
+// no accessibility === public
+interface Foo {
+  [Z: string]: any;
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: [['get', 'set']],
-            order: 'natural',
-          },
-        },
-      ],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-class Foo {
-  accessor bar;
-
-  baz() {}
+interface X {
+  (): void;
+  a: unknown;
+  b(): void;
 }
       `,
-      options: [
-        {
-          default: ['accessor', 'method'],
-        },
-      ],
+      options: [{ default: ['call-signature', 'field', 'method'] }],
     },
     {
       code: `
+// no accessibility === public
 interface Foo {
-  get x(): number;
-  y(): void;
+  A: string;
+  J();
+  K();
+  D: string;
+  [Z: string]: any;
+  E: string;
+  F: string;
+  new ();
+  G();
+  B: string;
+  C: string;
+  H();
+  I();
+  L();
 }
       `,
-      options: [
-        {
-          default: ['get', 'method'],
-        },
-      ],
+      options: [{ interfaces: 'never' }],
     },
     {
       code: `
+// no accessibility === public
 interface Foo {
-  y(): void;
-  get x(): number;
+  [Z: string]: any;
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+  new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
 }
       `,
       options: [
-        {
-          default: ['method', 'get'],
-        },
+        { interfaces: ['signature', 'method', 'constructor', 'field'] },
       ],
     },
-  ],
-  invalid: [
     {
       code: `
 // no accessibility === public
 interface Foo {
-  [Z: string]: any;
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   G();
   H();
   I();
@@ -2166,38 +3259,50 @@ interface Foo {
   K();
   L();
   new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  [Z: string]: any;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'method',
-          },
-          line: 17,
-          column: 3,
+          default: ['signature', 'field', 'constructor', 'method'],
+          interfaces: ['method', 'constructor', 'field', 'signature'],
         },
       ],
     },
     {
       code: `
-interface X {
-  a: unknown;
-  (): void;
-  b(): void;
+// no accessibility === public
+interface Foo {
+  G();
+  H();
+  I();
+  new ();
+  [Z: string]: any;
+  D: string;
+  E: string;
+  F: string;
+  G?: string;
+  J();
+  K();
+  L();
+  A: string;
+  B: string;
+  C: string;
 }
       `,
-      options: [{ default: ['call-signature', 'field', 'method'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'call',
-            rank: 'field',
-          },
-          line: 4,
-          column: 3,
+          default: [
+            'private-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
     },
@@ -2205,375 +3310,95 @@ interface X {
       code: `
 // no accessibility === public
 interface Foo {
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
   [Z: string]: any;
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  A: string;
+  B: string;
+  C: string;
 }
       `,
-      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          column: 3,
-        },
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          column: 3,
+          default: ['method', 'public-constructor', 'protected-static-field'],
         },
       ],
     },
-    {
-      code: `
+    `
 // no accessibility === public
-interface Foo {
+type Foo = {
+  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+  new ();
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
-  [Z: string]: any;
-}
-      `,
-      options: [
-        { interfaces: ['method', 'signature', 'constructor', 'field'] },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          column: 3,
-        },
-      ],
-    },
+};
+    `,
     {
       code: `
 // no accessibility === public
-interface Foo {
+type Foo = {
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+  [Z: string]: any;
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
-  [Z: string]: any;
-}
+};
       `,
-      options: [
-        {
-          default: ['field', 'method', 'constructor', 'signature'],
-          interfaces: ['method', 'signature', 'constructor', 'field'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          column: 3,
-        },
-      ],
+      options: [{ default: 'never' }],
     },
     {
       code: `
 // no accessibility === public
-interface Foo {
+type Foo = {
   [Z: string]: any;
-  new ();
   A: string;
-  G();
   B: string;
-  H();
   C: string;
-  I();
   D: string;
-  J();
   E: string;
-  K();
   F: string;
+  G();
+  H();
+  I();
+  J();
+  K();
   L();
-}
+};
       `,
-      options: [
-        {
-          interfaces: ['signature', 'constructor', 'field', 'method'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'method',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'method',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'E',
-            rank: 'method',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'method',
-          },
-          line: 16,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
   [Z: string]: any;
+  new ();
   A: string;
   B: string;
   C: string;
@@ -2586,776 +3411,353 @@ type Foo = {
   J();
   K();
   L();
-  new ();
 };
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'method',
-          },
-          line: 17,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
+  G();
+  H();
+  [Z: string]: any;
+  K();
+  L();
   A: string;
   B: string;
+  I();
+  J();
   C: string;
   D: string;
   E: string;
   F: string;
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  [Z: string]: any;
-  new ();
 };
       `,
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 16,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 17,
-          column: 3,
-        },
-      ],
+      options: [{ typeLiterals: 'never' }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  [Z: string]: any;
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  [Z: string]: any;
 };
       `,
-      options: [
-        { typeLiterals: ['method', 'constructor', 'signature', 'field'] },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'signature',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'signature',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'signature',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'signature',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'signature',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'signature',
-          },
-          line: 16,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'signature',
-          },
-          line: 17,
-          column: 3,
-        },
-      ],
+      options: [{ typeLiterals: ['method', 'field', 'signature'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
   [Z: string]: any;
 };
       `,
       options: [
-        {
-          default: ['field', 'method', 'constructor', 'signature'],
-          typeLiterals: ['signature', 'method', 'constructor', 'field'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          column: 3,
-        },
+        { typeLiterals: ['method', 'constructor', 'field', 'signature'] },
       ],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  new ();
-  [Z: string]: any;
-  A: string;
   G();
-  B: string;
   H();
-  C: string;
   I();
-  D: string;
   J();
-  E: string;
   K();
-  F: string;
   L();
-};
-      `,
-      options: [
-        {
-          typeLiterals: ['constructor', 'signature', 'field', 'method'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'method',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'method',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'E',
-            rank: 'method',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'method',
-          },
-          line: 16,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  [Z: string]: any;
-  public static A: string = '';
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  constructor() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
-}
-      `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'public instance method',
-          },
-          line: 17,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 18,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 19,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 20,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  constructor() {}
-  public static A: string = '';
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
   [Z: string]: any;
-}
-      `,
-      options: [{ default: ['field', 'constructor', 'method', 'signature'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'constructor',
-          },
-          line: 4,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'constructor',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'constructor',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'E',
-            rank: 'constructor',
-          },
-          line: 9,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 10,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 11,
-          column: 3,
+};
+      `,
+      options: [
+        {
+          default: ['signature', 'field', 'constructor', 'method'],
+          typeLiterals: ['method', 'constructor', 'field', 'signature'],
         },
       ],
     },
     {
       code: `
+// no accessibility === public
+type Foo = {
+  [Z: string]: any;
+  D: string;
+  E: string;
+  F: string;
+  A: string;
+  B: string;
+  C: string;
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+};
+      `,
+      options: [
+        {
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
+          typeLiterals: ['signature', 'field', 'method'],
+        },
+      ],
+    },
+    `
 class Foo {
-  constructor() {}
+  [Z: string]: any;
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
+  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  #F: string = '';
+  constructor() {}
   public static G() {}
-  public static A: string;
   protected static H() {}
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
+  #L() {}
 }
-      `,
-      options: [{ default: ['field', 'method'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
-    },
+    `,
     {
       code: `
 class Foo {
+  [Z: string]: any;
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  static #C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  #F: string = '';
+  constructor() {}
+  public static G() {}
   protected static H() {}
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
+  #L() {}
+}
+      `,
+      options: [{ default: 'never' }],
+    },
+    {
+      code: `
+class Foo {
+  [Z: string]: any;
   public static A: string;
-  public static G() {}
   protected static B: string = '';
   private static C: string = '';
+  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  #F: string = '';
   constructor() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  static #I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  #L() {}
 }
       `,
-      options: [{ default: ['method', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
 class Foo {
+  [Z: string]: any;
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  static #C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  #F: string = '';
   public static G() {}
   protected static H() {}
-  protected static B: string = '';
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
+  #L() {}
+}
+      `,
+      options: [{ default: ['field', 'method'] }],
+    },
+    {
+      code: `
+class Foo {
+  public static G() {}
+  protected K() {}
+  private L() {}
+  private static I() {}
+  public J() {}
+  public D: string = '';
+  [Z: string]: any;
+  protected static H() {}
   public static A: string;
+  protected static B: string = '';
   constructor() {}
   private static C: string = '';
-  public D: string = '';
   protected E: string = '';
   private F: string = '';
 }
       `,
-      options: [{ classes: ['method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
-        },
-      ],
+      options: [{ classes: 'never' }],
     },
     {
       code: `
 class Foo {
-  public static A: string;
   public static G() {}
   protected static H() {}
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
-  constructor() {}
+  #L() {}
+  [Z: string]: any;
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
+  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  #F: string = '';
+  constructor() {}
 }
       `,
-      options: [
-        {
-          default: ['field', 'constructor', 'method'],
-          classes: ['method', 'constructor', 'field'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 4,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
-        },
+      options: [{ classes: ['method', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  [Z: string]: any;
+}
+      `,
+      options: [{ classes: ['method', 'constructor', 'field', 'signature'] }],
+    },
+    {
+      code: `
+class Foo {
+  private required: boolean;
+  private typeChecker: (data: any) => boolean;
+  constructor(validator: (data: any) => boolean) {
+    this.typeChecker = validator;
+  }
+  check(data: any): boolean {
+    return this.typeChecker(data);
+  }
+}
+      `,
+      options: [{ classes: ['field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+class Foo {
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  [Z: string]: any;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
+          classes: ['method', 'constructor', 'field', 'signature'],
+          default: ['signature', 'field', 'constructor', 'method'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  private L() {}
   public J() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   protected K() {}
+  private L() {}
+  [Z: string]: any;
   constructor() {}
   public D: string = '';
-  private static C: string = '';
   public static A: string;
   private static C: string = '';
-  protected static B: string = '';
   private F: string = '';
+  static #M: string = '';
+  #N: string = '';
   protected static B: string = '';
   protected E: string = '';
 }
@@ -3364,50 +3766,34 @@ class Foo {
         {
           classes: [
             'public-method',
+            'signature',
             'constructor',
             'public-field',
             'private-field',
+            '#private-field',
             'protected-field',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'private field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'protected field',
-          },
-          line: 15,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 class Foo {
   public static G() {}
   private static I() {}
-  public J() {}
   protected static H() {}
+  public J() {}
   private L() {}
   protected K() {}
-  public D: string = '';
+  [Z: string]: any;
   constructor() {}
+  public D: string = '';
   public static A: string;
   protected static B: string = '';
   protected E: string = '';
   private static C: string = '';
   private F: string = '';
+  #M: string = '';
 }
       `,
       options: [
@@ -3417,33 +3803,15 @@ class Foo {
             'static-method',
             'public-instance-method',
             'instance-method',
+            'signature',
             'constructor',
             'public-field',
             'protected-field',
             'private-field',
+            '#private-field',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public field',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
@@ -3452,15 +3820,20 @@ class Foo {
   public static G() {}
   public D: string = '';
   public static A: string = '';
-  private L() {}
   constructor() {}
   protected K() {}
+  private L() {}
+  #P() {}
   protected static H() {}
   private static I() {}
+  static #O() {}
   protected static B: string = '';
   private static C: string = '';
+  static #N: string = '';
   protected E: string = '';
   private F: string = '';
+  #M: string = '';
+  [Z: string]: any;
 }
       `,
       options: [
@@ -3471,36 +3844,31 @@ class Foo {
             'constructor',
             'method',
             'field',
+            'signature',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'method',
-          },
-          line: 8,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 class Foo {
   public J() {}
-  private static I() {}
   public static G() {}
   protected static H() {}
+  private static I() {}
+  static #I() {}
   protected K() {}
   private L() {}
+  #L() {}
   constructor() {}
+  [Z: string]: any;
   public static A: string;
   private F: string = '';
+  #F: string = '';
   protected static B: string = '';
   public D: string = '';
   private static C: string = '';
+  static #C: string = '';
   protected E: string = '';
 }
       `,
@@ -3509,38 +3877,21 @@ class Foo {
           classes: [
             'public-method',
             'protected-static-method',
-            'private-static-method',
+            '#private-static-method',
             'protected-instance-method',
             'private-instance-method',
+            '#private-instance-method',
             'constructor',
+            'signature',
             'field',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'private static method',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'private static method',
-          },
-          line: 6,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 class Foo {
+  private L() {}
   private static I() {}
   protected static H() {}
   protected static B: string = '';
@@ -3548,12 +3899,12 @@ class Foo {
   public J() {}
   protected K() {}
   private static C: string = '';
-  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
   public D: string = '';
   constructor() {}
+  [Z: string]: any;
 }
       `,
       options: [
@@ -3561,600 +3912,327 @@ class Foo {
           classes: ['private-instance-method', 'protected-static-field'],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'protected static field',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 class Foo {
   private L() {}
   private static I() {}
-  protected static H() {}
+  static #H() {}
+  static #B: string = '';
   public static G() {}
-  protected static B: string = '';
   public J() {}
-  protected K() {}
+  #K() {}
   private static C: string = '';
   private F: string = '';
-  protected E: string = '';
+  #E: string = '';
   public static A: string;
   public D: string = '';
   constructor() {}
+  [Z: string]: any;
 }
-      `,
-      options: [
-        {
-          default: ['public-instance-method', 'protected-static-field'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'protected static field',
-          },
-          line: 8,
-          column: 3,
-        },
-      ],
-    },
-    {
-      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() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-};
-      `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'public instance method',
-          },
-          line: 13,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 14,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 15,
-          column: 3,
+      `,
+      options: [
+        {
+          classes: ['private-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  [Z: string]: any;
-  constructor() {}
-  public static A: string = '';
+class Foo {
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
   protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   private F: string = '';
-  public J() {}
-  protected K() {}
-  private L() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-};
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
+  [Z: string]: any;
+}
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'constructor',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'constructor',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'constructor',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'E',
-            rank: 'constructor',
-          },
-          line: 9,
-          column: 3,
-        },
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 10,
-          column: 3,
+          default: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  constructor() {}
+class Foo {
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
   protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   private F: string = '';
-  [Z: string]: any;
-  public static G() {}
+  protected E: string = '';
   public static A: string;
-  protected static H() {}
-  private static I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-};
+  public D: string = '';
+  constructor() {}
+  [Z: string]: any;
+}
       `,
-      options: [{ default: ['field', 'method'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 11,
-          column: 3,
+          classes: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  protected static H() {}
-  private static I() {}
-  public J() {}
-  protected K() {}
+class Foo {
+  [Z: string]: any;
+  public D: string = '';
   private L() {}
-  public static A: string;
+  private static I() {}
+  protected static H() {}
   public static G() {}
+  public J() {}
+  private constructor() {}
   protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   private F: string = '';
-  constructor() {}
-};
+  protected E: string = '';
+  public static A: string;
+}
       `,
-      options: [{ default: ['method', 'field'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
+          classes: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  public static G() {}
-  protected static H() {}
-  protected static B: string = '';
+class Foo {
+  public constructor() {}
+  public D: string = '';
+  private L() {}
   private static I() {}
+  protected static H() {}
+  public static G() {}
   public J() {}
-  protected K() {}
-  private L() {}
-  public static A: string;
-  constructor() {}
   [Z: string]: any;
+  protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   private F: string = '';
-};
+  protected E: string = '';
+  public static A: string;
+}
       `,
-      options: [{ classExpressions: ['method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
-        },
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 11,
-          column: 3,
+          classes: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
     },
+    `
+const foo = class Foo {
+  [Z: string]: any;
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  constructor() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+};
+    `,
+    {
+      code: `
+const foo = class Foo {
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  private static I() {}
+  public J() {}
+  private F: string = '';
+  [Z: string]: any;
+  public static G() {}
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  protected static H() {}
+  protected K() {}
+  private L() {}
+};
+      `,
+      options: [{ default: 'never' }],
+    },
     {
       code: `
-const foo = class {
+const foo = class Foo {
+  [Z: string]: any;
   public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  constructor() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
+};
+      `,
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+const foo = class Foo {
   constructor() {}
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  [Z: string]: any;
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
 };
       `,
-      options: [
-        {
-          default: ['field', 'constructor', 'method'],
-          classExpressions: ['method', 'constructor', 'field'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 4,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
   private L() {}
-  public J() {}
-  public static G() {}
   protected static H() {}
-  private static I() {}
-  protected K() {}
   constructor() {}
-  public D: string = '';
+  private static I() {}
+  public J() {}
   private static C: string = '';
+  [Z: string]: any;
+  public D: string = '';
+  protected K() {}
+  public static G() {}
   public static A: string;
-  private static C: string = '';
-  protected static B: string = '';
-  private F: string = '';
   protected static B: string = '';
   protected E: string = '';
+  private F: string = '';
 };
       `,
-      options: [
-        {
-          classExpressions: [
-            'public-method',
-            'constructor',
-            'public-field',
-            'private-field',
-            'protected-field',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'private field',
-          },
-          line: 12,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'protected field',
-          },
-          line: 15,
-          column: 3,
-        },
-      ],
+      options: [{ classExpressions: 'never' }],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
   public static G() {}
+  protected static H() {}
   private static I() {}
   public J() {}
-  protected static H() {}
-  private L() {}
   protected K() {}
-  public D: string = '';
-  constructor() {}
+  private L() {}
   public static A: string;
   protected static B: string = '';
-  protected E: string = '';
   private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
   private F: string = '';
+  constructor() {}
+  [Z: string]: any;
 };
       `,
-      options: [
-        {
-          classExpressions: [
-            'public-static-method',
-            'static-method',
-            'public-instance-method',
-            'instance-method',
-            'constructor',
-            'public-field',
-            'protected-field',
-            'private-field',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 6,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public field',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
+      options: [{ classExpressions: ['method', 'field'] }],
     },
     {
       code: `
-const foo = class {
-  public J() {}
+const foo = class Foo {
   public static G() {}
-  public D: string = '';
-  public static A: string = '';
-  private L() {}
-  constructor() {}
-  protected K() {}
   protected static H() {}
   private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  [Z: string]: any;
+  constructor() {}
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
-  protected E: string = '';
-  private F: string = '';
-};
-      `,
-      options: [
-        {
-          default: [
-            'public-method',
-            'public-field',
-            'constructor',
-            'method',
-            'field',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'method',
-          },
-          line: 8,
-          column: 3,
-        },
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+};
+      `,
+      options: [
+        { classExpressions: ['method', 'signature', 'constructor', 'field'] },
       ],
     },
     {
       code: `
-const foo = class {
-  public J() {}
-  private static I() {}
+const foo = class Foo {
   public static G() {}
   protected static H() {}
+  private static I() {}
+  public J() {}
   protected K() {}
   private L() {}
+  [Z: string]: any;
   constructor() {}
   public static A: string;
-  private F: string = '';
   protected static B: string = '';
-  public D: string = '';
   private static C: string = '';
+  public D: string = '';
   protected E: string = '';
+  private F: string = '';
 };
       `,
       options: [
         {
-          classExpressions: [
-            'public-method',
-            'protected-static-method',
-            'private-static-method',
-            'protected-instance-method',
-            'private-instance-method',
-            'constructor',
-            'field',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'G',
-            rank: 'private static method',
-          },
-          line: 5,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'H',
-            rank: 'private static method',
-          },
-          line: 6,
-          column: 3,
+          classExpressions: ['method', 'signature', 'constructor', 'field'],
+          default: ['field', 'constructor', 'method'],
         },
       ],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
+  [Z: string]: any;
+  private L() {}
   private static I() {}
   protected static H() {}
   protected static B: string = '';
@@ -4162,7 +4240,6 @@ const foo = class {
   public J() {}
   protected K() {}
   private static C: string = '';
-  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
@@ -4178,27 +4255,17 @@ const foo = class {
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'L',
-            rank: 'protected static field',
-          },
-          line: 10,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
   private L() {}
   private static I() {}
   protected static H() {}
   public static G() {}
-  protected static B: string = '';
   public J() {}
+  [Z: string]: any;
+  protected static B: string = '';
   protected K() {}
   private static C: string = '';
   private F: string = '';
@@ -4213,378 +4280,353 @@ const foo = class {
           default: ['public-instance-method', 'protected-static-field'],
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+const foo = class Foo {
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
+  [Z: string]: any;
+  protected static B: string = '';
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
+};
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'protected static field',
-          },
-          line: 8,
-          column: 3,
+          classExpressions: [
+            'public-instance-method',
+            'protected-static-field',
+          ],
         },
       ],
     },
     {
       code: `
-class Foo {
-  K = () => {};
-  A: string;
-  constructor() {}
+const foo = class Foo {
+  public D: string = '';
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
   [Z: string]: any;
-  J() {}
-}
+  private constructor() {}
+  protected static B: string = '';
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+};
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'public instance method',
-          },
-          line: 4,
-          column: 3,
-        },
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public instance method',
-          },
-          line: 5,
-          column: 3,
+          classes: [
+            'public-instance-method',
+            'protected-constructor',
+            'protected-static-method',
+          ],
+          classExpressions: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
+      ],
+    },
+    {
+      code: `
+const foo = class Foo {
+  public constructor() {}
+  public D: string = '';
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
+  protected static B: string = '';
+  protected K() {}
+  [Z: string]: any;
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+};
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'Z',
-            rank: 'public instance method',
-          },
-          line: 6,
-          column: 3,
+          classes: [
+            'public-instance-method',
+            'protected-constructor',
+            'protected-static-method',
+          ],
+          classExpressions: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
     },
+    `
+class Foo {
+  [Z: string]: any;
+  A: string;
+  constructor() {}
+  J() {}
+  K = () => {};
+}
+    `,
     {
       code: `
 class Foo {
   J() {}
-  constructor() {}
   K = () => {};
+  constructor() {}
   A: string;
   [Z: string]: any;
 }
       `,
       options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'constructor',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 class Foo {
   J() {}
-  constructor() {}
   K = () => {};
-  L: () => {};
+  constructor() {}
+  [Z: string]: any;
   A: string;
+  L: () => {};
+}
+      `,
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  static {}
+  m() {}
+  f = 1;
+}
+      `,
+      options: [{ default: ['static-initialization', 'method', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  m() {}
+  f = 1;
+  static {}
+}
+      `,
+      options: [{ default: ['method', 'field', 'static-initialization'] }],
+    },
+    {
+      code: `
+class Foo {
+  f = 1;
+  static {}
+  m() {}
 }
       `,
-      options: [{ default: ['method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'K',
-            rank: 'constructor',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['field', 'static-initialization', 'method'] }],
     },
+    `
+interface Foo {
+  [Z: string]: any;
+  A: string;
+  K: () => {};
+  J();
+}
+    `,
     {
       code: `
 interface Foo {
-  K: () => {};
+  [Z: string]: any;
   J();
+  K: () => {};
   A: string;
 }
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
     },
-    {
-      code: `
+    `
 type Foo = {
+  [Z: string]: any;
+  A: string;
   K: () => {};
   J();
-  A: string;
 };
-      `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
-    },
+    `,
     {
       code: `
 type Foo = {
-  A: string;
-  K: () => {};
   J();
+  [Z: string]: any;
+  K: () => {};
+  A: string;
 };
       `,
-      options: [{ default: ['method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
     },
     {
       code: `
 abstract class Foo {
-  abstract A(): void;
   B: string;
+  abstract A: () => {};
 }
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'public abstract method',
-          },
-          line: 4,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
-abstract class Foo {
-  abstract A: () => {};
+interface Foo {
+  [A: string]: number;
   B: string;
 }
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'public abstract field',
-          },
-          line: 4,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
 abstract class Foo {
-  abstract A: () => {};
+  [Z: string]: any;
+  private static C: string;
   B: string;
-  public C() {}
-  private D() {}
-  abstract E() {}
+  private D: string;
+  protected static F(): {};
+  public E(): {};
+  public abstract A(): void;
+  protected abstract G(): void;
 }
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'public abstract field',
-          },
-          line: 4,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
-class Foo {
-  C: number;
-  [A: string]: number;
-  public static D(): {};
-  static [B: string]: number;
+abstract class Foo {
+  protected typeChecker: (data: any) => boolean;
+  public abstract required: boolean;
+  abstract verify(): void;
 }
       `,
-      options: [
-        {
-          default: [
-            'field',
-            'method',
-            'public-static-method',
-            'private-static-method',
-            'signature',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'signature',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
+      options: [{ classes: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-abstract class Foo {
-  abstract B: string;
-  abstract A(): void;
-  public C(): {};
+class Foo {
+  @Dec() B: string;
+  @Dec() A: string;
+  constructor() {}
+  D: string;
+  C: string;
+  E(): void;
+  F(): void;
 }
       `,
-      options: [{ default: ['method', 'constructor', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 4,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
+      options: [{ default: ['decorated-field', 'field'] }],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
+  A: string;
   B: string;
-  @Dec() A: string = '';
-  C: string = '';
-  constructor() {}
-  D() {}
-  E() {}
+  @Dec() private C: string;
+  private D: string;
 }
       `,
-      options: [{ default: ['decorated-field', 'field'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
+          default: ['public-field', 'private-decorated-field', 'private-field'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  A() {}
-
-  @Decorator()
-  B() {}
+  constructor() {}
+  @Dec() public A(): void {}
+  @Dec() private B: string;
+  private C(): void;
+  private D: string;
 }
       `,
-      options: [{ default: ['decorated-method', 'method'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 5, // Symbol starts at the line with decorator
-          column: 3,
+          default: [
+            'decorated-method',
+            'private-decorated-field',
+            'private-method',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  @Decorator() C() {}
-  A() {}
+  @Dec() private A(): void {}
+  @Dec() private B: string;
+  constructor() {}
+  private C(): void;
+  private D: string;
 }
       `,
-      options: [{ default: ['public-method', 'decorated-method'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'decorated method',
-          },
-          line: 4,
-          column: 3,
+          default: [
+            'private-decorated-method',
+            'private-decorated-field',
+            'constructor',
+            'private-field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  A(): void;
-  B(): void;
-  private C() {}
-  constructor() {}
-  @Dec() private D() {}
+  public A: string;
+  @Dec() private B: string;
 }
       `,
       options: [
         {
-          classes: ['public-method', 'decorated-method', 'private-method'],
+          classes: ['public-instance-field', 'private-decorated-field'],
+          default: ['private-decorated-field', 'public-instance-field'],
         },
       ],
-      errors: [
+    },
+    // class + ignore decorator
+    {
+      code: `
+class Foo {
+  public A(): string;
+  @Dec() public B(): string {}
+  public C(): string;
+
+  d: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'private method',
-          },
-          line: 7,
-          column: 3,
+          default: ['public-method', 'field'],
         },
       ],
     },
@@ -4592,8 +4634,8 @@ class Foo {
       code: `
 class Foo {
   A: string;
-  get B() {}
   constructor() {}
+  get B() {}
   set B() {}
   get C() {}
   set C() {}
@@ -4605,15 +4647,18 @@ class Foo {
           default: ['field', 'constructor', ['get', 'set'], 'method'],
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+class Foo {
+  A: string;
+  constructor() {}
+  B(): void;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'get, set',
-          },
-          line: 5,
-          column: 3,
+          default: ['field', 'constructor', [], 'method'],
         },
       ],
     },
@@ -4621,9 +4666,9 @@ class Foo {
       code: `
 class Foo {
   A: string;
-  private C(): void;
   constructor() {}
   @Dec() private B: string;
+  private C(): void;
   set D() {}
   E(): void;
 }
@@ -4638,17 +4683,6 @@ class Foo {
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'private decorated field, public set, private method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
@@ -4656,410 +4690,318 @@ class Foo {
   A: string;
   constructor() {}
   get B() {}
-  set B() {}
   get C() {}
+  set B() {}
   set C() {}
   D(): void;
 }
       `,
       options: [
         {
-          default: ['field', 'constructor', 'get', ['set'], 'method'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'set',
-          },
-          line: 7,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  static {}
-  m() {}
-  f = 1;
-}
-      `,
-      options: [{ default: ['method', 'field', 'static-initialization'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'm',
-            rank: 'static initialization',
-          },
-          line: 4,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'f',
-            rank: 'static initialization',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  m() {}
-  f = 1;
-  static {}
-}
-      `,
-      options: [{ default: ['static-initialization', 'method', 'field'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'static block',
-            rank: 'method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  f = 1;
-  static {}
-  m() {}
-}
-      `,
-      options: [{ default: ['static-initialization', 'field', 'method'] }],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'static block',
-            rank: 'field',
-          },
-          line: 4,
-          column: 3,
+          default: ['field', 'constructor', ['get'], ['set'], 'method'],
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  static {}
-  f = 1;
-  m() {}
+  imPublic() {}
+  #imPrivate() {}
 }
       `,
-      options: [{ default: ['field', 'static-initialization', 'method'] }],
-      errors: [
+      name: 'with private identifier',
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'f',
-            rank: 'static initialization',
+          default: {
+            memberTypes: ['public-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
           },
-          line: 4,
-          column: 3,
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  private mp() {}
-  static {}
-  public m() {}
-  @dec
-  md() {}
+  private imPrivate() {}
+  #imPrivate() {}
 }
       `,
+      name: 'private and #private member order',
       options: [
-        { default: ['decorated-method', 'static-initialization', 'method'] },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'static block',
-            rank: 'method',
-          },
-          line: 4,
-          column: 3,
-        },
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'md',
-            rank: 'method',
+          default: {
+            memberTypes: ['private-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
           },
-          line: 6,
-          column: 3,
         },
       ],
     },
     {
-      name: 'with private identifier',
       code: `
 // no accessibility === public
 class Foo {
   #imPrivate() {}
-  imPublic() {}
+  private imPrivate() {}
 }
       `,
+      name: '#private and private member order',
       options: [
         {
           default: {
-            memberTypes: ['public-method', '#private-method'],
+            memberTypes: ['#private-method', 'private-method'],
             order: 'alphabetically-case-insensitive',
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'imPublic',
-            rank: '#private method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
     },
     {
-      name: 'private and #private member order',
       code: `
 // no accessibility === public
 class Foo {
-  #imPrivate() {}
+  [A: string]: any;
+  [a: string]: any;
+  static C: boolean;
+  static d: boolean;
+  b: any;
+  B: any;
+  get e(): string {}
+  get E(): string {}
   private imPrivate() {}
+  private ImPrivate() {}
 }
       `,
+      name: 'default member types with alphabetically-case-insensitive order',
       options: [
         {
           default: {
-            memberTypes: ['private-method', '#private-method'],
             order: 'alphabetically-case-insensitive',
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'imPrivate',
-            rank: '#private method',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
     },
     {
-      name: 'default member types with alphabetically order',
       code: `
-// no accessibility === public
 class Foo {
-  static C: boolean;
-  [B: string]: any;
-  private A() {}
+  readonly B: string;
+  readonly A: string;
+  constructor() {}
+  D: string;
+  C: string;
+  E(): void;
+  F(): void;
+}
+      `,
+      options: [{ default: ['readonly-field', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  A: string;
+  B: string;
+  private readonly C: string;
+  private D: string;
 }
       `,
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'public static field',
-          },
-          line: 5,
-          column: 3,
-        },
-      ],
       options: [
         {
-          default: {
-            order: 'alphabetically',
-          },
+          default: ['public-field', 'private-readonly-field', 'private-field'],
         },
       ],
     },
     {
-      name: 'alphabetically order without member types',
       code: `
-// no accessibility === public
 class Foo {
-  static C: boolean;
-  [B: string]: any;
+  private readonly A: string;
+  constructor() {}
+  private B: string;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'B',
-            beforeMember: 'C',
-          },
-          line: 5,
-          column: 3,
+          default: ['private-readonly-field', 'constructor', 'private-field'],
         },
       ],
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
     },
     {
-      name: '#private and private member order',
       code: `
-// no accessibility === public
 class Foo {
-  private imPrivate() {}
-  #imPrivate() {}
+  public A: string;
+  private readonly B: string;
 }
       `,
       options: [
         {
-          default: {
-            memberTypes: ['#private-method', 'private-method'],
-            order: 'alphabetically-case-insensitive',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'imPrivate',
-            rank: 'private method',
-          },
-          line: 5,
-          column: 3,
+          classes: ['public-instance-field', 'private-readonly-field'],
+          default: ['private-readonly-field', 'public-instance-field'],
         },
       ],
     },
+    // class + ignore readonly
     {
       code: `
-// no accessibility === public
 class Foo {
-  B: string;
-  readonly A: string = '';
-  C: string = '';
-  constructor() {}
-  D() {}
-  E() {}
+  public A(): string;
+  public B(): string;
+  public C(): string;
+
+  d: string;
+  readonly e: string;
+  f: string;
 }
       `,
-      options: [{ default: ['readonly-field', 'field'] }],
-      errors: [
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 5,
-          column: 3,
+          default: ['public-method', 'field'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  A: string;
-  private C(): void;
+  private readonly A: string;
+  readonly B: string;
+  C: string;
   constructor() {}
-  private readonly B: string;
-  set D() {}
-  E(): void;
+  @Dec() private D: string;
+  private E(): void;
+  set F() {}
+  G(): void;
 }
       `,
       options: [
         {
           default: [
-            'private-readonly-field',
+            'readonly-field',
             'public-field',
             'constructor',
-            ['public-set', 'private-method'],
+            ['private-decorated-field', 'public-set', 'private-method'],
             'public-method',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public set, private method',
-          },
-          line: 5,
-          column: 3,
-        },
+    },
+    {
+      code: `
+abstract class Foo {
+  public static readonly SA: string;
+  protected static readonly SB: string;
+  private static readonly SC: string;
+  static readonly #SD: string;
+
+  public readonly IA: string;
+  protected readonly IB: string;
+  private readonly IC: string;
+  readonly #ID: string;
+
+  public abstract readonly AA: string;
+  protected abstract readonly AB: string;
+
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'public field',
-          },
-          line: 6,
-          column: 3,
+          default: [
+            'public-static-readonly-field',
+            'protected-static-readonly-field',
+            'private-static-readonly-field',
+            '#private-static-readonly-field',
+
+            'static-readonly-field',
+
+            'public-instance-readonly-field',
+            'protected-instance-readonly-field',
+            'private-instance-readonly-field',
+            '#private-instance-readonly-field',
+
+            'instance-readonly-field',
+
+            'public-readonly-field',
+            'protected-readonly-field',
+            'private-readonly-field',
+            '#private-readonly-field',
+
+            'readonly-field',
+
+            'public-abstract-readonly-field',
+            'protected-abstract-readonly-field',
+
+            'abstract-readonly-field',
+
+            'public-decorated-readonly-field',
+            'protected-decorated-readonly-field',
+            'private-decorated-readonly-field',
+            'decorated-readonly-field',
+          ],
         },
       ],
     },
     {
       code: `
 abstract class Foo {
-  @Dec public readonly A: string;
-  public readonly B: string;
-  public static readonly C: string;
-  static readonly #D: string;
-  readonly #E: string;
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
 
-  @Dec public F: string;
-  public G: string;
-  public static H: string;
-  static readonly #I: string;
-  readonly #J: string;
+  public static readonly SA: string;
+  protected static readonly SB: string;
+  private static readonly SC: string;
+  static readonly #SD: string;
+
+  public readonly IA: string;
+  protected readonly IB: string;
+  private readonly IC: string;
+  readonly #ID: string;
+
+  public abstract readonly AA: string;
+  protected abstract readonly AB: string;
 }
       `,
       options: [
         {
-          default: ['decorated-field', 'readonly-field', 'field'],
+          default: [
+            'decorated-readonly-field',
+            'static-readonly-field',
+            'instance-readonly-field',
+            'abstract-readonly-field',
+          ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'F',
-            rank: 'readonly field',
-          },
-          line: 9,
-          column: 3,
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          column: 3,
-        },
+    },
+    {
+      code: `
+abstract class Foo {
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
+
+  public static readonly SA: string;
+  public readonly IA: string;
+  public abstract readonly AA: string;
+
+  protected static readonly SB: string;
+  protected readonly IB: string;
+  protected abstract readonly AB: string;
+
+  private static readonly SC: string;
+  private readonly IC: string;
+
+  static readonly #SD: string;
+  readonly #ID: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          column: 3,
+          default: [
+            'decorated-readonly-field',
+            'public-readonly-field',
+            'protected-readonly-field',
+            'private-readonly-field',
+          ],
         },
       ],
     },
@@ -5071,14 +5013,15 @@ abstract class Foo {
   @Dec private readonly DC: string;
 
   public static readonly SA: string;
-  protected static readonly SB: string;
-  private static readonly SC: string;
+  public readonly IA: string;
   static readonly #SD: string;
+  readonly #ID: string;
 
-  public readonly IA: string;
+  protected static readonly SB: string;
   protected readonly IB: string;
+
+  private static readonly SC: string;
   private readonly IC: string;
-  readonly #ID: string;
 
   public abstract readonly AA: string;
   protected abstract readonly AB: string;
@@ -5088,30 +5031,38 @@ abstract class Foo {
         {
           default: [
             'decorated-readonly-field',
+            ['public-readonly-field', 'readonly-field'],
+            'protected-readonly-field',
+            'private-readonly-field',
             'abstract-readonly-field',
-            'static-readonly-field',
-            'instance-readonly-field',
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'AA',
-            rank: 'static readonly field',
-          },
-          line: 17,
-          column: 3,
-        },
+    },
+    {
+      code: `
+abstract class Foo {
+  @Dec public readonly A: string;
+  @Dec public B: string;
+
+  public readonly C: string;
+  public static readonly D: string;
+  public E: string;
+  public static F: string;
+
+  static readonly #G: string;
+  readonly #H: string;
+  static #I: string;
+  #J: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'AB',
-            rank: 'static readonly field',
-          },
-          line: 18,
-          column: 3,
+          default: [
+            ['decorated-field', 'decorated-readonly-field'],
+            ['field', 'readonly-field'],
+            ['#private-field', '#private-readonly-field'],
+          ],
         },
       ],
     },
@@ -5127,38 +5078,39 @@ interface Foo {
       `,
       options: [
         {
-          default: ['field', 'readonly-field'],
+          default: ['readonly-field', 'field'],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'C',
-            rank: 'readonly field',
-          },
-          line: 6,
-          column: 3,
-        },
+    },
+    {
+      code: `
+interface Foo {
+  readonly [i: string]: string;
+  readonly A: string;
+
+  [i: number]: string;
+  B: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'D',
-            rank: 'readonly field',
-          },
-          line: 7,
-          column: 3,
+          default: [
+            'readonly-signature',
+            'readonly-field',
+            'signature',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  [i: number]: string;
   readonly [i: string]: string;
+  [i: number]: string;
 
-  A: string;
-  readonly B: string;
+  readonly A: string;
+  B: string;
 }
       `,
       options: [
@@ -5171,73 +5123,121 @@ interface Foo {
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'i',
-            rank: 'signature',
-          },
-          line: 4,
-          column: 3,
-        },
+    },
+    {
+      code: `
+interface Foo {
+  readonly A: string;
+  B: string;
+
+  [i: number]: string;
+  readonly [i: string]: string;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'B',
-            rank: 'field',
-          },
-          line: 7,
-          column: 3,
+          default: ['readonly-field', 'field', 'signature'],
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6812
     {
       code: `
 class Foo {
-  accessor bar;
+  #bar: string;
 
-  baz() {}
+  get bar(): string {
+    return this.#bar;
+  }
+
+  set bar(value: string) {
+    this.#bar = value;
+  }
 }
       `,
       options: [
         {
-          default: ['method', 'accessor'],
+          default: {
+            memberTypes: [['get', 'set']],
+            order: 'alphabetically',
+          },
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+// no accessibility === public
+class Foo {
+  [A: string]: any;
+  [B: string]: any;
+  [a: string]: any;
+  [b: string]: any;
+  static C: boolean;
+  static d: boolean;
+  get E(): string {}
+  get e(): string {}
+  private ImPrivate() {}
+  private imPrivate() {}
+}
+      `,
+      name: 'default member types with alphabetically order',
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'baz',
-            rank: 'accessor',
+          default: {
+            order: 'alphabetically',
           },
-          line: 5,
-          column: 3,
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 interface Foo {
-  y(): void;
-  get x(): number;
+  A: string;
+  B: string;
+  [Z: string]: any;
+  c();
+  new ();
+  r();
+}
+      `,
+      name: 'alphabetically order without member types',
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+    {
+      code: `
+class Foo {
+  #bar: string;
+
+  get bar(): string {
+    return this.#bar;
+  }
+
+  set bar(value: string) {
+    this.#bar = value;
+  }
 }
       `,
       options: [
         {
-          default: ['get', 'method'],
+          default: {
+            memberTypes: [['get', 'set']],
+            order: 'natural',
+          },
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+class Foo {
+  accessor bar;
+
+  baz() {}
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'x',
-            rank: 'method',
-          },
-          line: 4,
-          column: 3,
+          default: ['accessor', 'method'],
         },
       ],
     },
@@ -5250,18 +5250,20 @@ interface Foo {
       `,
       options: [
         {
-          default: ['method', 'get'],
+          default: ['get', 'method'],
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+interface Foo {
+  y(): void;
+  get x(): number;
+}
+      `,
+      options: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'y',
-            rank: 'get',
-          },
-          line: 4,
-          column: 3,
+          default: ['method', 'get'],
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts
index d45c48ee389c..10758d743000 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts
@@ -1,12 +1,158 @@
 import type { RunTests } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../../src/rules/member-ordering';
+
 import rule, { defaultOrder } from '../../../src/rules/member-ordering';
 
 const ruleTester = new RuleTester();
 
 const sortedCiWithoutGrouping: RunTests<MessageIds, Options> = {
+  invalid: [
+    // default option + interface + wrong order (multiple)
+    {
+      code: `
+interface Foo {
+  c: string;
+  B: string;
+  a: string;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'c',
+            member: 'B',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically-case-insensitive',
+          },
+        },
+      ],
+    },
+
+    // default option + interface + lower/upper case wrong order
+    {
+      code: `
+interface Foo {
+  B: b;
+  a: b;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically-case-insensitive',
+          },
+        },
+      ],
+    },
+
+    // default option + type literal + lower/upper case wrong order
+    {
+      code: `
+type Foo = {
+  B: b;
+  a: b;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically-case-insensitive',
+          },
+        },
+      ],
+    },
+
+    // default option + class + lower/upper case wrong order
+    {
+      code: `
+class Foo {
+  public static B: string;
+  public static a: string;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically-case-insensitive',
+          },
+        },
+      ],
+    },
+
+    // default option + class expression + lower/upper case wrong order
+    {
+      code: `
+const foo = class Foo {
+  public static B: string;
+  public static a: string;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically-case-insensitive',
+          },
+        },
+      ],
+    },
+  ],
   valid: [
     // default option + interface + lower/upper case
     {
@@ -99,153 +245,220 @@ class Foo {
       ],
     },
   ],
+};
+
+const sortedCiWithGrouping: RunTests<MessageIds, Options> = {
   invalid: [
-    // default option + interface + wrong order (multiple)
+    // default option + interface + wrong order within group and wrong group order + alphabetically
     {
       code: `
 interface Foo {
-  c: string;
-  B: string;
-  a: string;
+  [a: string]: number;
+
+  a: x;
+  B: x;
+  c: x;
+
+  c(): void;
+  B(): void;
+  a(): void;
+
+  (): Baz;
+
+  new (): Bar;
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: 'never',
-            order: 'alphabetically-case-insensitive',
+          data: {
+            beforeMember: 'c',
+            member: 'B',
           },
+          messageId: 'incorrectOrder',
         },
-      ],
-      errors: [
         {
+          data: {
+            beforeMember: 'B',
+            member: 'a',
+          },
           messageId: 'incorrectOrder',
+        },
+        {
           data: {
-            member: 'B',
-            beforeMember: 'c',
+            name: 'call',
+            rank: 'field',
           },
+          messageId: 'incorrectGroupOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
-            beforeMember: 'B',
+            name: 'new',
+            rank: 'method',
           },
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-
-    // default option + interface + lower/upper case wrong order
-    {
-      code: `
-interface Foo {
-  B: b;
-  a: b;
-}
-      `,
       options: [
         {
           default: {
-            memberTypes: 'never',
+            memberTypes: defaultOrder,
             order: 'alphabetically-case-insensitive',
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'B',
-          },
-        },
-      ],
     },
 
-    // default option + type literal + lower/upper case wrong order
+    // default option + type literal + wrong order within group and wrong group order + alphabetically
     {
       code: `
 type Foo = {
-  B: b;
-  a: b;
+  [a: string]: number;
+
+  a: x;
+  B: x;
+  c: x;
+
+  c(): void;
+  B(): void;
+  a(): void;
+
+  (): Baz;
+
+  new (): Bar;
 };
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: 'never',
-            order: 'alphabetically-case-insensitive',
+          data: {
+            beforeMember: 'c',
+            member: 'B',
           },
+          messageId: 'incorrectOrder',
         },
-      ],
-      errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            name: 'call',
+            rank: 'field',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically-case-insensitive',
           },
         },
       ],
     },
 
-    // default option + class + lower/upper case wrong order
+    // default option + class + wrong order within group and wrong group order + alphabetically
     {
       code: `
 class Foo {
-  public static B: string;
+  public static c: string = '';
+  public static B: string = '';
   public static a: string;
+
+  constructor() {}
+
+  public d: string = '';
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: 'never',
-            order: 'alphabetically-case-insensitive',
+          data: {
+            beforeMember: 'c',
+            member: 'B',
           },
+          messageId: 'incorrectOrder',
         },
-      ],
-      errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically-case-insensitive',
           },
         },
       ],
     },
 
-    // default option + class expression + lower/upper case wrong order
+    // default option + class expression + wrong order within group and wrong group order + alphabetically
     {
       code: `
 const foo = class Foo {
-  public static B: string;
+  public static c: string = '';
+  public static B: string = '';
   public static a: string;
+
+  constructor() {}
+
+  public d: string = '';
 };
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: 'never',
-            order: 'alphabetically-case-insensitive',
+          data: {
+            beforeMember: 'c',
+            member: 'B',
           },
+          messageId: 'incorrectOrder',
         },
-      ],
-      errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'B',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically-case-insensitive',
           },
         },
       ],
     },
   ],
-};
-
-const sortedCiWithGrouping: RunTests<MessageIds, Options> = {
   valid: [
     // default option + interface + default order + alphabetically
     {
@@ -508,223 +721,12 @@ class Foo {
       ],
     },
   ],
-  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-case-insensitive',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'B',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'B',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'call',
-            rank: 'field',
-          },
-        },
-        {
-          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-case-insensitive',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'B',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'B',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'call',
-            rank: 'field',
-          },
-        },
-        {
-          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-case-insensitive',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'B',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'B',
-          },
-        },
-        {
-          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-case-insensitive',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'B',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'B',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'd',
-            rank: 'public constructor',
-          },
-        },
-      ],
-    },
-  ],
 };
 
 ruleTester.run('member-ordering-alphabetically-case-insensitive-order', rule, {
-  valid: [...sortedCiWithoutGrouping.valid, ...sortedCiWithGrouping.valid],
   invalid: [
     ...sortedCiWithoutGrouping.invalid,
     ...sortedCiWithGrouping.invalid,
   ],
+  valid: [...sortedCiWithoutGrouping.valid, ...sortedCiWithGrouping.valid],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-order.test.ts b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-order.test.ts
index 1cd4d98089db..87fa9315469d 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-order.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-alphabetically-order.test.ts
@@ -1,11 +1,292 @@
 import type { RunTests } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../../src/rules/member-ordering';
+
 import rule, { defaultOrder } from '../../../src/rules/member-ordering';
 
 const ruleTester = new RuleTester();
 const sortedWithoutGroupingDefaultOption: RunTests<MessageIds, Options> = {
+  invalid: [
+    // default option + interface + wrong order
+    {
+      code: `
+interface Foo {
+  b(): void;
+  a: b;
+  [a: string]: number;
+  new (): Bar;
+  (): Baz;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'new',
+            member: 'call',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + interface + literal properties
+    {
+      code: `
+interface Foo {
+  'b.d': Foo;
+  'b.c': Foo;
+  a: Foo;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b.d',
+            member: 'b.c',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b.c',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { order: 'alphabetically' } }],
+    },
+
+    // default option + interface + wrong order (multiple)
+    {
+      code: `
+interface Foo {
+  c: string;
+  b: string;
+  a: string;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'c',
+            member: 'b',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + type literal + wrong order
+    {
+      code: `
+type Foo = {
+  b(): void;
+  a: b;
+  [a: string]: number;
+  new (): Bar;
+  (): Baz;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'new',
+            member: 'call',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + type + literal properties
+    {
+      code: `
+type Foo = {
+  'b.d': Foo;
+  'b.c': Foo;
+  a: Foo;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b.d',
+            member: 'b.c',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b.c',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { order: 'alphabetically' } }],
+    },
+
+    // default option + type literal + wrong order (multiple)
+    {
+      code: `
+type Foo = {
+  c: string;
+  b: string;
+  a: string;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'c',
+            member: 'b',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // 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 = '';
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class + wrong order (multiple)
+    {
+      code: `
+class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'c',
+            member: 'b',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // 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 = '';
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class expression + wrong order (multiple)
+    {
+      code: `
+const foo = class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+};
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'c',
+            member: 'b',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+  ],
   valid: [
     // default option + interface + multiple types
     {
@@ -145,298 +426,76 @@ class Foo {
 
     // 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' } }],
-    },
-
-    // default option + class + decorators
-    {
-      code: `
-class Foo {
-  public static a: string;
-  @Dec() static b: string;
-  public static c: string;
-}
-      `,
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
-    },
-
-    // default option + private identifiers
-    {
-      code: `
-class Foo {
-  #a = 1;
-  #b = 2;
-  #c = 3;
-}
-      `,
-      options: [
-        { default: { memberTypes: defaultOrder, 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',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'call',
-            beforeMember: 'new',
-          },
-        },
-      ],
-    },
-
-    // default option + interface + literal properties
-    {
-      code: `
-interface Foo {
-  'b.d': Foo;
-  'b.c': Foo;
-  a: Foo;
-}
-      `,
-      options: [{ default: { order: 'alphabetically' } }],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'b.c',
-            beforeMember: 'b.d',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'b.c',
-          },
-        },
-      ],
-    },
-
-    // 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',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'call',
-            beforeMember: 'new',
-          },
-        },
-      ],
+      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 + type + literal properties
+    // default option + class expression + lower/upper case
     {
       code: `
-type Foo = {
-  'b.d': Foo;
-  'b.c': Foo;
-  a: Foo;
+const foo = class Foo {
+  public static A: string;
+  public static a: string;
 };
       `,
-      options: [{ default: { order: 'alphabetically' } }],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'b.c',
-            beforeMember: 'b.d',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'b.c',
-          },
-        },
-      ],
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
     },
 
-    // default option + type literal + wrong order (multiple)
+    // default option + class expression + numbers
     {
       code: `
-type Foo = {
-  c: string;
-  b: string;
-  a: string;
+const foo = class Foo {
+  public static a1: string;
+  public static aa: 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
+    // default option + class + decorators
     {
       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 = '';
+  @Dec() static b: string;
+  public static c: string;
 }
       `,
       options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'b',
-          },
-        },
-      ],
     },
 
-    // default option + class + wrong order (multiple)
+    // default option + private identifiers
     {
       code: `
 class Foo {
-  public static c: string;
-  public static b: string;
-  public static a: string;
+  #a = 1;
+  #b = 2;
+  #c = 3;
 }
       `,
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'b',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'b',
-          },
-        },
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
       ],
     },
+  ],
+};
 
-    // default option + class expression + wrong order
+const sortedWithoutGroupingClassesOption: RunTests<MessageIds, Options> = {
+  invalid: [
+    // classes option + class + wrong order
     {
       code: `
-const foo = class Foo {
+class Foo {
   protected static b: string = '';
   public static a: string;
   private static c: string = '';
@@ -444,51 +503,48 @@ const foo = class Foo {
   public d: string = '';
   protected e: string = '';
   private f: string = '';
-};
+}
       `,
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
     },
 
-    // default option + class expression + wrong order (multiple)
+    // classes option + class + wrong order (multiple)
     {
       code: `
-const foo = class 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',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
     },
   ],
-};
-
-const sortedWithoutGroupingClassesOption: RunTests<MessageIds, Options> = {
   valid: [
     // classes option + interface + multiple types --> Only member group order is checked (default config)
     {
@@ -639,11 +695,17 @@ const foo = class Foo {
       options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
     },
   ],
+};
+
+const sortedWithoutGroupingClassExpressionsOption: RunTests<
+  MessageIds,
+  Options
+> = {
   invalid: [
-    // classes option + class + wrong order
+    // classExpressions option + class expression + wrong order
     {
       code: `
-class Foo {
+const foo = class Foo {
   protected static b: string = '';
   public static a: string;
   private static c: string = '';
@@ -651,54 +713,52 @@ class Foo {
   public d: string = '';
   protected e: string = '';
   private f: string = '';
-}
+};
       `,
-      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
 
-    // classes option + class + wrong order (multiple)
+    // classExpressions option + class expression + wrong order (multiple)
     {
       code: `
-class Foo {
+const foo = 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',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
   ],
-};
-
-const sortedWithoutGroupingClassExpressionsOption: RunTests<
-  MessageIds,
-  Options
-> = {
   valid: [
     // classExpressions option + interface + multiple types --> Only member group order is checked (default config)
     {
@@ -872,67 +932,72 @@ const foo = class Foo {
       ],
     },
   ],
+};
+
+const sortedWithoutGroupingInterfacesOption: RunTests<MessageIds, Options> = {
   invalid: [
-    // classExpressions option + class expression + wrong order
+    // interfaces option + interface + 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 = '';
-};
+interface Foo {
+  b(): void;
+  a: b;
+  [a: string]: number;
+  new (): Bar;
+  (): Baz;
+}
       `,
-      options: [
-        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            beforeMember: 'new',
+            member: 'call',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
 
-    // classExpressions option + class expression + wrong order (multiple)
+    // interfaces option + interface + wrong order (multiple)
     {
       code: `
-const foo = class Foo {
-  public static c: string;
-  public static b: string;
-  public static a: string;
-};
+interface Foo {
+  c: string;
+  b: string;
+  a: string;
+}
       `,
-      options: [
-        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
-  ],
-};
-
-const sortedWithoutGroupingInterfacesOption: RunTests<MessageIds, Options> = {
+  ],
   valid: [
     // interfaces option + interface + multiple types
     {
@@ -1106,72 +1171,72 @@ const foo = class Foo {
       ],
     },
   ],
+};
+
+const sortedWithoutGroupingTypeLiteralsOption: RunTests<MessageIds, Options> = {
   invalid: [
-    // interfaces option + interface + wrong order
+    // typeLiterals option + type literal + wrong order
     {
       code: `
-interface Foo {
+type 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',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'call',
             beforeMember: 'new',
+            member: 'call',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
 
-    // interfaces option + interface + wrong order (multiple)
+    // typeLiterals option + type literal + wrong order (multiple)
     {
       code: `
-interface Foo {
+type Foo = {
   c: string;
   b: string;
   a: string;
-}
+};
       `,
-      options: [
-        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
     },
   ],
-};
-
-const sortedWithoutGroupingTypeLiteralsOption: RunTests<MessageIds, Options> = {
   valid: [
     // typeLiterals option + interface + multiple types --> Only member group order is checked (default config)
     {
@@ -1345,72 +1410,230 @@ const foo = class Foo {
       ],
     },
   ],
+};
+
+const sortedWithGroupingDefaultOption: RunTests<MessageIds, Options> = {
   invalid: [
-    // typeLiterals option + type literal + wrong order
+    // default option + class + wrong order within group and wrong group order + alphabetically
     {
       code: `
-type Foo = {
-  b(): void;
-  a: b;
-  [a: string]: number;
-  new (): Bar;
-  (): Baz;
-};
+class FooTestGetter {
+  public static a: string;
+  protected static b: string = '';
+  private static c: string = '';
+
+  public d: string = '';
+  protected e: string = '';
+  private f: string = '';
+
+  get h() {}
+
+  set g() {}
+
+  constructor() {}
+}
       `,
+      errors: [
+        {
+          data: {
+            name: 'constructor',
+            rank: 'public instance get',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
-        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+        {
+          default: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically',
+          },
+        },
       ],
+    },
+
+    // default option + class + custom + alphabetically
+    {
+      code: `
+class Foo {
+  @Bar
+  get a() {}
+
+  get b() {}
+
+  @Bar
+  set c() {}
+
+  set d() {}
+}
+      `,
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
-            beforeMember: 'b',
+            name: 'b',
+            rank: 'decorated get',
           },
+          messageId: 'incorrectGroupOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'call',
-            beforeMember: 'new',
+            name: 'd',
+            rank: 'decorated set',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: ['get', 'decorated-get', 'set', 'decorated-set'],
+            order: 'alphabetically',
           },
         },
       ],
     },
 
-    // typeLiterals option + type literal + wrong order (multiple)
+    // default option + class + wrong order within group and wrong group order + alphabetically
     {
       code: `
-type Foo = {
-  c: string;
-  b: string;
-  a: string;
-};
+class FooTestGetter {
+  public static a: string;
+  protected static b: string = '';
+  private static c: string = '';
+
+  public d: string = '';
+  protected e: string = '';
+  private f: string = '';
+
+  set g() {}
+
+  constructor() {}
+
+  get h() {}
+}
       `,
+      errors: [
+        {
+          data: {
+            name: 'constructor',
+            rank: 'public instance set',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          data: {
+            name: 'h',
+            rank: 'public instance set',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
-        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+        {
+          default: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically',
+          },
+        },
       ],
+    },
+    // 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 = '';
+};
+      `,
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+    // default option + class + decorators + custom order + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+class Foo {
+  @Dec() a1: string;
+  @Dec()
+  a3: string;
+  @Dec()
+  a2: string;
+
+  constructor() {}
+
+  b1: string;
+  b2: string;
+
+  public c(): void;
+  @Dec() d(): void {}
+}
+      `,
+      errors: [
+        {
+          data: {
+            beforeMember: 'a3',
+            member: 'a2',
+          },
+          messageId: 'incorrectOrder',
+        },
+        {
+          data: {
+            name: 'b1',
+            rank: 'constructor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          data: {
+            name: 'b2',
+            rank: 'constructor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: [
+              'decorated-field',
+              'field',
+              'constructor',
+              'decorated-method',
+            ],
+            order: 'alphabetically',
           },
         },
       ],
     },
   ],
-};
-
-const sortedWithGroupingDefaultOption: RunTests<MessageIds, Options> = {
   valid: [
     // default option + interface + default order + alphabetically
     {
@@ -1703,134 +1926,14 @@ class Foo {
       ],
     },
   ],
+};
+
+const sortedWithGroupingClassesOption: RunTests<MessageIds, Options> = {
   invalid: [
     // default option + class + wrong order within group and wrong group order + alphabetically
     {
       code: `
-class FooTestGetter {
-  public static a: string;
-  protected static b: string = '';
-  private static c: string = '';
-
-  public d: string = '';
-  protected e: string = '';
-  private f: string = '';
-
-  get h() {}
-
-  set g() {}
-
-  constructor() {}
-}
-      `,
-      options: [
-        {
-          default: {
-            memberTypes: defaultOrder,
-            order: 'alphabetically',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public instance get',
-          },
-        },
-      ],
-    },
-
-    // default option + class + custom + alphabetically
-    {
-      code: `
 class Foo {
-  @Bar
-  get a() {}
-
-  get b() {}
-
-  @Bar
-  set c() {}
-
-  set d() {}
-}
-      `,
-      options: [
-        {
-          default: {
-            memberTypes: ['get', 'decorated-get', 'set', 'decorated-set'],
-            order: 'alphabetically',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'b',
-            rank: 'decorated get',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'd',
-            rank: 'decorated set',
-          },
-        },
-      ],
-    },
-
-    // default option + class + wrong order within group and wrong group order + alphabetically
-    {
-      code: `
-class FooTestGetter {
-  public static a: string;
-  protected static b: string = '';
-  private static c: string = '';
-
-  public d: string = '';
-  protected e: string = '';
-  private f: string = '';
-
-  set g() {}
-
-  constructor() {}
-
-  get h() {}
-}
-      `,
-      options: [
-        {
-          default: {
-            memberTypes: defaultOrder,
-            order: 'alphabetically',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'constructor',
-            rank: 'public instance set',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'h',
-            rank: 'public instance set',
-          },
-        },
-      ],
-    },
-    // 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;
@@ -1838,95 +1941,36 @@ const foo = class Foo {
   constructor() {}
 
   public d: string = '';
-};
+}
       `,
-      options: [
-        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectGroupOrder',
           data: {
             name: 'd',
             rank: 'public constructor',
           },
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    // default option + class + decorators + custom order + wrong order within group and wrong group order + alphabetically
-    {
-      code: `
-class Foo {
-  @Dec() a1: string;
-  @Dec()
-  a3: string;
-  @Dec()
-  a2: string;
-
-  constructor() {}
-
-  b1: string;
-  b2: string;
-
-  public c(): void;
-  @Dec() d(): void {}
-}
-      `,
       options: [
-        {
-          default: {
-            memberTypes: [
-              'decorated-field',
-              'field',
-              'constructor',
-              'decorated-method',
-            ],
-            order: 'alphabetically',
-          },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a2',
-            beforeMember: 'a3',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'b1',
-            rank: 'constructor',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'b2',
-            rank: 'constructor',
-          },
-        },
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
       ],
     },
   ],
-};
-
-const sortedWithGroupingClassesOption: RunTests<MessageIds, Options> = {
   valid: [
     // classes option + interface + alphabetically --> Default order applies
     {
@@ -2025,62 +2069,62 @@ const foo = class Foo {
   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: 'incorrectOrder',
-          data: {
-            member: 'b',
-            beforeMember: 'c',
-          },
-        },
-        {
-          messageId: 'incorrectOrder',
-          data: {
-            member: 'a',
-            beforeMember: 'b',
-          },
-        },
-        {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'd',
-            rank: 'public constructor',
-          },
-        },
-      ],
+  public d: string = '';
+  protected e: string = '';
+  private f: string = '';
+
+  constructor() {}
+};
+      `,
+      options: [{ classes: { order: 'alphabetically' } }],
     },
   ],
 };
 
 const sortedWithGroupingClassExpressionsOption: RunTests<MessageIds, Options> =
   {
+    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 = '';
+};
+        `,
+        errors: [
+          {
+            data: {
+              beforeMember: 'c',
+              member: 'b',
+            },
+            messageId: 'incorrectOrder',
+          },
+          {
+            data: {
+              beforeMember: 'b',
+              member: 'a',
+            },
+            messageId: 'incorrectOrder',
+          },
+          {
+            data: {
+              name: 'd',
+              rank: 'public constructor',
+            },
+            messageId: 'incorrectGroupOrder',
+          },
+        ],
+        options: [
+          { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+        ],
+      },
+    ],
     valid: [
       // classExpressions option + interface + alphabetically --> Default order applies
       {
@@ -2194,167 +2238,9 @@ const foo = class Foo {
         ],
       },
     ],
-    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: 'incorrectOrder',
-            data: {
-              member: 'b',
-              beforeMember: 'c',
-            },
-          },
-          {
-            messageId: 'incorrectOrder',
-            data: {
-              member: 'a',
-              beforeMember: 'b',
-            },
-          },
-          {
-            messageId: 'incorrectGroupOrder',
-            data: {
-              name: 'd',
-              rank: 'public constructor',
-            },
-          },
-        ],
-      },
-    ],
   };
 
 const sortedWithGroupingInterfacesOption: 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;
-
-  (): Baz;
-
-  c: x;
-  b: x;
-  a: x;
-
-  new (): Bar;
-
-  c(): void;
-  b(): void;
-  a(): void;
-};
-      `,
-      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
     {
@@ -2375,73 +2261,48 @@ interface Foo {
   new (): Bar;
 }
       `,
-      options: [
-        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectGroupOrder',
           data: {
             name: 'call',
             rank: 'field',
           },
+          messageId: 'incorrectGroupOrder',
         },
         {
-          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'method',
           },
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
     },
   ],
-};
-
-const sortedWithGroupingTypeLiteralsOption: RunTests<MessageIds, Options> = {
   valid: [
-    // typeLiterals option + interface + alphabetically --> Default order applies
+    // interfaces option + interface + default order + alphabetically
     {
       code: `
 interface Foo {
   [a: string]: number;
 
-  (): Baz;
-
-  c: x;
-  b: x;
-  a: x;
-
-  new (): Bar;
-
-  c(): void;
-  b(): void;
-  a(): void;
-}
-      `,
-      options: [{ typeLiterals: { order: 'alphabetically' } }],
-    },
-
-    // typeLiterals option + type literal + default order + alphabetically
-    {
-      code: `
-type Foo = {
-  [a: string]: number;
-
   a: x;
   b: x;
   c: x;
@@ -2453,11 +2314,11 @@ type Foo = {
   new (): Bar;
 
   (): Baz;
-};
+}
       `,
       options: [
         {
-          typeLiterals: {
+          interfaces: {
             memberTypes: ['signature', 'field', 'method', 'constructor'],
             order: 'alphabetically',
           },
@@ -2465,10 +2326,10 @@ type Foo = {
       ],
     },
 
-    // typeLiterals option + type literal + custom order + alphabetically
+    // interfaces option + interface + custom order + alphabetically
     {
       code: `
-type Foo = {
+interface Foo {
   new (): Bar;
 
   a(): void;
@@ -2481,11 +2342,11 @@ type Foo = {
 
   [a: string]: number;
   (): Baz;
-};
+}
       `,
       options: [
         {
-          typeLiterals: {
+          interfaces: {
             memberTypes: ['constructor', 'method', 'field'],
             order: 'alphabetically',
           },
@@ -2493,7 +2354,29 @@ type Foo = {
       ],
     },
 
-    // typeLiterals option + class + alphabetically --> Default order applies
+    // interfaces option + type literal + alphabetically --> Default order applies
+    {
+      code: `
+type Foo = {
+  [a: string]: number;
+
+  (): Baz;
+
+  c: x;
+  b: x;
+  a: x;
+
+  new (): Bar;
+
+  c(): void;
+  b(): void;
+  a(): void;
+};
+      `,
+      options: [{ interfaces: { order: 'alphabetically' } }],
+    },
+
+    // interfaces option + class + alphabetically --> Default order applies
     {
       code: `
 class Foo {
@@ -2508,10 +2391,10 @@ class Foo {
   constructor() {}
 }
       `,
-      options: [{ typeLiterals: { order: 'alphabetically' } }],
+      options: [{ interfaces: { order: 'alphabetically' } }],
     },
 
-    // typeLiterals option + class expression + alphabetically --> Default order applies
+    // interfaces option + class expression + alphabetically --> Default order applies
     {
       code: `
 const foo = class Foo {
@@ -2526,9 +2409,12 @@ const foo = class Foo {
   constructor() {}
 };
       `,
-      options: [{ typeLiterals: { order: 'alphabetically' } }],
+      options: [{ interfaces: { order: 'alphabetically' } }],
     },
   ],
+};
+
+const sortedWithGroupingTypeLiteralsOption: RunTests<MessageIds, Options> = {
   invalid: [
     // default option + type literal + wrong order within group and wrong group order + alphabetically
     {
@@ -2549,39 +2435,39 @@ type Foo = {
   new (): Bar;
 };
       `,
-      options: [
-        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'b',
             beforeMember: 'c',
+            member: 'b',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectGroupOrder',
           data: {
             name: 'call',
             rank: 'field',
           },
+          messageId: 'incorrectGroupOrder',
         },
         {
-          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'method',
           },
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
     },
 
     // default option + private identifiers
@@ -2593,21 +2479,21 @@ class Foo {
   #a = 1;
 }
       `,
-      options: [
-        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
     },
     // default option + accessors
     {
@@ -2623,32 +2509,32 @@ class Foo {
   abstract accessor e;
 }
       `,
-      options: [
-        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
-      ],
       errors: [
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'c',
             beforeMember: 'd',
+            member: 'c',
           },
+          messageId: 'incorrectOrder',
         },
         {
-          messageId: 'incorrectOrder',
           data: {
-            member: 'e',
             beforeMember: 'f',
+            member: 'e',
           },
+          messageId: 'incorrectOrder',
         },
       ],
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
     },
     // accessors with wrong group order
     {
@@ -2660,6 +2546,22 @@ class Foo {
   @Dec() accessor d;
 }
       `,
+      errors: [
+        {
+          data: {
+            name: 'c',
+            rank: 'abstract accessor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          data: {
+            name: 'd',
+            rank: 'accessor',
+          },
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: {
@@ -2672,34 +2574,127 @@ class Foo {
           },
         },
       ],
-      errors: [
+    },
+  ],
+  valid: [
+    // typeLiterals option + interface + alphabetically --> Default order applies
+    {
+      code: `
+interface Foo {
+  [a: string]: number;
+
+  (): Baz;
+
+  c: x;
+  b: x;
+  a: x;
+
+  new (): Bar;
+
+  c(): void;
+  b(): void;
+  a(): void;
+}
+      `,
+      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: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'c',
-            rank: 'abstract accessor',
+          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: [
         {
-          messageId: 'incorrectGroupOrder',
-          data: {
-            name: 'd',
-            rank: 'accessor',
+          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' } }],
+    },
   ],
 };
 
 const sortedWithoutGrouping: RunTests<MessageIds, Options> = {
-  valid: [
-    ...sortedWithoutGroupingDefaultOption.valid,
-    ...sortedWithoutGroupingClassesOption.valid,
-    ...sortedWithoutGroupingClassExpressionsOption.valid,
-    ...sortedWithoutGroupingInterfacesOption.valid,
-    ...sortedWithoutGroupingTypeLiteralsOption.valid,
-  ],
   invalid: [
     ...sortedWithoutGroupingDefaultOption.invalid,
     ...sortedWithoutGroupingClassesOption.invalid,
@@ -2707,16 +2702,16 @@ const sortedWithoutGrouping: RunTests<MessageIds, Options> = {
     ...sortedWithoutGroupingInterfacesOption.invalid,
     ...sortedWithoutGroupingTypeLiteralsOption.invalid,
   ],
+  valid: [
+    ...sortedWithoutGroupingDefaultOption.valid,
+    ...sortedWithoutGroupingClassesOption.valid,
+    ...sortedWithoutGroupingClassExpressionsOption.valid,
+    ...sortedWithoutGroupingInterfacesOption.valid,
+    ...sortedWithoutGroupingTypeLiteralsOption.valid,
+  ],
 };
 
 const sortedWithGrouping: RunTests<MessageIds, Options> = {
-  valid: [
-    ...sortedWithGroupingDefaultOption.valid,
-    ...sortedWithGroupingClassesOption.valid,
-    ...sortedWithGroupingClassExpressionsOption.valid,
-    ...sortedWithGroupingInterfacesOption.valid,
-    ...sortedWithGroupingTypeLiteralsOption.valid,
-  ],
   invalid: [
     ...sortedWithGroupingDefaultOption.invalid,
     ...sortedWithGroupingClassesOption.invalid,
@@ -2724,9 +2719,16 @@ const sortedWithGrouping: RunTests<MessageIds, Options> = {
     ...sortedWithGroupingInterfacesOption.invalid,
     ...sortedWithGroupingTypeLiteralsOption.invalid,
   ],
+  valid: [
+    ...sortedWithGroupingDefaultOption.valid,
+    ...sortedWithGroupingClassesOption.valid,
+    ...sortedWithGroupingClassExpressionsOption.valid,
+    ...sortedWithGroupingInterfacesOption.valid,
+    ...sortedWithGroupingTypeLiteralsOption.valid,
+  ],
 };
 
 ruleTester.run('member-ordering-alphabetically-order', rule, {
-  valid: [...sortedWithoutGrouping.valid, ...sortedWithGrouping.valid],
   invalid: [...sortedWithoutGrouping.invalid, ...sortedWithGrouping.invalid],
+  valid: [...sortedWithoutGrouping.valid, ...sortedWithGrouping.valid],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts
index 299f91d05427..93bbf2b5e3e3 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts
@@ -5,53 +5,6 @@ import rule from '../../../src/rules/member-ordering';
 const ruleTester = new RuleTester();
 
 ruleTester.run('member-ordering-natural-order', rule, {
-  valid: [
-    {
-      code: `
-interface Example {
-  1: number;
-  5: number;
-  10: number;
-}
-      `,
-      options: [
-        {
-          default: {
-            order: 'natural-case-insensitive',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-interface Example {
-  new (): unknown;
-
-  a1(): void;
-  a5(): void;
-  a10(): void;
-  B1(): void;
-  B5(): void;
-  B10(): void;
-
-  a1: number;
-  a5: number;
-  a10: number;
-  B1: number;
-  B5: number;
-  B10: number;
-}
-      `,
-      options: [
-        {
-          default: {
-            memberTypes: ['constructor', 'method', 'field'],
-            order: 'natural-case-insensitive',
-          },
-        },
-      ],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -63,13 +16,13 @@ interface Example {
       `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          column: 3,
           data: {
             beforeMember: 10,
             member: 5,
           },
           line: 5,
-          column: 3,
+          messageId: 'incorrectOrder',
         },
       ],
       options: [
@@ -140,4 +93,51 @@ interface Example {
       ],
     },
   ],
+  valid: [
+    {
+      code: `
+interface Example {
+  1: number;
+  5: number;
+  10: number;
+}
+      `,
+      options: [
+        {
+          default: {
+            order: 'natural-case-insensitive',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface Example {
+  new (): unknown;
+
+  a1(): void;
+  a5(): void;
+  a10(): void;
+  B1(): void;
+  B5(): void;
+  B10(): void;
+
+  a1: number;
+  a5: number;
+  a10: number;
+  B1: number;
+  B5: number;
+  B10: number;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'natural-case-insensitive',
+          },
+        },
+      ],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-order.test.ts b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-order.test.ts
index af47b390e7e2..24d0bc0ece48 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-order.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-natural-order.test.ts
@@ -5,53 +5,6 @@ import rule from '../../../src/rules/member-ordering';
 const ruleTester = new RuleTester();
 
 ruleTester.run('member-ordering-natural-order', rule, {
-  valid: [
-    {
-      code: `
-interface Example {
-  1: number;
-  5: number;
-  10: number;
-}
-      `,
-      options: [
-        {
-          default: {
-            order: 'natural',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-interface Example {
-  new (): unknown;
-
-  B1(): void;
-  B5(): void;
-  B10(): void;
-  a1(): void;
-  a5(): void;
-  a10(): void;
-
-  B1: number;
-  B5: number;
-  B10: number;
-  a1: number;
-  a5: number;
-  a10: number;
-}
-      `,
-      options: [
-        {
-          default: {
-            memberTypes: ['constructor', 'method', 'field'],
-            order: 'natural',
-          },
-        },
-      ],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -63,13 +16,13 @@ interface Example {
       `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          column: 3,
           data: {
             beforeMember: 10,
             member: 5,
           },
           line: 5,
-          column: 3,
+          messageId: 'incorrectOrder',
         },
       ],
       options: [
@@ -158,4 +111,51 @@ interface Example {
       ],
     },
   ],
+  valid: [
+    {
+      code: `
+interface Example {
+  1: number;
+  5: number;
+  10: number;
+}
+      `,
+      options: [
+        {
+          default: {
+            order: 'natural',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface Example {
+  new (): unknown;
+
+  B1(): void;
+  B5(): void;
+  B10(): void;
+  a1(): void;
+  a5(): void;
+  a10(): void;
+
+  B1: number;
+  B5: number;
+  B10: number;
+  a1: number;
+  a5: number;
+  a10: number;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'natural',
+          },
+        },
+      ],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-optionalMembers.test.ts b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-optionalMembers.test.ts
index 16971f118760..f7a6d47e80ad 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-optionalMembers.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering/member-ordering-optionalMembers.test.ts
@@ -1,7 +1,9 @@
 import type { RunTests } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../../src/rules/member-ordering';
+
 import rule from '../../../src/rules/member-ordering';
 
 const ruleTester = new RuleTester();
@@ -21,8 +23,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -39,8 +41,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'as-written',
             optionalityOrder: 'required-first',
+            order: 'as-written',
           },
         },
       ],
@@ -57,8 +59,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'as-written',
             optionalityOrder: 'required-first',
+            order: 'as-written',
           },
         },
       ],
@@ -75,8 +77,8 @@ class X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -93,8 +95,8 @@ class X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -111,8 +113,8 @@ class X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -129,8 +131,8 @@ class X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -147,8 +149,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -166,8 +168,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'required-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -185,8 +187,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'optional-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -203,8 +205,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'as-written',
             optionalityOrder: 'optional-first',
+            order: 'as-written',
           },
         },
       ],
@@ -221,8 +223,8 @@ interface X {
         {
           default: {
             memberTypes: 'never',
-            order: 'as-written',
             optionalityOrder: 'optional-first',
+            order: 'as-written',
           },
         },
       ],
@@ -239,8 +241,8 @@ class X {
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'optional-first',
+            order: 'alphabetically',
           },
         },
       ],
@@ -256,24 +258,24 @@ interface X {
   b?: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: 'never',
-            order: 'alphabetically',
-            optionalityOrder: 'required-first',
-          },
-        },
-      ],
       errors: [
         {
+          column: 3,
           data: {
-            member: 'b',
             beforeMember: 'd',
+            member: 'b',
           },
-          messageId: 'incorrectOrder',
           line: 5,
-          column: 3,
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            optionalityOrder: 'required-first',
+            order: 'alphabetically',
+          },
         },
       ],
     },
@@ -285,24 +287,24 @@ interface X {
   c: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: ['call-signature', 'field', 'method'],
-            order: 'as-written',
-            optionalityOrder: 'required-first',
-          },
-        },
-      ],
       errors: [
         {
-          messageId: 'incorrectRequiredMembersOrder',
-          line: 4,
           column: 3,
           data: {
             member: 'b',
             optionalOrRequired: 'required',
           },
+          line: 4,
+          messageId: 'incorrectRequiredMembersOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: ['call-signature', 'field', 'method'],
+            optionalityOrder: 'required-first',
+            order: 'as-written',
+          },
         },
       ],
     },
@@ -314,53 +316,53 @@ class X {
   b?: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: 'never',
-            order: 'as-written',
-            optionalityOrder: 'required-first',
-          },
-        },
-      ],
       errors: [
         {
-          messageId: 'incorrectRequiredMembersOrder',
-          line: 3,
           column: 3,
           data: {
             member: 'a',
             optionalOrRequired: 'required',
           },
+          line: 3,
+          messageId: 'incorrectRequiredMembersOrder',
         },
       ],
-    },
-    {
-      code: `
-class X {
-  b: string;
-  a: string;
-}
-      `,
       options: [
         {
           default: {
             memberTypes: 'never',
-            order: 'natural-case-insensitive',
             optionalityOrder: 'required-first',
+            order: 'as-written',
           },
         },
       ],
+    },
+    {
+      code: `
+class X {
+  b: string;
+  a: string;
+}
+      `,
       errors: [
         {
-          messageId: 'incorrectOrder',
-          line: 4,
           column: 3,
           data: {
-            member: 'a',
             beforeMember: 'b',
+            member: 'a',
             optionalOrRequired: 'required',
           },
+          line: 4,
+          messageId: 'incorrectOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            optionalityOrder: 'required-first',
+            order: 'natural-case-insensitive',
+          },
         },
       ],
     },
@@ -373,22 +375,22 @@ interface X {
   m: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          line: 4,
+          messageId: 'incorrectOrder',
+        },
+      ],
       options: [
         {
           default: {
             memberTypes: 'never',
-            order: 'alphabetically',
             optionalityOrder: 'optional-first',
+            order: 'alphabetically',
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'incorrectOrder',
-          line: 4,
-          column: 3,
-        },
-      ],
     },
     {
       code: `
@@ -398,24 +400,24 @@ interface X {
   c?: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: ['call-signature', 'field', 'method'],
-            order: 'as-written',
-            optionalityOrder: 'optional-first',
-          },
-        },
-      ],
       errors: [
         {
-          messageId: 'incorrectRequiredMembersOrder',
-          line: 4,
           column: 3,
           data: {
             member: 'b',
             optionalOrRequired: 'optional',
           },
+          line: 4,
+          messageId: 'incorrectRequiredMembersOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: ['call-signature', 'field', 'method'],
+            optionalityOrder: 'optional-first',
+            order: 'as-written',
+          },
         },
       ],
     },
@@ -431,24 +433,24 @@ class Test {
   h: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: 'never',
-            order: 'as-written',
-            optionalityOrder: 'optional-first',
-          },
-        },
-      ],
       errors: [
         {
-          messageId: 'incorrectRequiredMembersOrder',
-          line: 5,
           column: 3,
           data: {
             member: 'f',
             optionalOrRequired: 'optional',
           },
+          line: 5,
+          messageId: 'incorrectRequiredMembersOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            optionalityOrder: 'optional-first',
+            order: 'as-written',
+          },
         },
       ],
     },
@@ -462,24 +464,24 @@ class Test {
   d?: string;
 }
       `,
-      options: [
-        {
-          default: {
-            memberTypes: 'never',
-            order: 'as-written',
-            optionalityOrder: 'optional-first',
-          },
-        },
-      ],
       errors: [
         {
-          messageId: 'incorrectRequiredMembersOrder',
-          line: 3,
           column: 3,
           data: {
             member: 'a',
             optionalOrRequired: 'optional',
           },
+          line: 3,
+          messageId: 'incorrectRequiredMembersOrder',
+        },
+      ],
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            optionalityOrder: 'optional-first',
+            order: 'as-written',
+          },
         },
       ],
     },
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 626d6801d696..23b8b0e77b46 100644
--- a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
@@ -5,135 +5,6 @@ import rule from '../../src/rules/method-signature-style';
 const ruleTester = new RuleTester();
 
 ruleTester.run('method-signature-style', rule, {
-  valid: [
-    `
-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;
-}
-    `,
-    `
-interface Test {
-  get f(): number;
-}
-    `,
-    `
-interface Test {
-  set f(value: number): 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 };",
-    'type Test = { get f(): number };',
-    'type Test = { set f(value: number): void };',
-    {
-      options: ['method'],
-      code: `
-        interface Test {
-          f(a: string): number;
-        }
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        interface Test {
-          ['f'](a: boolean): void;
-        }
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        interface Test {
-          f<T>(a: T): T;
-        }
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        interface Test {
-          ['f']<T extends {}>(a: T, b: T): T;
-        }
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        interface Test {
-          'f!'</* a */>(/* b */ x: any /* c */): void;
-        }
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        type Test = { f(a: string): number };
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        type Test = { ['f']?(a: boolean): void };
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        type Test = { f?<T>(a?: T): T };
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        type Test = { ['f']?<T>(a: T, b: T): T };
-      `,
-    },
-    `
-      interface Test {
-        get f(): number;
-      }
-    `,
-    `
-      interface Test {
-        set f(value: number): void;
-      }
-    `,
-    {
-      options: ['method'],
-      code: `
-        type Test = { get f(): number };
-      `,
-    },
-    {
-      options: ['method'],
-      code: `
-        type Test = { set f(value: number): void };
-      `,
-    },
-  ],
   invalid: [
     {
       code: `
@@ -242,8 +113,8 @@ interface Test {
           f: (a: string) => number;
         }
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         interface Test {
           f(a: string): number;
@@ -256,8 +127,8 @@ interface Test {
           ['f']: (a: boolean) => void;
         }
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         interface Test {
           ['f'](a: boolean): void;
@@ -270,8 +141,8 @@ interface Test {
           f: <T>(a: T) => T;
         }
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         interface Test {
           f<T>(a: T): T;
@@ -284,8 +155,8 @@ interface Test {
           ['f']: <T extends {}>(a: T, b: T) => T;
         }
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         interface Test {
           ['f']<T extends {}>(a: T, b: T): T;
@@ -298,8 +169,8 @@ interface Test {
           'f!': </* a */>(/* b */ x: any /* c */) => void;
         }
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         interface Test {
           'f!'</* a */>(/* b */ x: any /* c */): void;
@@ -310,8 +181,8 @@ interface Test {
       code: `
         type Test = { f: (a: string) => number };
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         type Test = { f(a: string): number };
       `,
@@ -320,8 +191,8 @@ interface Test {
       code: `
         type Test = { ['f']?: (a: boolean) => void };
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         type Test = { ['f']?(a: boolean): void };
       `,
@@ -330,8 +201,8 @@ interface Test {
       code: `
         type Test = { f?: <T>(a?: T) => T };
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         type Test = { f?<T>(a?: T): T };
       `,
@@ -340,8 +211,8 @@ interface Test {
       code: `
         type Test = { ['f']?: <T>(a: T, b: T) => T };
       `,
-      options: ['method'],
       errors: [{ messageId: 'errorProperty' }],
+      options: ['method'],
       output: `
         type Test = { ['f']?<T>(a: T, b: T): T };
       `,
@@ -352,60 +223,60 @@ interface Foo {
   semi(arg: string): void;
   comma(arg: string): void,
   none(arg: string): void
-}
-      `,
-      output: `
-interface Foo {
-  semi: (arg: string) => void;
-  comma: (arg: string) => void,
-  none: (arg: string) => void
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
-    },
-    {
-      code: noFormat`
+      output: `
 interface Foo {
   semi: (arg: string) => void;
   comma: (arg: string) => void,
   none: (arg: string) => void
 }
       `,
-      output: `
+    },
+    {
+      code: noFormat`
 interface Foo {
-  semi(arg: string): void;
-  comma(arg: string): void,
-  none(arg: string): void
+  semi: (arg: string) => void;
+  comma: (arg: string) => void,
+  none: (arg: string) => void
 }
       `,
-      options: ['method'],
       errors: [
         {
-          messageId: 'errorProperty',
           line: 3,
+          messageId: 'errorProperty',
         },
         {
-          messageId: 'errorProperty',
           line: 4,
+          messageId: 'errorProperty',
         },
         {
-          messageId: 'errorProperty',
           line: 5,
+          messageId: 'errorProperty',
         },
       ],
+      options: ['method'],
+      output: `
+interface Foo {
+  semi(arg: string): void;
+  comma(arg: string): void,
+  none(arg: string): void
+}
+      `,
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/1857
     {
@@ -423,6 +294,16 @@ interface Foo {
   ): void;
 }
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'errorMethod',
+        },
+        {
+          line: 9,
+          messageId: 'errorMethod',
+        },
+      ],
       output: `
 interface Foo {
   x: (
@@ -437,16 +318,6 @@ interface Foo {
   ) => void;
 }
       `,
-      errors: [
-        {
-          messageId: 'errorMethod',
-          line: 3,
-        },
-        {
-          messageId: 'errorMethod',
-          line: 9,
-        },
-      ],
     },
     {
       code: noFormat`
@@ -454,27 +325,27 @@ interface Foo {
   foo(): one;
   foo(): two;
   foo(): three;
-}
-      `,
-      output: `
-interface Foo {
-  foo: (() => one) & (() => two) & (() => three);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+interface Foo {
+  foo: (() => one) & (() => two) & (() => three);
+}
+      `,
     },
     {
       code: noFormat`
@@ -482,27 +353,27 @@ interface Foo {
   foo(bar: string): one;
   foo(bar: number, baz: string): two;
   foo(): three;
-}
-      `,
-      output: `
-interface Foo {
-  foo: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+interface Foo {
+  foo: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
+}
+      `,
     },
     {
       code: noFormat`
@@ -510,27 +381,27 @@ interface Foo {
   [foo](bar: string): one;
   [foo](bar: number, baz: string): two;
   [foo](): three;
-}
-      `,
-      output: `
-interface Foo {
-  [foo]: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+interface Foo {
+  [foo]: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
+}
+      `,
     },
     {
       code: noFormat`
@@ -540,36 +411,36 @@ interface Foo {
   [foo](): three;
   bar(arg: string): void;
   bar(baz: number): Foo;
-}
-      `,
-      output: `
-interface Foo {
-  [foo]: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
-  bar: ((arg: string) => void) & ((baz: number) => Foo);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 6,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 7,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+interface Foo {
+  [foo]: ((bar: string) => one) & ((bar: number, baz: string) => two) & (() => three);
+  bar: ((arg: string) => void) & ((baz: number) => Foo);
+}
+      `,
     },
     {
       code: noFormat`
@@ -583,17 +454,17 @@ interface Foo {
           }
         }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 6,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 7,
+          messageId: 'errorMethod',
         },
       ],
+      output: null,
     },
     {
       code: noFormat`
@@ -601,27 +472,27 @@ type Foo = {
   foo(): one;
   foo(): two;
   foo(): three;
-}
-      `,
-      output: `
-type Foo = {
-  foo: (() => one) & (() => two) & (() => three);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+type Foo = {
+  foo: (() => one) & (() => two) & (() => three);
+}
+      `,
     },
     {
       code: noFormat`
@@ -629,46 +500,175 @@ declare const Foo: {
   foo(): one;
   foo(): two;
   foo(): three;
-}
-      `,
-      output: `
-declare const Foo: {
-  foo: (() => one) & (() => two) & (() => three);
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 4,
+          messageId: 'errorMethod',
         },
         {
-          messageId: 'errorMethod',
           line: 5,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+declare const Foo: {
+  foo: (() => one) & (() => two) & (() => three);
+}
+      `,
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/2834
     {
       code: `
 interface MyInterface {
   methodReturningImplicitAny();
-}
-      `,
-      output: `
-interface MyInterface {
-  methodReturningImplicitAny: () => any;
 }
       `,
       errors: [
         {
-          messageId: 'errorMethod',
           line: 3,
+          messageId: 'errorMethod',
         },
       ],
+      output: `
+interface MyInterface {
+  methodReturningImplicitAny: () => any;
+}
+      `,
+    },
+  ],
+  valid: [
+    `
+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;
+}
+    `,
+    `
+interface Test {
+  get f(): number;
+}
+    `,
+    `
+interface Test {
+  set f(value: number): 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 };",
+    'type Test = { get f(): number };',
+    'type Test = { set f(value: number): void };',
+    {
+      code: `
+        interface Test {
+          f(a: string): number;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          ['f'](a: boolean): void;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          f<T>(a: T): T;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          ['f']<T extends {}>(a: T, b: T): T;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          'f!'</* a */>(/* b */ x: any /* c */): void;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { f(a: string): number };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { ['f']?(a: boolean): void };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { f?<T>(a?: T): T };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { ['f']?<T>(a: T, b: T): T };
+      `,
+      options: ['method'],
+    },
+    `
+      interface Test {
+        get f(): number;
+      }
+    `,
+    `
+      interface Test {
+        set f(value: number): void;
+      }
+    `,
+    {
+      code: `
+        type Test = { get f(): number };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { set f(value: number): void };
+      `,
+      options: ['method'],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts b/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts
index 0aa8b08d6ee4..3025252d72e6 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts
@@ -2,37 +2,30 @@ import type {
   InvalidTestCase,
   ValidTestCase,
 } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type {
   MessageIds,
   Options,
 } from '../../../../src/rules/naming-convention';
-import rule from '../../../../src/rules/naming-convention';
 import type {
   PredefinedFormatsString,
   Selector,
 } from '../../../../src/rules/naming-convention-utils';
+
+import rule from '../../../../src/rules/naming-convention';
 import { selectorTypeToMessageString } from '../../../../src/rules/naming-convention-utils';
 
 export const formatTestNames: Readonly<
   Record<PredefinedFormatsString, Record<'invalid' | 'valid', string[]>>
 > = {
   camelCase: {
-    valid: ['strictCamelCase', 'lower', 'camelCaseUNSTRICT'],
     invalid: ['snake_case', 'UPPER_CASE', 'UPPER', 'StrictPascalCase'],
-  },
-  strictCamelCase: {
-    valid: ['strictCamelCase', 'lower'],
-    invalid: [
-      'snake_case',
-      'UPPER_CASE',
-      'UPPER',
-      'StrictPascalCase',
-      'camelCaseUNSTRICT',
-    ],
+    valid: ['strictCamelCase', 'lower', 'camelCaseUNSTRICT'],
   },
   PascalCase: {
+    invalid: ['snake_case', 'UPPER_CASE', 'strictCamelCase'],
     valid: [
       'StrictPascalCase',
       'Pascal',
@@ -40,10 +33,27 @@ export const formatTestNames: Readonly<
       'PascalCaseUNSTRICT',
       'UPPER',
     ],
-    invalid: ['snake_case', 'UPPER_CASE', 'strictCamelCase'],
+  },
+  snake_case: {
+    invalid: [
+      'UPPER_CASE',
+      'SNAKE_case_UNSTRICT',
+      'strictCamelCase',
+      'StrictPascalCase',
+    ],
+    valid: ['snake_case', 'lower'],
+  },
+  strictCamelCase: {
+    invalid: [
+      'snake_case',
+      'UPPER_CASE',
+      'UPPER',
+      'StrictPascalCase',
+      'camelCaseUNSTRICT',
+    ],
+    valid: ['strictCamelCase', 'lower'],
   },
   StrictPascalCase: {
-    valid: ['StrictPascalCase', 'Pascal', 'I18n'],
     invalid: [
       'snake_case',
       'UPPER_CASE',
@@ -51,9 +61,9 @@ export const formatTestNames: Readonly<
       'strictCamelCase',
       'PascalCaseUNSTRICT',
     ],
+    valid: ['StrictPascalCase', 'Pascal', 'I18n'],
   },
   UPPER_CASE: {
-    valid: ['UPPER_CASE', 'UPPER'],
     invalid: [
       'lower',
       'snake_case',
@@ -61,15 +71,7 @@ export const formatTestNames: Readonly<
       'strictCamelCase',
       'StrictPascalCase',
     ],
-  },
-  snake_case: {
-    valid: ['snake_case', 'lower'],
-    invalid: [
-      'UPPER_CASE',
-      'SNAKE_case_UNSTRICT',
-      'strictCamelCase',
-      'StrictPascalCase',
-    ],
+    valid: ['UPPER_CASE', 'UPPER'],
   },
 };
 
@@ -92,10 +94,10 @@ export function createTestCases(cases: Cases): void {
             preparedName: string,
             options: Selector,
           ): ValidTestCase<Options> => ({
-            options: [{ ...options, filter: IGNORED_FILTER }],
             code: `// ${JSON.stringify(options)}\n${test.code
               .map(code => code.replaceAll(REPLACE_REGEX, preparedName))
               .join('\n')}`,
+            options: [{ ...options, filter: IGNORED_FILTER }],
           });
 
           return [
@@ -260,8 +262,8 @@ export function createTestCases(cases: Cases): void {
               selector !== 'accessor'
                 ? {
                     data: {
-                      type: selectorTypeToMessageString(selector),
                       name: preparedName,
+                      type: selectorTypeToMessageString(selector),
                       ...data,
                     },
                   }
@@ -270,22 +272,22 @@ export function createTestCases(cases: Cases): void {
             }));
 
             const errors: {
-              data?: { type: string; name: string };
+              data?: { name: string; type: string };
               messageId: MessageIds;
             }[] = [];
             test.code.forEach(() => errors.push(...errorsTemplate));
 
             return {
+              code: `// ${JSON.stringify(options)}\n${test.code
+                .map(code => code.replaceAll(REPLACE_REGEX, preparedName))
+                .join('\n')}`,
+              errors,
               options: [
                 {
                   ...options,
                   filter: IGNORED_FILTER,
                 },
               ],
-              code: `// ${JSON.stringify(options)}\n${test.code
-                .map(code => code.replaceAll(REPLACE_REGEX, preparedName))
-                .join('\n')}`,
-              errors,
             };
           };
 
@@ -324,7 +326,7 @@ export function createTestCases(cases: Cases): void {
                 leadingUnderscore: 'require',
               },
               'missingUnderscore',
-              { position: 'leading', count: 'one' },
+              { count: 'one', position: 'leading' },
             ),
             createCase(
               name,
@@ -334,7 +336,7 @@ export function createTestCases(cases: Cases): void {
                 leadingUnderscore: 'requireDouble',
               },
               'missingUnderscore',
-              { position: 'leading', count: 'two' },
+              { count: 'two', position: 'leading' },
             ),
             createCase(
               `_${name}`,
@@ -344,7 +346,7 @@ export function createTestCases(cases: Cases): void {
                 leadingUnderscore: 'requireDouble',
               },
               'missingUnderscore',
-              { position: 'leading', count: 'two' },
+              { count: 'two', position: 'leading' },
             ),
 
             // trailingUnderscore
@@ -366,7 +368,7 @@ export function createTestCases(cases: Cases): void {
                 trailingUnderscore: 'require',
               },
               'missingUnderscore',
-              { position: 'trailing', count: 'one' },
+              { count: 'one', position: 'trailing' },
             ),
             createCase(
               name,
@@ -376,7 +378,7 @@ export function createTestCases(cases: Cases): void {
                 trailingUnderscore: 'requireDouble',
               },
               'missingUnderscore',
-              { position: 'trailing', count: 'two' },
+              { count: 'two', position: 'trailing' },
             ),
             createCase(
               `${name}_`,
@@ -386,7 +388,7 @@ export function createTestCases(cases: Cases): void {
                 trailingUnderscore: 'requireDouble',
               },
               'missingUnderscore',
-              { position: 'trailing', count: 'two' },
+              { count: 'two', position: 'trailing' },
             ),
 
             // prefix
@@ -398,7 +400,7 @@ export function createTestCases(cases: Cases): void {
                 prefix: prefixSingle,
               },
               'missingAffix',
-              { position: 'prefix', affixes: prefixSingle.join(', ') },
+              { affixes: prefixSingle.join(', '), position: 'prefix' },
             ),
             createCase(
               name,
@@ -409,8 +411,8 @@ export function createTestCases(cases: Cases): void {
               },
               'missingAffix',
               {
-                position: 'prefix',
                 affixes: prefixMulti.join(', '),
+                position: 'prefix',
               },
             ),
 
@@ -423,7 +425,7 @@ export function createTestCases(cases: Cases): void {
                 suffix: suffixSingle,
               },
               'missingAffix',
-              { position: 'suffix', affixes: suffixSingle.join(', ') },
+              { affixes: suffixSingle.join(', '), position: 'suffix' },
             ),
             createCase(
               name,
@@ -434,8 +436,8 @@ export function createTestCases(cases: Cases): void {
               },
               'missingAffix',
               {
-                position: 'suffix',
                 affixes: suffixMulti.join(', '),
+                position: 'suffix',
               },
             ),
           );
diff --git a/packages/eslint-plugin/tests/rules/naming-convention/cases/default.test.ts b/packages/eslint-plugin/tests/rules/naming-convention/cases/default.test.ts
index 4a3459b8639c..dfbc5b6ff871 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention/cases/default.test.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention/cases/default.test.ts
@@ -25,8 +25,8 @@ createTestCases([
       'interface Ignored<%> extends Ignored<string> {}',
     ],
     options: {
-      selector: 'default',
       filter: '[iI]gnored',
+      selector: 'default',
     },
   },
 ]);
diff --git a/packages/eslint-plugin/tests/rules/naming-convention/cases/parameterProperty.test.ts b/packages/eslint-plugin/tests/rules/naming-convention/cases/parameterProperty.test.ts
index 146cb4dfb540..d6a4f7ad1abb 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention/cases/parameterProperty.test.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention/cases/parameterProperty.test.ts
@@ -14,8 +14,8 @@ createTestCases([
   {
     code: ['class Ignored { constructor(private readonly %) {} }'],
     options: {
-      selector: 'parameterProperty',
       modifiers: ['readonly'],
+      selector: 'parameterProperty',
     },
   },
 ]);
diff --git a/packages/eslint-plugin/tests/rules/naming-convention/naming-convention.test.ts b/packages/eslint-plugin/tests/rules/naming-convention/naming-convention.test.ts
index af3dbc2ba1ee..520e186a97c6 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention/naming-convention.test.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention/naming-convention.test.ts
@@ -9,358 +9,421 @@ const ruleTester = new RuleTester();
 // only need parserOptions for the `type` option tests
 const rootDir = getFixturesRootDir();
 const parserOptions = {
-  tsconfigRootDir: rootDir,
   project: './tsconfig.json',
+  tsconfigRootDir: rootDir,
 };
 
 ruleTester.run('naming-convention', rule, {
-  valid: [
+  invalid: [
+    {
+      // make sure we handle no options and apply defaults
+      code: 'const x_x = 1;',
+      errors: [{ messageId: 'doesNotMatchFormat' }],
+    },
+    {
+      // make sure we handle empty options and apply defaults
+      code: 'const x_x = 1;',
+      errors: [{ messageId: 'doesNotMatchFormat' }],
+      options: [],
+    },
     {
       code: `
         const child_process = require('child_process');
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'default',
-          format: ['camelCase'],
           filter: {
+            match: true,
             regex: 'child_process',
-            match: false,
           },
+          format: ['camelCase'],
+          selector: 'default',
         },
       ],
     },
     {
       code: `
-        declare const ANY_UPPER_CASE: any;
-        declare const ANY_UPPER_CASE: any | null;
-        declare const ANY_UPPER_CASE: any | null | undefined;
-
-        declare const string_camelCase: string;
-        declare const string_camelCase: string | null;
-        declare const string_camelCase: string | null | undefined;
-        declare const string_camelCase: 'a' | null | undefined;
-        declare const string_camelCase: string | 'a' | null | undefined;
-
-        declare const number_camelCase: number;
-        declare const number_camelCase: number | null;
-        declare const number_camelCase: number | null | undefined;
-        declare const number_camelCase: 1 | null | undefined;
-        declare const number_camelCase: number | 2 | null | undefined;
-
-        declare const boolean_camelCase: boolean;
-        declare const boolean_camelCase: boolean | null;
-        declare const boolean_camelCase: boolean | null | undefined;
-        declare const boolean_camelCase: true | null | undefined;
-        declare const boolean_camelCase: false | null | undefined;
-        declare const boolean_camelCase: true | false | null | undefined;
+        declare const any_camelCase01: any;
+        declare const any_camelCase02: any | null;
+        declare const any_camelCase03: any | null | undefined;
+        declare const string_camelCase01: string;
+        declare const string_camelCase02: string | null;
+        declare const string_camelCase03: string | null | undefined;
+        declare const string_camelCase04: 'a' | null | undefined;
+        declare const string_camelCase05: string | 'a' | null | undefined;
+        declare const number_camelCase06: number;
+        declare const number_camelCase07: number | null;
+        declare const number_camelCase08: number | null | undefined;
+        declare const number_camelCase09: 1 | null | undefined;
+        declare const number_camelCase10: number | 2 | null | undefined;
+        declare const boolean_camelCase11: boolean;
+        declare const boolean_camelCase12: boolean | null;
+        declare const boolean_camelCase13: boolean | null | undefined;
+        declare const boolean_camelCase14: true | null | undefined;
+        declare const boolean_camelCase15: false | null | undefined;
+        declare const boolean_camelCase16: true | false | null | undefined;
       `,
+      errors: Array(19).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'variable',
-          modifiers: ['const'],
           format: ['UPPER_CASE'],
-          prefix: ['ANY_'],
+          modifiers: ['const'],
+          prefix: ['any_'],
+          selector: 'variable',
         },
         {
+          format: ['snake_case'],
+          prefix: ['string_'],
           selector: 'variable',
           types: ['string'],
-          format: ['camelCase'],
-          prefix: ['string_'],
         },
         {
+          format: ['snake_case'],
+          prefix: ['number_'],
           selector: 'variable',
           types: ['number'],
-          format: ['camelCase'],
-          prefix: ['number_'],
         },
         {
+          format: ['snake_case'],
+          prefix: ['boolean_'],
           selector: 'variable',
           types: ['boolean'],
-          format: ['camelCase'],
-          prefix: ['boolean_'],
         },
       ],
     },
     {
       code: `
-        let foo = 'a';
-        const _foo = 1;
-        interface Foo {}
-        class Bar {}
-        function foo_function_bar() {}
+        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;
       `,
+      errors: Array(4).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
+      languageOptions: { parserOptions },
       options: [
         {
-          selector: 'default',
-          format: ['camelCase'],
-          custom: {
-            regex: /^unused_\w/.source,
-            match: false,
-          },
-          leadingUnderscore: 'allow',
-        },
-        {
-          selector: 'typeLike',
-          format: ['PascalCase'],
-          custom: {
-            regex: /^I[A-Z]/.source,
-            match: false,
-          },
-        },
-        {
-          selector: 'function',
           format: ['snake_case'],
-          custom: {
-            regex: /_function_/.source,
-            match: true,
-          },
-          leadingUnderscore: 'allow',
+          prefix: ['function_'],
+          selector: 'variable',
+          types: ['function'],
         },
       ],
     },
     {
       code: `
-        let foo = 'a';
-        const _foo = 1;
-        interface foo {}
-        class bar {}
-        function fooFunctionBar() {}
-        function _fooFunctionBar() {}
+        declare const array_camelCase1: Array<number>;
+        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_camelCase6: [] | null | undefined;
+        declare const array_camelCase7: [number] | null | undefined;
+        declare const array_camelCase8:
+          | readonly number[]
+          | Array<string>
+          | [boolean]
+          | null
+          | undefined;
       `,
+      errors: Array(8).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
+      languageOptions: { parserOptions },
       options: [
         {
-          selector: ['default', 'typeLike', 'function'],
-          format: ['camelCase'],
-          custom: {
-            regex: /^unused_\w/.source,
-            match: false,
-          },
-          leadingUnderscore: 'allow',
+          format: ['snake_case'],
+          prefix: ['array_'],
+          selector: 'variable',
+          types: ['array'],
         },
       ],
     },
     {
       code: `
-        const match = 'test'.match(/test/);
-        const [, key, value] = match;
+        let unused_foo = 'a';
+        const _unused_foo = 1;
+        interface IFoo {}
+        class IBar {}
+        function fooBar() {}
       `,
-      options: [
+      errors: [
         {
-          selector: 'default',
-          format: ['camelCase'],
+          data: {
+            name: 'unused_foo',
+            regex: '/^unused_\\w/u',
+            regexMatch: 'not match',
+            type: 'Variable',
+          },
+          line: 2,
+          messageId: 'satisfyCustom',
         },
-      ],
-    },
-    // no format selector
-    {
-      code: 'const snake_case = 1;',
-      options: [
         {
-          selector: 'default',
-          format: ['camelCase'],
+          data: {
+            name: '_unused_foo',
+            regex: '/^unused_\\w/u',
+            regexMatch: 'not match',
+            type: 'Variable',
+          },
+          line: 3,
+          messageId: 'satisfyCustom',
         },
         {
-          selector: 'variable',
-          format: null,
+          data: {
+            name: 'IFoo',
+            regex: '/^I[A-Z]/u',
+            regexMatch: 'not match',
+            type: 'Interface',
+          },
+          line: 4,
+          messageId: 'satisfyCustom',
+        },
+        {
+          data: {
+            name: 'IBar',
+            regex: '/^I[A-Z]/u',
+            regexMatch: 'not match',
+            type: 'Class',
+          },
+          line: 5,
+          messageId: 'satisfyCustom',
+        },
+        {
+          data: {
+            name: 'fooBar',
+            regex: '/function/u',
+            regexMatch: 'match',
+            type: 'Function',
+          },
+          line: 6,
+          messageId: 'satisfyCustom',
         },
       ],
-    },
-    {
-      code: 'const snake_case = 1;',
       options: [
         {
+          custom: {
+            match: false,
+            regex: /^unused_\w/.source,
+          },
+          format: ['snake_case'],
+          leadingUnderscore: 'allow',
           selector: 'default',
-          format: ['camelCase'],
         },
         {
-          selector: 'variable',
-          format: [],
+          custom: {
+            match: false,
+            regex: /^I[A-Z]/.source,
+          },
+          format: ['PascalCase'],
+          selector: 'typeLike',
+        },
+        {
+          custom: {
+            match: true,
+            regex: /function/.source,
+          },
+          format: ['camelCase'],
+          leadingUnderscore: 'allow',
+          selector: 'function',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1478
     {
       code: `
-        const child_process = require('child_process');
-      `,
-      options: [
-        { selector: 'variable', format: ['camelCase', 'UPPER_CASE'] },
-        {
-          selector: 'variable',
-          format: ['snake_case'],
-          filter: 'child_process',
+        let unused_foo = 'a';
+        const _unused_foo = 1;
+        function foo_bar() {}
+        interface IFoo {}
+        class IBar {}
+      `,
+      errors: [
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'unused_foo',
+            type: 'Variable',
+          },
+          line: 2,
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'camelCase',
+            name: '_unused_foo',
+            processedName: 'unused_foo',
+            type: 'Variable',
+          },
+          line: 3,
+          messageId: 'doesNotMatchFormatTrimmed',
+        },
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'foo_bar',
+            type: 'Function',
+          },
+          line: 4,
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            name: 'IFoo',
+            regex: '/^I[A-Z]/u',
+            regexMatch: 'not match',
+            type: 'Interface',
+          },
+          line: 5,
+          messageId: 'satisfyCustom',
+        },
+        {
+          data: {
+            name: 'IBar',
+            regex: '/^I[A-Z]/u',
+            regexMatch: 'not match',
+            type: 'Class',
+          },
+          line: 6,
+          messageId: 'satisfyCustom',
         },
       ],
-    },
-    {
-      code: `
-        const foo = {
-          'Property-Name': 'asdf',
-        };
-      `,
       options: [
         {
-          format: ['strictCamelCase'],
-          selector: 'default',
-          filter: {
-            regex: /-/.source,
+          format: ['camelCase'],
+          leadingUnderscore: 'allow',
+          selector: ['variable', 'function'],
+        },
+        {
+          custom: {
             match: false,
+            regex: /^I[A-Z]/.source,
           },
+          format: ['PascalCase'],
+          selector: ['class', 'interface'],
         },
       ],
     },
     {
       code: `
         const foo = {
-          'Property-Name': 'asdf',
+          'Property Name': 'asdf',
         };
       `,
-      options: [
+      errors: [
         {
-          format: ['strictCamelCase'],
-          selector: 'default',
-          filter: {
-            regex: /^(Property-Name)$/.source,
-            match: false,
+          data: {
+            formats: 'strictCamelCase',
+            name: 'Property Name',
+            type: 'Object Literal Property',
           },
+          line: 3,
+          messageId: 'doesNotMatchFormat',
         },
       ],
-    },
-    {
-      code: `
-        let isFoo = 1;
-        class foo {
-          shouldBoo: number;
-        }
-      `,
-      languageOptions: { parserOptions },
       options: [
         {
-          selector: ['variable', 'parameter', 'property', 'accessor'],
-          types: ['number'],
-          format: ['PascalCase'],
-          prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+          filter: {
+            match: false,
+            regex: /-/.source,
+          },
+          format: ['strictCamelCase'],
+          selector: 'default',
         },
       ],
     },
     {
       code: `
+        const myfoo_bar = 'abcs';
+        function fun(myfoo: string) {}
         class foo {
-          private readonly FooBoo: boolean;
+          Myfoo: string;
         }
       `,
+      errors: Array(3).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
       languageOptions: { parserOptions },
       options: [
         {
-          selector: ['property', 'accessor'],
-          types: ['boolean'],
-          modifiers: ['private', 'readonly'],
           format: ['PascalCase'],
+          prefix: ['my', 'My'],
+          selector: ['variable', 'property', 'parameter'],
+          types: ['string'],
         },
       ],
     },
     {
       code: `
         class foo {
-          private fooBoo: number;
+          private readonly fooBar: boolean;
         }
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
+          format: ['PascalCase'],
+          modifiers: ['private', 'readonly'],
           selector: ['property', 'accessor'],
-          modifiers: ['private'],
-          format: ['camelCase'],
         },
       ],
     },
     {
       code: `
-        const isfooBar = 1;
-        function fun(goodfunFoo: number) {}
-        class foo {
-          private VanFooBar: number;
-        }
+        function my_foo_bar() {}
       `,
+      errors: [{ messageId: 'doesNotMatchFormatTrimmed' }],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: ['property', 'accessor'],
-          modifiers: ['private'],
-          format: ['StrictPascalCase'],
-          prefix: ['Van'],
-        },
-        {
-          selector: ['variable', 'parameter'],
-          types: ['number'],
-          format: ['camelCase'],
-          prefix: ['is', 'good'],
+          format: ['PascalCase'],
+          prefix: ['my', 'My'],
+          selector: ['variable', 'function'],
+          types: ['string'],
         },
       ],
     },
     {
       code: `
         class SomeClass {
-          static OtherConstant = 'hello';
+          static otherConstant = 'hello';
         }
 
-        export const { OtherConstant: otherConstant } = SomeClass;
+        export const { otherConstant } = SomeClass;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
       options: [
-        { selector: 'property', format: ['PascalCase'] },
-        { selector: 'variable', format: ['camelCase'] },
+        { format: ['PascalCase'], selector: 'property' },
+        { format: ['camelCase'], selector: 'variable' },
       ],
     },
-    // treat properties with function expressions as typeMethod
     {
       code: `
-        interface SOME_INTERFACE {
-          SomeMethod: () => void;
-
-          some_property: string;
+        declare class Foo {
+          Bar(Baz: string): void;
         }
       `,
-      options: [
-        {
-          selector: 'default',
-          format: ['UPPER_CASE'],
-        },
-        {
-          selector: 'typeMethod',
-          format: ['PascalCase'],
-        },
+      errors: [
         {
-          selector: 'typeProperty',
-          format: ['snake_case'],
+          line: 3,
+          messageId: 'doesNotMatchFormat',
         },
       ],
-    },
-    {
-      code: `
-        type Ignored = {
-          ignored_due_to_modifiers: string;
-          readonly FOO: string;
-        };
-      `,
       languageOptions: { parserOptions },
-      options: [
-        {
-          selector: 'typeProperty',
-          modifiers: ['readonly'],
-          format: ['UPPER_CASE'],
-        },
-      ],
+      options: [{ format: ['camelCase'], selector: 'parameter' }],
     },
     {
       code: `
-        const camelCaseVar = 1;
-        enum camelCaseEnum {}
-        class camelCaseClass {}
-        function camelCaseFunction() {}
-        interface camelCaseInterface {}
-        type camelCaseType = {};
         export const PascalCaseVar = 1;
         export enum PascalCaseEnum {}
         export class PascalCaseClass {}
@@ -368,48 +431,46 @@ ruleTester.run('naming-convention', rule, {
         export interface PascalCaseInterface {}
         export type PascalCaseType = {};
       `,
+      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
-        { selector: 'default', format: ['camelCase'] },
         {
-          selector: 'variable',
-          format: ['PascalCase'],
+          format: ['snake_case'],
+          selector: 'default',
+        },
+        {
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'function',
         },
         {
-          selector: 'class',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'class',
         },
         {
-          selector: 'interface',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'interface',
         },
         {
-          selector: 'typeAlias',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'typeAlias',
         },
         {
-          selector: 'enum',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'enum',
         },
       ],
     },
     {
       code: `
-        const camelCaseVar = 1;
-        enum camelCaseEnum {}
-        class camelCaseClass {}
-        function camelCaseFunction() {}
-        interface camelCaseInterface {}
-        type camelCaseType = {};
         const PascalCaseVar = 1;
         enum PascalCaseEnum {}
         class PascalCaseClass {}
@@ -425,100 +486,80 @@ ruleTester.run('naming-convention', rule, {
           PascalCaseType,
         };
       `,
+      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
-        { selector: 'default', format: ['camelCase'] },
+        { format: ['snake_case'], selector: 'default' },
         {
-          selector: 'variable',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'function',
         },
         {
-          selector: 'class',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'class',
         },
         {
-          selector: 'interface',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'interface',
         },
         {
-          selector: 'typeAlias',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'typeAlias',
         },
         {
-          selector: 'enum',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['exported'],
+          selector: 'enum',
         },
       ],
     },
     {
       code: `
-        {
-          const camelCaseVar = 1;
-          function camelCaseFunction() {}
-          declare function camelCaseDeclaredFunction();
-        }
         const PascalCaseVar = 1;
         function PascalCaseFunction() {}
         declare function PascalCaseDeclaredFunction();
       `,
+      errors: Array(3).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
-        { selector: 'default', format: ['camelCase'] },
+        { format: ['snake_case'], selector: 'default' },
         {
-          selector: 'variable',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['global'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['PascalCase'],
+          format: ['camelCase'],
           modifiers: ['global'],
+          selector: 'function',
         },
       ],
     },
     {
       code: `
         const { some_name1 } = {};
-        const { ignore: IgnoredDueToModifiers1 } = {};
         const { some_name2 = 2 } = {};
-        const IgnoredDueToModifiers2 = 1;
+        const { ignored: IgnoredDueToModifiers1 } = {};
+        const { ignored: IgnoredDueToModifiers2 = 3 } = {};
+        const IgnoredDueToModifiers3 = 1;
       `,
+      errors: Array(2).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
-        },
-        {
-          selector: 'variable',
-          format: ['snake_case'],
-          modifiers: ['destructured'],
-        },
-      ],
-    },
-    {
-      code: `
-        const { some_name1 } = {};
-        const { ignore: IgnoredDueToModifiers1 } = {};
-        const { some_name2 = 2 } = {};
-        const IgnoredDueToModifiers2 = 1;
-      `,
-      options: [
-        {
           selector: 'default',
-          format: ['PascalCase'],
         },
         {
-          selector: 'variable',
-          format: null,
+          format: ['UPPER_CASE'],
           modifiers: ['destructured'],
+          selector: 'variable',
         },
       ],
     },
@@ -532,15 +573,16 @@ ruleTester.run('naming-convention', rule, {
           IgnoredDueToModifiers2,
         ) {}
       `,
+      errors: Array(2).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'parameter',
+          format: ['UPPER_CASE'],
           modifiers: ['destructured'],
-          format: ['camelCase'],
+          selector: 'parameter',
         },
       ],
     },
@@ -551,15 +593,16 @@ ruleTester.run('naming-convention', rule, {
           IgnoredDueToModifiers = 1;
         }
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'classProperty',
-          format: ['snake_case'],
+          format: ['UPPER_CASE'],
           modifiers: ['static', 'readonly'],
+          selector: 'classProperty',
         },
       ],
     },
@@ -572,15 +615,16 @@ ruleTester.run('naming-convention', rule, {
           ) {}
         }
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'parameterProperty',
-          format: ['snake_case'],
+          format: ['UPPER_CASE'],
           modifiers: ['readonly'],
+          selector: 'parameterProperty',
         },
       ],
     },
@@ -591,15 +635,16 @@ ruleTester.run('naming-convention', rule, {
           IgnoredDueToModifiers() {}
         }
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'classMethod',
-          format: ['snake_case'],
+          format: ['UPPER_CASE'],
           modifiers: ['abstract', 'static'],
+          selector: 'classMethod',
         },
       ],
     },
@@ -610,15 +655,16 @@ ruleTester.run('naming-convention', rule, {
           get IgnoredDueToModifiers() {}
         }
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'accessor',
-          format: ['snake_case'],
+          format: ['UPPER_CASE'],
           modifiers: ['private', 'static'],
+          selector: 'accessor',
         },
       ],
     },
@@ -627,15 +673,16 @@ ruleTester.run('naming-convention', rule, {
         abstract class some_name {}
         class IgnoredDueToModifier {}
       `,
+      errors: [{ messageId: 'doesNotMatchFormat' }],
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'class',
-          format: ['snake_case'],
+          format: ['UPPER_CASE'],
           modifiers: ['abstract'],
+          selector: 'class',
         },
       ],
     },
@@ -652,30 +699,17 @@ ruleTester.run('naming-convention', rule, {
           // this line is intentionally broken out
           UnusedTypeParam,
         > = {};
-
-        export const used_var = 1;
-        export function used_func(
-          // this line is intentionally broken out
-          used_param: string,
-        ) {
-          return used_param;
-        }
-        export class used_class {}
-        export interface used_interface {}
-        export type used_type<
-          // this line is intentionally broken out
-          used_typeparam,
-        > = used_typeparam;
       `,
+      errors: Array(7).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
         {
+          format: ['PascalCase'],
           selector: 'default',
-          format: ['snake_case'],
         },
         {
-          selector: 'default',
+          format: ['snake_case'],
           modifiers: ['unused'],
-          format: ['PascalCase'],
+          selector: 'default',
         },
       ],
     },
@@ -709,107 +743,116 @@ ruleTester.run('naming-convention', rule, {
           'a a',
         }
       `,
+      errors: Array(13).fill({ messageId: 'doesNotMatchFormat' }),
       options: [
         {
-          selector: 'default',
           format: ['snake_case'],
+          selector: 'default',
         },
         {
-          selector: 'default',
-          format: null,
+          format: ['PascalCase'],
           modifiers: ['requiresQuotes'],
+          selector: 'default',
         },
       ],
     },
     {
-      code: `
-        const ignored1 = {
-          'a a': 1,
-          'b b'() {},
-          get 'c c'() {
-            return 1;
-          },
-          set 'd d'(value: string) {},
+      code: noFormat`
+        type Foo = {
+          'foo     Bar': string;
+          '': string;
+          '0': string;
+          'foo': string;
+          'foo-bar': string;
+          '#foo-bar': string;
         };
-        class ignored2 {
-          'a a' = 1;
-          'b b'() {}
-          get 'c c'() {
-            return 1;
-          }
-          set 'd d'(value: string) {}
+
+        interface Bar {
+          'boo-----foo': string;
         }
-        interface ignored3 {
-          'a a': 1;
-          'b b'(): void;
+      `,
+      // 6, not 7 because 'foo' is valid
+      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
+    },
+    {
+      code: `
+        class foo {
+          public Bar() {
+            return 42;
+          }
+          public async async_bar() {
+            return 42;
+          }
+          // ❌ error
+          public async asyncBar() {
+            return 42;
+          }
+          // ❌ error
+          public AsyncBar2 = async () => {
+            return 42;
+          };
+          // ❌ error
+          public AsyncBar3 = async function () {
+            return 42;
+          };
         }
-        type ignored4 = {
-          'a a': 1;
-          'b b'(): void;
-        };
-        enum ignored5 {
-          'a a',
+        abstract class foo {
+          public abstract Bar(): number;
+          public abstract async async_bar(): number;
+          // ❌ error
+          public abstract async ASYNC_BAR(): number;
         }
       `,
-      options: [
+      errors: [
         {
-          selector: 'default',
-          format: ['snake_case'],
+          data: {
+            formats: 'snake_case',
+            name: 'asyncBar',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
         },
         {
-          selector: [
-            'classProperty',
-            'objectLiteralProperty',
-            'typeProperty',
-            'classMethod',
-            'objectLiteralMethod',
-            'typeMethod',
-            'accessor',
-            'enumMember',
-          ],
-          format: null,
-          modifiers: ['requiresQuotes'],
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar2',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
         },
-        // making sure the `requoresQuotes` modifier appropriately overrides this
         {
-          selector: [
-            'classProperty',
-            'objectLiteralProperty',
-            'typeProperty',
-            'classMethod',
-            'objectLiteralMethod',
-            'typeMethod',
-            'accessor',
-            'enumMember',
-          ],
-          format: ['PascalCase'],
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar3',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
         },
-      ],
-    },
-    {
-      code: `
-        const obj = {
-          Foo: 42,
-          Bar() {
-            return 42;
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'ASYNC_BAR',
+            type: 'Class Method',
           },
-        };
-      `,
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: 'property',
           format: ['PascalCase'],
-        },
-        {
           selector: 'method',
-          format: ['PascalCase'],
         },
-      ],
+        {
+          format: ['snake_case'],
+          modifiers: ['async'],
+          selector: ['method', 'objectLiteralMethod'],
+        },
+      ],
     },
     {
       code: `
@@ -820,61 +863,150 @@ ruleTester.run('naming-convention', rule, {
           async async_bar() {
             return 42;
           },
-        };
-        class foo {
-          public Bar() {
-            return 42;
-          }
-          public async async_bar() {
+          // ❌ error
+          async AsyncBar() {
             return 42;
-          }
-        }
-        abstract class foo {
-          public abstract Bar() {
+          },
+          // ❌ error
+          AsyncBar2: async () => {
             return 42;
-          }
-          public abstract async async_bar() {
+          },
+          // ❌ error
+          AsyncBar3: async function () {
             return 42;
-          }
-        }
+          },
+        };
       `,
+      errors: [
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar',
+            type: 'Object Literal Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar2',
+            type: 'Object Literal Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar3',
+            type: 'Object Literal Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['method', 'objectLiteralMethod'],
-          format: ['snake_case'],
-          modifiers: ['async'],
+          format: ['PascalCase'],
+          selector: 'method',
         },
         {
-          selector: 'method',
-          format: ['PascalCase'],
+          format: ['snake_case'],
+          modifiers: ['async'],
+          selector: ['method', 'objectLiteralMethod'],
         },
       ],
     },
     {
       code: `
+        const syncbar1 = () => {};
+        function syncBar2() {}
+        const syncBar3 = function syncBar4() {};
+
+        // ❌ error
+        const AsyncBar1 = async () => {};
         const async_bar1 = async () => {};
-        async function async_bar2() {}
         const async_bar3 = async function async_bar4() {};
+        async function async_bar2() {}
+        // ❌ error
+        const asyncBar5 = async function async_bar6() {};
       `,
+      errors: [
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'AsyncBar1',
+            type: 'Variable',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'asyncBar5',
+            type: 'Variable',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'variableLike',
         },
         {
-          selector: 'method',
-          format: ['PascalCase'],
+          format: ['snake_case'],
+          modifiers: ['async'],
+          selector: ['variableLike'],
+        },
+      ],
+    },
+    {
+      code: `
+        const syncbar1 = () => {};
+        function syncBar2() {}
+        const syncBar3 = function syncBar4() {};
+
+        const async_bar1 = async () => {};
+        // ❌ error
+        async function asyncBar2() {}
+        const async_bar3 = async function async_bar4() {};
+        async function async_bar2() {}
+        // ❌ error
+        const async_bar3 = async function ASYNC_BAR4() {};
+      `,
+      errors: [
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'asyncBar2',
+            type: 'Function',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'ASYNC_BAR4',
+            type: 'Function',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [
+        {
+          format: ['camelCase'],
+          selector: 'variableLike',
         },
         {
-          selector: ['variable'],
           format: ['snake_case'],
           modifiers: ['async'],
+          selector: ['variableLike'],
         },
       ],
     },
@@ -883,129 +1015,273 @@ ruleTester.run('naming-convention', rule, {
         class foo extends bar {
           public someAttribute = 1;
           public override some_attribute_override = 1;
-          public someMethod() {
-            return 42;
-          }
-          public override some_method_override2() {
-            return 42;
-          }
-        }
-        abstract class foo extends bar {
-          public abstract someAttribute: string;
-          public abstract override some_attribute_override: string;
-          public abstract someMethod(): string;
-          public abstract override some_method_override2(): string;
+          // ❌ error
+          public override someAttributeOverride = 1;
         }
       `,
+      errors: [
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'someAttributeOverride',
+            type: 'Class Property',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['override'],
           format: ['snake_case'],
+          modifiers: ['override'],
+          selector: ['memberLike'],
         },
       ],
     },
     {
       code: `
-        class foo {
-          private someAttribute = 1;
-          #some_attribute = 1;
-
-          private someMethod() {}
-          #some_method() {}
+        class foo extends bar {
+          public override some_method_override() {
+            return 42;
+          }
+          // ❌ error
+          public override someMethodOverride() {
+            return 42;
+          }
         }
       `,
+      errors: [
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'someMethodOverride',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['#private'],
           format: ['snake_case'],
+          modifiers: ['override'],
+          selector: ['memberLike'],
         },
       ],
     },
     {
-      code: "import * as FooBar from 'foo_bar';",
-      languageOptions: { parserOptions },
-      options: [
+      code: `
+        class foo extends bar {
+          public get someGetter(): string;
+          public override get some_getter_override(): string;
+          // ❌ error
+          public override get someGetterOverride(): string;
+          public set someSetter(val: string);
+          public override set some_setter_override(val: string);
+          // ❌ error
+          public override set someSetterOverride(val: string);
+        }
+      `,
+      errors: [
         {
-          selector: ['import'],
-          format: ['PascalCase'],
+          data: {
+            formats: 'snake_case',
+            name: 'someGetterOverride',
+            type: 'Classic Accessor',
+          },
+          messageId: 'doesNotMatchFormat',
         },
         {
-          selector: ['import'],
-          modifiers: ['default'],
-          format: ['camelCase'],
+          data: {
+            formats: 'snake_case',
+            name: 'someSetterOverride',
+            type: 'Classic Accessor',
+          },
+          messageId: 'doesNotMatchFormat',
         },
       ],
-    },
-    {
-      code: "import fooBar from 'foo_bar';",
       languageOptions: { parserOptions },
       options: [
         {
-          selector: ['import'],
-          format: ['PascalCase'],
+          format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['import'],
-          modifiers: ['default'],
-          format: ['camelCase'],
+          format: ['snake_case'],
+          modifiers: ['override'],
+          selector: ['memberLike'],
         },
       ],
     },
     {
-      code: "import { default as fooBar } from 'foo_bar';",
-      languageOptions: { parserOptions },
-      options: [
-        {
-          selector: ['import'],
-          format: ['PascalCase'],
+      code: `
+        class foo {
+          private firstPrivateField = 1;
+          // ❌ error
+          private first_private_field = 1;
+          // ❌ error
+          #secondPrivateField = 1;
+          #second_private_field = 1;
+        }
+      `,
+      errors: [
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'first_private_field',
+            type: 'Class Property',
+          },
+          messageId: 'doesNotMatchFormat',
         },
         {
-          selector: ['import'],
-          modifiers: ['default'],
+          data: {
+            formats: 'snake_case',
+            name: 'secondPrivateField',
+            type: 'Class Property',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [
+        {
           format: ['camelCase'],
+          selector: 'memberLike',
+        },
+        {
+          format: ['snake_case'],
+          modifiers: ['#private'],
+          selector: ['memberLike'],
         },
       ],
     },
     {
-      code: "import { foo_bar } from 'foo_bar';",
+      code: `
+        class foo {
+          private firstPrivateMethod() {}
+          // ❌ error
+          private first_private_method() {}
+          // ❌ error
+          #secondPrivateMethod() {}
+          #second_private_method() {}
+        }
+      `,
+      errors: [
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'first_private_method',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+        {
+          data: {
+            formats: 'snake_case',
+            name: 'secondPrivateMethod',
+            type: 'Class Method',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [
+        {
+          format: ['camelCase'],
+          selector: 'memberLike',
+        },
+        {
+          format: ['snake_case'],
+          modifiers: ['#private'],
+          selector: ['memberLike'],
+        },
+      ],
+    },
+    {
+      code: "import * as fooBar from 'foo_bar';",
+      errors: [
+        {
+          data: {
+            formats: 'PascalCase',
+            name: 'fooBar',
+            type: 'Import',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [
         {
+          format: ['camelCase'],
           selector: ['import'],
-          format: ['PascalCase'],
         },
         {
+          format: ['PascalCase'],
+          modifiers: ['namespace'],
           selector: ['import'],
-          modifiers: ['default'],
-          format: ['camelCase'],
         },
       ],
     },
-  ],
-  invalid: [
     {
-      // make sure we handle no options and apply defaults
-      code: 'const x_x = 1;',
-      errors: [{ messageId: 'doesNotMatchFormat' }],
+      code: "import FooBar from 'foo_bar';",
+      errors: [
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'FooBar',
+            type: 'Import',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [
+        {
+          format: ['camelCase'],
+          selector: ['import'],
+        },
+        {
+          format: ['PascalCase'],
+          modifiers: ['namespace'],
+          selector: ['import'],
+        },
+      ],
     },
     {
-      // make sure we handle empty options and apply defaults
-      code: 'const x_x = 1;',
-      options: [],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
+      code: "import { default as foo_bar } from 'foo_bar';",
+      errors: [
+        {
+          data: {
+            formats: 'camelCase',
+            name: 'foo_bar',
+            type: 'Import',
+          },
+          messageId: 'doesNotMatchFormat',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [
+        {
+          format: ['camelCase'],
+          selector: ['import'],
+        },
+        {
+          format: ['PascalCase'],
+          modifiers: ['namespace'],
+          selector: ['import'],
+        },
+      ],
     },
+  ],
+  valid: [
     {
       code: `
         const child_process = require('child_process');
@@ -1013,397 +1289,345 @@ ruleTester.run('naming-convention', rule, {
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'default',
-          format: ['camelCase'],
           filter: {
+            match: false,
             regex: 'child_process',
-            match: true,
           },
+          format: ['camelCase'],
+          selector: 'default',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
-        declare const any_camelCase01: any;
-        declare const any_camelCase02: any | null;
-        declare const any_camelCase03: any | null | undefined;
-        declare const string_camelCase01: string;
-        declare const string_camelCase02: string | null;
-        declare const string_camelCase03: string | null | undefined;
-        declare const string_camelCase04: 'a' | null | undefined;
-        declare const string_camelCase05: string | 'a' | null | undefined;
-        declare const number_camelCase06: number;
-        declare const number_camelCase07: number | null;
-        declare const number_camelCase08: number | null | undefined;
-        declare const number_camelCase09: 1 | null | undefined;
-        declare const number_camelCase10: number | 2 | null | undefined;
-        declare const boolean_camelCase11: boolean;
-        declare const boolean_camelCase12: boolean | null;
-        declare const boolean_camelCase13: boolean | null | undefined;
-        declare const boolean_camelCase14: true | null | undefined;
-        declare const boolean_camelCase15: false | null | undefined;
-        declare const boolean_camelCase16: true | false | null | undefined;
+        declare const ANY_UPPER_CASE: any;
+        declare const ANY_UPPER_CASE: any | null;
+        declare const ANY_UPPER_CASE: any | null | undefined;
+
+        declare const string_camelCase: string;
+        declare const string_camelCase: string | null;
+        declare const string_camelCase: string | null | undefined;
+        declare const string_camelCase: 'a' | null | undefined;
+        declare const string_camelCase: string | 'a' | null | undefined;
+
+        declare const number_camelCase: number;
+        declare const number_camelCase: number | null;
+        declare const number_camelCase: number | null | undefined;
+        declare const number_camelCase: 1 | null | undefined;
+        declare const number_camelCase: number | 2 | null | undefined;
+
+        declare const boolean_camelCase: boolean;
+        declare const boolean_camelCase: boolean | null;
+        declare const boolean_camelCase: boolean | null | undefined;
+        declare const boolean_camelCase: true | null | undefined;
+        declare const boolean_camelCase: false | null | undefined;
+        declare const boolean_camelCase: true | false | null | undefined;
       `,
+      languageOptions: { parserOptions },
       options: [
         {
-          selector: 'variable',
-          modifiers: ['const'],
           format: ['UPPER_CASE'],
-          prefix: ['any_'],
+          modifiers: ['const'],
+          prefix: ['ANY_'],
+          selector: 'variable',
         },
         {
+          format: ['camelCase'],
+          prefix: ['string_'],
           selector: 'variable',
           types: ['string'],
-          format: ['snake_case'],
-          prefix: ['string_'],
         },
         {
+          format: ['camelCase'],
+          prefix: ['number_'],
           selector: 'variable',
           types: ['number'],
-          format: ['snake_case'],
-          prefix: ['number_'],
         },
         {
+          format: ['camelCase'],
+          prefix: ['boolean_'],
           selector: 'variable',
           types: ['boolean'],
-          format: ['snake_case'],
-          prefix: ['boolean_'],
         },
       ],
-      languageOptions: { parserOptions },
-      errors: Array(19).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
       code: `
-        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;
+        let foo = 'a';
+        const _foo = 1;
+        interface Foo {}
+        class Bar {}
+        function foo_function_bar() {}
       `,
       options: [
         {
-          selector: 'variable',
-          types: ['function'],
-          format: ['snake_case'],
-          prefix: ['function_'],
+          custom: {
+            match: false,
+            regex: /^unused_\w/.source,
+          },
+          format: ['camelCase'],
+          leadingUnderscore: 'allow',
+          selector: 'default',
         },
-      ],
-      languageOptions: { parserOptions },
-      errors: Array(4).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
-    },
-    {
-      code: `
-        declare const array_camelCase1: Array<number>;
-        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_camelCase6: [] | null | undefined;
-        declare const array_camelCase7: [number] | null | undefined;
-        declare const array_camelCase8:
-          | readonly number[]
-          | Array<string>
-          | [boolean]
-          | null
-          | undefined;
-      `,
-      options: [
-        {
-          selector: 'variable',
-          types: ['array'],
-          format: ['snake_case'],
-          prefix: ['array_'],
-        },
-      ],
-      languageOptions: { parserOptions },
-      errors: Array(8).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
-    },
-    {
-      code: `
-        let unused_foo = 'a';
-        const _unused_foo = 1;
-        interface IFoo {}
-        class IBar {}
-        function fooBar() {}
-      `,
-      options: [
         {
-          selector: 'default',
-          format: ['snake_case'],
           custom: {
-            regex: /^unused_\w/.source,
             match: false,
-          },
-          leadingUnderscore: 'allow',
-        },
-        {
-          selector: 'typeLike',
-          format: ['PascalCase'],
-          custom: {
             regex: /^I[A-Z]/.source,
-            match: false,
           },
+          format: ['PascalCase'],
+          selector: 'typeLike',
         },
         {
-          selector: 'function',
-          format: ['camelCase'],
           custom: {
-            regex: /function/.source,
             match: true,
+            regex: /_function_/.source,
           },
+          format: ['snake_case'],
           leadingUnderscore: 'allow',
+          selector: 'function',
         },
       ],
-      errors: [
-        {
-          messageId: 'satisfyCustom',
-          line: 2,
-          data: {
-            type: 'Variable',
-            name: 'unused_foo',
-            regex: '/^unused_\\w/u',
-            regexMatch: 'not match',
-          },
-        },
-        {
-          messageId: 'satisfyCustom',
-          line: 3,
-          data: {
-            type: 'Variable',
-            name: '_unused_foo',
-            regex: '/^unused_\\w/u',
-            regexMatch: 'not match',
-          },
-        },
-        {
-          messageId: 'satisfyCustom',
-          line: 4,
-          data: {
-            type: 'Interface',
-            name: 'IFoo',
-            regex: '/^I[A-Z]/u',
-            regexMatch: 'not match',
-          },
-        },
-        {
-          messageId: 'satisfyCustom',
-          line: 5,
-          data: {
-            type: 'Class',
-            name: 'IBar',
-            regex: '/^I[A-Z]/u',
-            regexMatch: 'not match',
-          },
-        },
+    },
+    {
+      code: `
+        let foo = 'a';
+        const _foo = 1;
+        interface foo {}
+        class bar {}
+        function fooFunctionBar() {}
+        function _fooFunctionBar() {}
+      `,
+      options: [
         {
-          messageId: 'satisfyCustom',
-          line: 6,
-          data: {
-            type: 'Function',
-            name: 'fooBar',
-            regex: '/function/u',
-            regexMatch: 'match',
+          custom: {
+            match: false,
+            regex: /^unused_\w/.source,
           },
+          format: ['camelCase'],
+          leadingUnderscore: 'allow',
+          selector: ['default', 'typeLike', 'function'],
         },
       ],
     },
     {
       code: `
-        let unused_foo = 'a';
-        const _unused_foo = 1;
-        function foo_bar() {}
-        interface IFoo {}
-        class IBar {}
+        const match = 'test'.match(/test/);
+        const [, key, value] = match;
       `,
       options: [
         {
-          selector: ['variable', 'function'],
           format: ['camelCase'],
-          leadingUnderscore: 'allow',
-        },
-        {
-          selector: ['class', 'interface'],
-          format: ['PascalCase'],
-          custom: {
-            regex: /^I[A-Z]/.source,
-            match: false,
-          },
+          selector: 'default',
         },
       ],
-      errors: [
+    },
+    // no format selector
+    {
+      code: 'const snake_case = 1;',
+      options: [
         {
-          messageId: 'doesNotMatchFormat',
-          line: 2,
-          data: {
-            type: 'Variable',
-            name: 'unused_foo',
-            formats: 'camelCase',
-          },
+          format: ['camelCase'],
+          selector: 'default',
         },
         {
-          messageId: 'doesNotMatchFormatTrimmed',
-          line: 3,
-          data: {
-            type: 'Variable',
-            name: '_unused_foo',
-            processedName: 'unused_foo',
-            formats: 'camelCase',
-          },
+          format: null,
+          selector: 'variable',
         },
+      ],
+    },
+    {
+      code: 'const snake_case = 1;',
+      options: [
         {
-          messageId: 'doesNotMatchFormat',
-          line: 4,
-          data: {
-            type: 'Function',
-            name: 'foo_bar',
-            formats: 'camelCase',
-          },
+          format: ['camelCase'],
+          selector: 'default',
         },
         {
-          messageId: 'satisfyCustom',
-          line: 5,
-          data: {
-            type: 'Interface',
-            name: 'IFoo',
-            regex: '/^I[A-Z]/u',
-            regexMatch: 'not match',
-          },
+          format: [],
+          selector: 'variable',
         },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1478
+    {
+      code: `
+        const child_process = require('child_process');
+      `,
+      options: [
+        { format: ['camelCase', 'UPPER_CASE'], selector: 'variable' },
         {
-          messageId: 'satisfyCustom',
-          line: 6,
-          data: {
-            type: 'Class',
-            name: 'IBar',
-            regex: '/^I[A-Z]/u',
-            regexMatch: 'not match',
-          },
+          filter: 'child_process',
+          format: ['snake_case'],
+          selector: 'variable',
         },
       ],
     },
     {
       code: `
         const foo = {
-          'Property Name': 'asdf',
+          'Property-Name': 'asdf',
         };
       `,
       options: [
         {
-          format: ['strictCamelCase'],
-          selector: 'default',
           filter: {
-            regex: /-/.source,
             match: false,
+            regex: /-/.source,
           },
+          format: ['strictCamelCase'],
+          selector: 'default',
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+        const foo = {
+          'Property-Name': 'asdf',
+        };
+      `,
+      options: [
         {
-          line: 3,
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Object Literal Property',
-            name: 'Property Name',
-            formats: 'strictCamelCase',
+          filter: {
+            match: false,
+            regex: /^(Property-Name)$/.source,
           },
+          format: ['strictCamelCase'],
+          selector: 'default',
         },
       ],
     },
     {
       code: `
-        const myfoo_bar = 'abcs';
-        function fun(myfoo: string) {}
+        let isFoo = 1;
         class foo {
-          Myfoo: string;
+          shouldBoo: number;
         }
       `,
+      languageOptions: { parserOptions },
       options: [
         {
-          selector: ['variable', 'property', 'parameter'],
-          types: ['string'],
           format: ['PascalCase'],
-          prefix: ['my', 'My'],
+          prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+          selector: ['variable', 'parameter', 'property', 'accessor'],
+          types: ['number'],
         },
       ],
-      languageOptions: { parserOptions },
-      errors: Array(3).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
       code: `
         class foo {
-          private readonly fooBar: boolean;
+          private readonly FooBoo: boolean;
         }
       `,
+      languageOptions: { parserOptions },
       options: [
         {
-          selector: ['property', 'accessor'],
-          modifiers: ['private', 'readonly'],
           format: ['PascalCase'],
+          modifiers: ['private', 'readonly'],
+          selector: ['property', 'accessor'],
+          types: ['boolean'],
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
-        function my_foo_bar() {}
+        class foo {
+          private fooBoo: number;
+        }
+      `,
+      options: [
+        {
+          format: ['camelCase'],
+          modifiers: ['private'],
+          selector: ['property', 'accessor'],
+        },
+      ],
+    },
+    {
+      code: `
+        const isfooBar = 1;
+        function fun(goodfunFoo: number) {}
+        class foo {
+          private VanFooBar: number;
+        }
       `,
       languageOptions: { parserOptions },
       options: [
         {
-          selector: ['variable', 'function'],
-          types: ['string'],
-          format: ['PascalCase'],
-          prefix: ['my', 'My'],
+          format: ['StrictPascalCase'],
+          modifiers: ['private'],
+          prefix: ['Van'],
+          selector: ['property', 'accessor'],
+        },
+        {
+          format: ['camelCase'],
+          prefix: ['is', 'good'],
+          selector: ['variable', 'parameter'],
+          types: ['number'],
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormatTrimmed' }],
     },
     {
       code: `
         class SomeClass {
-          static otherConstant = 'hello';
+          static OtherConstant = 'hello';
         }
 
-        export const { otherConstant } = SomeClass;
+        export const { OtherConstant: otherConstant } = SomeClass;
       `,
-      languageOptions: { parserOptions },
       options: [
-        { selector: 'property', format: ['PascalCase'] },
-        { selector: 'variable', format: ['camelCase'] },
+        { format: ['PascalCase'], selector: 'property' },
+        { format: ['camelCase'], selector: 'variable' },
       ],
-      errors: [
+    },
+    // treat properties with function expressions as typeMethod
+    {
+      code: `
+        interface SOME_INTERFACE {
+          SomeMethod: () => void;
+
+          some_property: string;
+        }
+      `,
+      options: [
         {
-          line: 3,
-          messageId: 'doesNotMatchFormat',
+          format: ['UPPER_CASE'],
+          selector: 'default',
+        },
+        {
+          format: ['PascalCase'],
+          selector: 'typeMethod',
+        },
+        {
+          format: ['snake_case'],
+          selector: 'typeProperty',
         },
       ],
     },
     {
       code: `
-        declare class Foo {
-          Bar(Baz: string): void;
-        }
+        type Ignored = {
+          ignored_due_to_modifiers: string;
+          readonly FOO: string;
+        };
       `,
       languageOptions: { parserOptions },
-      options: [{ selector: 'parameter', format: ['camelCase'] }],
-      errors: [
+      options: [
         {
-          line: 3,
-          messageId: 'doesNotMatchFormat',
+          format: ['UPPER_CASE'],
+          modifiers: ['readonly'],
+          selector: 'typeProperty',
         },
       ],
     },
     {
       code: `
+        const camelCaseVar = 1;
+        enum camelCaseEnum {}
+        class camelCaseClass {}
+        function camelCaseFunction() {}
+        interface camelCaseInterface {}
+        type camelCaseType = {};
         export const PascalCaseVar = 1;
         export enum PascalCaseEnum {}
         export class PascalCaseClass {}
@@ -1412,45 +1636,47 @@ ruleTester.run('naming-convention', rule, {
         export type PascalCaseType = {};
       `,
       options: [
+        { format: ['camelCase'], selector: 'default' },
         {
-          selector: 'default',
-          format: ['snake_case'],
-        },
-        {
-          selector: 'variable',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'function',
         },
         {
-          selector: 'class',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'class',
         },
         {
-          selector: 'interface',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'interface',
         },
         {
-          selector: 'typeAlias',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'typeAlias',
         },
         {
-          selector: 'enum',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'enum',
         },
       ],
-      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
+        const camelCaseVar = 1;
+        enum camelCaseEnum {}
+        class camelCaseClass {}
+        function camelCaseFunction() {}
+        interface camelCaseInterface {}
+        type camelCaseType = {};
         const PascalCaseVar = 1;
         enum PascalCaseEnum {}
         class PascalCaseClass {}
@@ -1467,81 +1693,101 @@ ruleTester.run('naming-convention', rule, {
         };
       `,
       options: [
-        { selector: 'default', format: ['snake_case'] },
+        { format: ['camelCase'], selector: 'default' },
         {
-          selector: 'variable',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'function',
         },
         {
-          selector: 'class',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'class',
         },
         {
-          selector: 'interface',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'interface',
         },
         {
-          selector: 'typeAlias',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'typeAlias',
         },
         {
-          selector: 'enum',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['exported'],
+          selector: 'enum',
         },
       ],
-      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
+        {
+          const camelCaseVar = 1;
+          function camelCaseFunction() {}
+          declare function camelCaseDeclaredFunction();
+        }
         const PascalCaseVar = 1;
         function PascalCaseFunction() {}
         declare function PascalCaseDeclaredFunction();
       `,
       options: [
-        { selector: 'default', format: ['snake_case'] },
+        { format: ['camelCase'], selector: 'default' },
         {
-          selector: 'variable',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['global'],
+          selector: 'variable',
         },
         {
-          selector: 'function',
-          format: ['camelCase'],
+          format: ['PascalCase'],
           modifiers: ['global'],
+          selector: 'function',
         },
       ],
-      errors: Array(3).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
         const { some_name1 } = {};
+        const { ignore: IgnoredDueToModifiers1 } = {};
         const { some_name2 = 2 } = {};
-        const { ignored: IgnoredDueToModifiers1 } = {};
-        const { ignored: IgnoredDueToModifiers2 = 3 } = {};
-        const IgnoredDueToModifiers3 = 1;
+        const IgnoredDueToModifiers2 = 1;
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
+          format: ['snake_case'],
+          modifiers: ['destructured'],
           selector: 'variable',
-          format: ['UPPER_CASE'],
+        },
+      ],
+    },
+    {
+      code: `
+        const { some_name1 } = {};
+        const { ignore: IgnoredDueToModifiers1 } = {};
+        const { some_name2 = 2 } = {};
+        const IgnoredDueToModifiers2 = 1;
+      `,
+      options: [
+        {
+          format: ['PascalCase'],
+          selector: 'default',
+        },
+        {
+          format: null,
           modifiers: ['destructured'],
+          selector: 'variable',
         },
       ],
-      errors: Array(2).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
@@ -1555,16 +1801,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'parameter',
+          format: ['camelCase'],
           modifiers: ['destructured'],
-          format: ['UPPER_CASE'],
+          selector: 'parameter',
         },
       ],
-      errors: Array(2).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
@@ -1575,16 +1820,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'classProperty',
-          format: ['UPPER_CASE'],
+          format: ['snake_case'],
           modifiers: ['static', 'readonly'],
+          selector: 'classProperty',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
@@ -1597,16 +1841,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'parameterProperty',
-          format: ['UPPER_CASE'],
+          format: ['snake_case'],
           modifiers: ['readonly'],
+          selector: 'parameterProperty',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
@@ -1617,16 +1860,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'classMethod',
-          format: ['UPPER_CASE'],
+          format: ['snake_case'],
           modifiers: ['abstract', 'static'],
+          selector: 'classMethod',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
@@ -1637,16 +1879,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'accessor',
-          format: ['UPPER_CASE'],
+          format: ['snake_case'],
           modifiers: ['private', 'static'],
+          selector: 'accessor',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
@@ -1655,16 +1896,15 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['PascalCase'],
+          selector: 'default',
         },
         {
-          selector: 'class',
-          format: ['UPPER_CASE'],
+          format: ['snake_case'],
           modifiers: ['abstract'],
+          selector: 'class',
         },
       ],
-      errors: [{ messageId: 'doesNotMatchFormat' }],
     },
     {
       code: `
@@ -1679,19 +1919,32 @@ ruleTester.run('naming-convention', rule, {
           // this line is intentionally broken out
           UnusedTypeParam,
         > = {};
+
+        export const used_var = 1;
+        export function used_func(
+          // this line is intentionally broken out
+          used_param: string,
+        ) {
+          return used_param;
+        }
+        export class used_class {}
+        export interface used_interface {}
+        export type used_type<
+          // this line is intentionally broken out
+          used_typeparam,
+        > = used_typeparam;
       `,
       options: [
         {
+          format: ['snake_case'],
           selector: 'default',
-          format: ['PascalCase'],
         },
         {
-          selector: 'default',
+          format: ['PascalCase'],
           modifiers: ['unused'],
-          format: ['snake_case'],
+          selector: 'default',
         },
       ],
-      errors: Array(7).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
@@ -1725,311 +1978,129 @@ ruleTester.run('naming-convention', rule, {
       `,
       options: [
         {
-          selector: 'default',
           format: ['snake_case'],
+          selector: 'default',
         },
         {
-          selector: 'default',
-          format: ['PascalCase'],
+          format: null,
           modifiers: ['requiresQuotes'],
+          selector: 'default',
         },
       ],
-      errors: Array(13).fill({ messageId: 'doesNotMatchFormat' }),
-    },
-    {
-      code: noFormat`
-        type Foo = {
-          'foo     Bar': string;
-          '': string;
-          '0': string;
-          'foo': string;
-          'foo-bar': string;
-          '#foo-bar': string;
-        };
-
-        interface Bar {
-          'boo-----foo': string;
-        }
-      `,
-      // 6, not 7 because 'foo' is valid
-      errors: Array(6).fill({ messageId: 'doesNotMatchFormat' }),
     },
     {
       code: `
-        class foo {
-          public Bar() {
-            return 42;
-          }
-          public async async_bar() {
-            return 42;
-          }
-          // ❌ error
-          public async asyncBar() {
-            return 42;
+        const ignored1 = {
+          'a a': 1,
+          'b b'() {},
+          get 'c c'() {
+            return 1;
+          },
+          set 'd d'(value: string) {},
+        };
+        class ignored2 {
+          'a a' = 1;
+          'b b'() {}
+          get 'c c'() {
+            return 1;
           }
-          // ❌ error
-          public AsyncBar2 = async () => {
-            return 42;
-          };
-          // ❌ error
-          public AsyncBar3 = async function () {
-            return 42;
-          };
+          set 'd d'(value: string) {}
         }
-        abstract class foo {
-          public abstract Bar(): number;
-          public abstract async async_bar(): number;
-          // ❌ error
-          public abstract async ASYNC_BAR(): number;
+        interface ignored3 {
+          'a a': 1;
+          'b b'(): void;
         }
-      `,
-      languageOptions: { parserOptions },
-      options: [
-        {
-          selector: 'memberLike',
-          format: ['camelCase'],
-        },
-        {
-          selector: 'method',
-          format: ['PascalCase'],
-        },
-        {
-          selector: ['method', 'objectLiteralMethod'],
-          format: ['snake_case'],
-          modifiers: ['async'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'asyncBar',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'AsyncBar2',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'AsyncBar3',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'ASYNC_BAR',
-            formats: 'snake_case',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-        const obj = {
-          Bar() {
-            return 42;
-          },
-          async async_bar() {
-            return 42;
-          },
-          // ❌ error
-          async AsyncBar() {
-            return 42;
-          },
-          // ❌ error
-          AsyncBar2: async () => {
-            return 42;
-          },
-          // ❌ error
-          AsyncBar3: async function () {
-            return 42;
-          },
+        type ignored4 = {
+          'a a': 1;
+          'b b'(): void;
         };
+        enum ignored5 {
+          'a a',
+        }
       `,
-      languageOptions: { parserOptions },
-      options: [
-        {
-          selector: 'memberLike',
-          format: ['camelCase'],
-        },
-        {
-          selector: 'method',
-          format: ['PascalCase'],
-        },
-        {
-          selector: ['method', 'objectLiteralMethod'],
-          format: ['snake_case'],
-          modifiers: ['async'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Object Literal Method',
-            name: 'AsyncBar',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Object Literal Method',
-            name: 'AsyncBar2',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Object Literal Method',
-            name: 'AsyncBar3',
-            formats: 'snake_case',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-        const syncbar1 = () => {};
-        function syncBar2() {}
-        const syncBar3 = function syncBar4() {};
-
-        // ❌ error
-        const AsyncBar1 = async () => {};
-        const async_bar1 = async () => {};
-        const async_bar3 = async function async_bar4() {};
-        async function async_bar2() {}
-        // ❌ error
-        const asyncBar5 = async function async_bar6() {};
-      `,
-      languageOptions: { parserOptions },
-      options: [
-        {
-          selector: 'variableLike',
-          format: ['camelCase'],
-        },
-        {
-          selector: ['variableLike'],
-          modifiers: ['async'],
-          format: ['snake_case'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Variable',
-            name: 'AsyncBar1',
-            formats: 'snake_case',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Variable',
-            name: 'asyncBar5',
-            formats: 'snake_case',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-        const syncbar1 = () => {};
-        function syncBar2() {}
-        const syncBar3 = function syncBar4() {};
-
-        const async_bar1 = async () => {};
-        // ❌ error
-        async function asyncBar2() {}
-        const async_bar3 = async function async_bar4() {};
-        async function async_bar2() {}
-        // ❌ error
-        const async_bar3 = async function ASYNC_BAR4() {};
-      `,
-      languageOptions: { parserOptions },
       options: [
         {
-          selector: 'variableLike',
-          format: ['camelCase'],
-        },
-        {
-          selector: ['variableLike'],
-          modifiers: ['async'],
           format: ['snake_case'],
+          selector: 'default',
         },
-      ],
-      errors: [
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Function',
-            name: 'asyncBar2',
-            formats: 'snake_case',
-          },
+          format: null,
+          modifiers: ['requiresQuotes'],
+          selector: [
+            'classProperty',
+            'objectLiteralProperty',
+            'typeProperty',
+            'classMethod',
+            'objectLiteralMethod',
+            'typeMethod',
+            'accessor',
+            'enumMember',
+          ],
         },
+        // making sure the `requoresQuotes` modifier appropriately overrides this
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Function',
-            name: 'ASYNC_BAR4',
-            formats: 'snake_case',
-          },
+          format: ['PascalCase'],
+          selector: [
+            'classProperty',
+            'objectLiteralProperty',
+            'typeProperty',
+            'classMethod',
+            'objectLiteralMethod',
+            'typeMethod',
+            'accessor',
+            'enumMember',
+          ],
         },
       ],
     },
     {
       code: `
-        class foo extends bar {
-          public someAttribute = 1;
-          public override some_attribute_override = 1;
-          // ❌ error
-          public override someAttributeOverride = 1;
-        }
+        const obj = {
+          Foo: 42,
+          Bar() {
+            return 42;
+          },
+        };
       `,
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['override'],
-          format: ['snake_case'],
+          format: ['PascalCase'],
+          selector: 'property',
         },
-      ],
-      errors: [
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Property',
-            name: 'someAttributeOverride',
-            formats: 'snake_case',
-          },
+          format: ['PascalCase'],
+          selector: 'method',
         },
       ],
     },
     {
       code: `
-        class foo extends bar {
-          public override some_method_override() {
+        const obj = {
+          Bar() {
+            return 42;
+          },
+          async async_bar() {
+            return 42;
+          },
+        };
+        class foo {
+          public Bar() {
             return 42;
           }
-          // ❌ error
-          public override someMethodOverride() {
+          public async async_bar() {
+            return 42;
+          }
+        }
+        abstract class foo {
+          public abstract Bar() {
+            return 42;
+          }
+          public abstract async async_bar() {
             return 42;
           }
         }
@@ -2037,226 +2108,155 @@ ruleTester.run('naming-convention', rule, {
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['override'],
           format: ['snake_case'],
+          modifiers: ['async'],
+          selector: ['method', 'objectLiteralMethod'],
         },
-      ],
-      errors: [
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'someMethodOverride',
-            formats: 'snake_case',
-          },
+          format: ['PascalCase'],
+          selector: 'method',
         },
       ],
     },
     {
       code: `
-        class foo extends bar {
-          public get someGetter(): string;
-          public override get some_getter_override(): string;
-          // ❌ error
-          public override get someGetterOverride(): string;
-          public set someSetter(val: string);
-          public override set some_setter_override(val: string);
-          // ❌ error
-          public override set someSetterOverride(val: string);
-        }
+        const async_bar1 = async () => {};
+        async function async_bar2() {}
+        const async_bar3 = async function async_bar4() {};
       `,
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['override'],
-          format: ['snake_case'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Classic Accessor',
-            name: 'someGetterOverride',
-            formats: 'snake_case',
-          },
+          format: ['PascalCase'],
+          selector: 'method',
         },
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Classic Accessor',
-            name: 'someSetterOverride',
-            formats: 'snake_case',
-          },
+          format: ['snake_case'],
+          modifiers: ['async'],
+          selector: ['variable'],
         },
       ],
     },
     {
       code: `
-        class foo {
-          private firstPrivateField = 1;
-          // ❌ error
-          private first_private_field = 1;
-          // ❌ error
-          #secondPrivateField = 1;
-          #second_private_field = 1;
+        class foo extends bar {
+          public someAttribute = 1;
+          public override some_attribute_override = 1;
+          public someMethod() {
+            return 42;
+          }
+          public override some_method_override2() {
+            return 42;
+          }
+        }
+        abstract class foo extends bar {
+          public abstract someAttribute: string;
+          public abstract override some_attribute_override: string;
+          public abstract someMethod(): string;
+          public abstract override some_method_override2(): string;
         }
       `,
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['#private'],
           format: ['snake_case'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Property',
-            name: 'first_private_field',
-            formats: 'camelCase',
-          },
-        },
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Property',
-            name: 'secondPrivateField',
-            formats: 'snake_case',
-          },
+          modifiers: ['override'],
+          selector: ['memberLike'],
         },
       ],
     },
     {
       code: `
         class foo {
-          private firstPrivateMethod() {}
-          // ❌ error
-          private first_private_method() {}
-          // ❌ error
-          #secondPrivateMethod() {}
-          #second_private_method() {}
+          private someAttribute = 1;
+          #some_attribute = 1;
+
+          private someMethod() {}
+          #some_method() {}
         }
       `,
       languageOptions: { parserOptions },
       options: [
         {
-          selector: 'memberLike',
           format: ['camelCase'],
+          selector: 'memberLike',
         },
         {
-          selector: ['memberLike'],
-          modifiers: ['#private'],
           format: ['snake_case'],
+          modifiers: ['#private'],
+          selector: ['memberLike'],
         },
       ],
-      errors: [
+    },
+    {
+      code: "import * as FooBar from 'foo_bar';",
+      languageOptions: { parserOptions },
+      options: [
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'first_private_method',
-            formats: 'camelCase',
-          },
+          format: ['PascalCase'],
+          selector: ['import'],
         },
         {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Class Method',
-            name: 'secondPrivateMethod',
-            formats: 'snake_case',
-          },
+          format: ['camelCase'],
+          modifiers: ['default'],
+          selector: ['import'],
         },
       ],
     },
     {
-      code: "import * as fooBar from 'foo_bar';",
+      code: "import fooBar from 'foo_bar';",
       languageOptions: { parserOptions },
       options: [
         {
+          format: ['PascalCase'],
           selector: ['import'],
-          format: ['camelCase'],
         },
         {
+          format: ['camelCase'],
+          modifiers: ['default'],
           selector: ['import'],
-          modifiers: ['namespace'],
-          format: ['PascalCase'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Import',
-            name: 'fooBar',
-            formats: 'PascalCase',
-          },
         },
       ],
     },
     {
-      code: "import FooBar from 'foo_bar';",
+      code: "import { default as fooBar } from 'foo_bar';",
       languageOptions: { parserOptions },
       options: [
         {
+          format: ['PascalCase'],
           selector: ['import'],
-          format: ['camelCase'],
         },
         {
+          format: ['camelCase'],
+          modifiers: ['default'],
           selector: ['import'],
-          modifiers: ['namespace'],
-          format: ['PascalCase'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Import',
-            name: 'FooBar',
-            formats: 'camelCase',
-          },
         },
       ],
     },
     {
-      code: "import { default as foo_bar } from 'foo_bar';",
+      code: "import { foo_bar } from 'foo_bar';",
       languageOptions: { parserOptions },
       options: [
         {
+          format: ['PascalCase'],
           selector: ['import'],
-          format: ['camelCase'],
         },
         {
+          format: ['camelCase'],
+          modifiers: ['default'],
           selector: ['import'],
-          modifiers: ['namespace'],
-          format: ['PascalCase'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'doesNotMatchFormat',
-          data: {
-            type: 'Import',
-            name: 'foo_bar',
-            formats: 'camelCase',
-          },
         },
       ],
     },
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 05d56823bdad..d696be8f093f 100644
--- a/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
@@ -8,102 +8,70 @@ const ruleTester = new RuleTester();
 const messageId = 'useLiteral';
 
 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();',
-
-    // TypeScript
-    '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);',
-  ],
-
   invalid: [
     {
       code: 'new Array();',
-      output: '[];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.NewExpression,
         },
       ],
+      output: '[];',
     },
     {
       code: 'Array();',
-      output: '[];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.CallExpression,
         },
       ],
+      output: '[];',
     },
     {
       code: 'new Array(x, y);',
-      output: '[x, y];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.NewExpression,
         },
       ],
+      output: '[x, y];',
     },
     {
       code: 'Array(x, y);',
-      output: '[x, y];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.CallExpression,
         },
       ],
+      output: '[x, y];',
     },
     {
       code: 'new Array(0, 1, 2);',
-      output: '[0, 1, 2];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.NewExpression,
         },
       ],
+      output: '[0, 1, 2];',
     },
     {
       code: 'Array(0, 1, 2);',
-      output: '[0, 1, 2];',
       errors: [
         {
           messageId,
           type: AST_NODE_TYPES.CallExpression,
         },
       ],
+      output: '[0, 1, 2];',
     },
     {
       code: `
 new Array(0, 1, 2);
-      `,
-      output: `
-[0, 1, 2];
       `,
       errors: [
         {
@@ -111,6 +79,38 @@ new Array(0, 1, 2);
           type: AST_NODE_TYPES.NewExpression,
         },
       ],
+      output: `
+[0, 1, 2];
+      `,
     },
   ],
+
+  valid: [
+    '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>();',
+
+    // 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);',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-array-delete.test.ts b/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
index ed5a7cba7c65..4279a4750c12 100644
--- a/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
@@ -8,55 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('no-array-delete', rule, {
-  valid: [
-    `
-      declare const obj: { a: 1; b: 2 };
-      delete obj.a;
-    `,
-
-    `
-      declare const obj: { a: 1; b: 2 };
-      delete obj['a'];
-    `,
-
-    `
-      declare const arr: { a: 1; b: 2 }[][][][];
-      delete arr[0][0][0][0].a;
-    `,
-
-    `
-      declare const maybeArray: any;
-      delete maybeArray[0];
-    `,
-
-    `
-      declare const maybeArray: unknown;
-      delete maybeArray[0];
-    `,
-
-    `
-      declare function getObject<T extends { a: 1; b: 2 }>(): T;
-      delete getObject().a;
-    `,
-
-    `
-      declare function getObject<T extends number>(): { a: T; b: 2 };
-      delete getObject().a;
-    `,
-
-    `
-      declare const test: never;
-      delete test[0];
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -65,10 +23,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -90,10 +48,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 4,
           column: 9,
           endColumn: 24,
+          line: 4,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -121,10 +79,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 9,
           column: 9,
           endColumn: 27,
+          line: 9,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -152,10 +110,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 4,
           column: 9,
           endColumn: 34,
+          line: 4,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -178,10 +136,10 @@ ruleTester.run('no-array-delete', rule, {
 
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -199,10 +157,10 @@ ruleTester.run('no-array-delete', rule, {
       code: 'delete [1, 2, 3][0];',
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 1,
           column: 1,
           endColumn: 20,
+          line: 1,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -220,10 +178,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 42,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -244,10 +202,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -268,10 +226,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -292,10 +250,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -316,10 +274,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 28,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -340,10 +298,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 29,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -364,10 +322,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 29,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -389,10 +347,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 11,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -415,10 +373,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 11,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -441,10 +399,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 11,
           endColumn: 22,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -466,10 +424,10 @@ ruleTester.run('no-array-delete', rule, {
       `,
       errors: [
         {
-          messageId: 'noArrayDelete',
-          line: 3,
           column: 9,
           endColumn: 24,
+          line: 3,
+          messageId: 'noArrayDelete',
           suggestions: [
             {
               messageId: 'useSplice',
@@ -597,4 +555,46 @@ ruleTester.run('no-array-delete', rule, {
       ],
     },
   ],
+
+  valid: [
+    `
+      declare const obj: { a: 1; b: 2 };
+      delete obj.a;
+    `,
+
+    `
+      declare const obj: { a: 1; b: 2 };
+      delete obj['a'];
+    `,
+
+    `
+      declare const arr: { a: 1; b: 2 }[][][][];
+      delete arr[0][0][0][0].a;
+    `,
+
+    `
+      declare const maybeArray: any;
+      delete maybeArray[0];
+    `,
+
+    `
+      declare const maybeArray: unknown;
+      delete maybeArray[0];
+    `,
+
+    `
+      declare function getObject<T extends { a: 1; b: 2 }>(): T;
+      delete getObject().a;
+    `,
+
+    `
+      declare function getObject<T extends number>(): { a: T; b: 2 };
+      delete getObject().a;
+    `,
+
+    `
+      declare const test: never;
+      delete test[0];
+    `,
+  ],
 });
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 67c2a7ebddaa..e01eb9ca5d77 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
@@ -7,8 +7,8 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
@@ -39,86 +39,6 @@ const literalListWrapped = [
 ];
 
 ruleTester.run('no-base-to-string', rule, {
-  valid: [
-    // template
-    ...literalList.map(i => `\`\${${i}}\`;`),
-
-    // operator + +=
-    ...literalListWrapped
-      .map(l => literalListWrapped.map(r => `${l} + ${r};`))
-      .reduce((pre, cur) => [...pre, ...cur]),
-
-    // toString()
-    ...literalListWrapped.map(i => `${i === '1' ? `(${i})` : i}.toString();`),
-
-    // variable toString() and template
-    ...literalList.map(
-      i => `
-        let value = ${i};
-        value.toString();
-        let text = \`\${value}\`;
-      `,
-    ),
-
-    `
-function someFunction() {}
-someFunction.toString();
-let text = \`\${someFunction}\`;
-    `,
-    'unknownObject.toString();',
-    'unknownObject.someOtherMethod();',
-    `
-class CustomToString {
-  toString() {
-    return 'Hello, world!';
-  }
-}
-'' + new CustomToString();
-    `,
-    `
-const literalWithToString = {
-  toString: () => 'Hello, world!',
-};
-'' + literalToString;
-    `,
-    `
-const printer = (inVar: string | number | boolean) => {
-  inVar.toString();
-};
-printer('');
-printer(1);
-printer(true);
-    `,
-    'let _ = {} * {};',
-    'let _ = {} / {};',
-    'let _ = ({} *= {});',
-    'let _ = ({} /= {});',
-    'let _ = ({} = {});',
-    'let _ = {} == {};',
-    'let _ = {} === {};',
-    'let _ = {} in {};',
-    'let _ = {} & {};',
-    'let _ = {} ^ {};',
-    'let _ = {} << {};',
-    'let _ = {} >> {};',
-    `
-function tag() {}
-tag\`\${{}}\`;
-    `,
-    `
-      function tag() {}
-      tag\`\${{}}\`;
-    `,
-    `
-      interface Brand {}
-      function test(v: string & Brand): string {
-        return \`\${v}\`;
-      }
-    `,
-    "'' += new Error();",
-    "'' += new URL();",
-    "'' += new URLSearchParams();",
-  ],
   invalid: [
     {
       code: '`${{}})`;',
@@ -247,4 +167,84 @@ tag\`\${{}}\`;
       ],
     },
   ],
+  valid: [
+    // template
+    ...literalList.map(i => `\`\${${i}}\`;`),
+
+    // operator + +=
+    ...literalListWrapped
+      .map(l => literalListWrapped.map(r => `${l} + ${r};`))
+      .reduce((pre, cur) => [...pre, ...cur]),
+
+    // toString()
+    ...literalListWrapped.map(i => `${i === '1' ? `(${i})` : i}.toString();`),
+
+    // variable toString() and template
+    ...literalList.map(
+      i => `
+        let value = ${i};
+        value.toString();
+        let text = \`\${value}\`;
+      `,
+    ),
+
+    `
+function someFunction() {}
+someFunction.toString();
+let text = \`\${someFunction}\`;
+    `,
+    'unknownObject.toString();',
+    'unknownObject.someOtherMethod();',
+    `
+class CustomToString {
+  toString() {
+    return 'Hello, world!';
+  }
+}
+'' + new CustomToString();
+    `,
+    `
+const literalWithToString = {
+  toString: () => 'Hello, world!',
+};
+'' + literalToString;
+    `,
+    `
+const printer = (inVar: string | number | boolean) => {
+  inVar.toString();
+};
+printer('');
+printer(1);
+printer(true);
+    `,
+    'let _ = {} * {};',
+    'let _ = {} / {};',
+    'let _ = ({} *= {});',
+    'let _ = ({} /= {});',
+    'let _ = ({} = {});',
+    'let _ = {} == {};',
+    'let _ = {} === {};',
+    'let _ = {} in {};',
+    'let _ = {} & {};',
+    'let _ = {} ^ {};',
+    'let _ = {} << {};',
+    'let _ = {} >> {};',
+    `
+function tag() {}
+tag\`\${{}}\`;
+    `,
+    `
+      function tag() {}
+      tag\`\${{}}\`;
+    `,
+    `
+      interface Brand {}
+      function test(v: string & Brand): string {
+        return \`\${v}\`;
+      }
+    `,
+    "'' += new Error();",
+    "'' += new URL();",
+    "'' += new URLSearchParams();",
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
index 19f3cfec601d..7fe5698308a0 100644
--- a/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
@@ -10,23 +10,14 @@ import rule from '../../src/rules/no-confusing-non-null-assertion';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-confusing-non-null-assertion', rule, {
-  valid: [
-    //
-    'a == b!;',
-    'a = b!;',
-    'a !== b;',
-    'a != b;',
-    '(a + b!) == c;',
-    '(a + b!) = c;',
-  ],
   invalid: [
     {
       code: 'a! == b;',
       errors: [
         {
-          messageId: 'confusingEqual',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingEqual',
           suggestions: [
             {
               messageId: 'notNeedInEqualTest',
@@ -40,9 +31,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: 'a! === b;',
       errors: [
         {
-          messageId: 'confusingEqual',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingEqual',
           suggestions: [
             {
               messageId: 'notNeedInEqualTest',
@@ -56,9 +47,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: 'a + b! == c;',
       errors: [
         {
-          messageId: 'confusingEqual',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingEqual',
           suggestions: [
             {
               messageId: 'wrapUpLeft',
@@ -72,9 +63,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: '(obj = new new OuterObj().InnerObj).Name! == c;',
       errors: [
         {
-          messageId: 'confusingEqual',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingEqual',
           suggestions: [
             {
               messageId: 'notNeedInEqualTest',
@@ -88,9 +79,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: '(a==b)! ==c;',
       errors: [
         {
-          messageId: 'confusingEqual',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingEqual',
           suggestions: [
             {
               messageId: 'notNeedInEqualTest',
@@ -104,9 +95,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: 'a! = b;',
       errors: [
         {
-          messageId: 'confusingAssign',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingAssign',
           suggestions: [
             {
               messageId: 'notNeedInAssign',
@@ -120,9 +111,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: '(obj = new new OuterObj().InnerObj).Name! = c;',
       errors: [
         {
-          messageId: 'confusingAssign',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingAssign',
           suggestions: [
             {
               messageId: 'notNeedInAssign',
@@ -136,9 +127,9 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       code: '(a=b)! =c;',
       errors: [
         {
-          messageId: 'confusingAssign',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'confusingAssign',
           suggestions: [
             {
               messageId: 'notNeedInAssign',
@@ -149,4 +140,13 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       ],
     },
   ],
+  valid: [
+    //
+    'a == b!;',
+    'a = b!;',
+    'a !== b;',
+    'a != b;',
+    '(a + b!) == c;',
+    '(a + b!) = c;',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
index 24301c213bce..d2fb35ebef74 100644
--- a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
@@ -7,191 +7,83 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('no-confusing-void-expression', rule, {
-  valid: [
-    '() => Math.random();',
-    "console.log('foo');",
-    'foo && console.log(foo);',
-    'foo || console.log(foo);',
-    'foo ? console.log(true) : console.log(false);',
-    "console?.log('foo');",
-
-    {
-      options: [{ ignoreArrowShorthand: true }],
-      code: `
-        () => console.log('foo');
-      `,
-    },
-    {
-      options: [{ ignoreArrowShorthand: true }],
-      code: `
-        foo => foo && console.log(foo);
-      `,
-    },
-    {
-      options: [{ ignoreArrowShorthand: true }],
-      code: `
-        foo => foo || console.log(foo);
-      `,
-    },
-    {
-      options: [{ ignoreArrowShorthand: true }],
-      code: `
-        foo => (foo ? console.log(true) : console.log(false));
-      `,
-    },
-
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        !void console.log('foo');
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        +void (foo && console.log(foo));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        -void (foo || console.log(foo));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        () => void ((foo && void console.log(true)) || console.log(false));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        const x = void (foo ? console.log(true) : console.log(false));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        !(foo && void console.log(foo));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        !!(foo || void console.log(foo));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        const x = (foo && void console.log(true)) || void console.log(false);
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        () => (foo ? void console.log(true) : void console.log(false));
-      `,
-    },
-    {
-      options: [{ ignoreVoidOperator: true }],
-      code: `
-        return void console.log('foo');
-      `,
-    },
-
-    `
-function cool(input: string) {
-  return console.log(input), input;
-}
-    `,
-    {
-      code: `
-function cool(input: string) {
-  return input, console.log(input), input;
-}
-      `,
-    },
-  ],
-
   invalid: [
     {
       code: `
         const x = console.log('foo');
       `,
-      output: null,
       errors: [{ column: 19, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         const x = console?.log('foo');
       `,
-      output: null,
       errors: [{ column: 19, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         console.error(console.log('foo'));
       `,
-      output: null,
       errors: [{ column: 23, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         [console.log('foo')];
       `,
-      output: null,
       errors: [{ column: 10, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         ({ x: console.log('foo') });
       `,
-      output: null,
       errors: [{ column: 15, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         void console.log('foo');
       `,
-      output: null,
       errors: [{ column: 14, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         console.log('foo') ? true : false;
       `,
-      output: null,
       errors: [{ column: 9, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         (console.log('foo') && true) || false;
       `,
-      output: null,
       errors: [{ column: 10, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         (cond && console.log('ok')) || console.log('error');
       `,
-      output: null,
       errors: [{ column: 18, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
     {
       code: `
         !console.log('foo');
       `,
-      output: null,
       errors: [{ column: 10, messageId: 'invalidVoidExpr' }],
+      output: null,
     },
 
     {
@@ -200,44 +92,44 @@ function notcool(input: string) {
   return input, console.log(input);
 }
       `,
+      errors: [{ column: 17, line: 3, messageId: 'invalidVoidExpr' }],
       output: null,
-      errors: [{ line: 3, column: 17, messageId: 'invalidVoidExpr' }],
     },
     {
       code: "() => console.log('foo');",
-      errors: [{ line: 1, column: 7, messageId: 'invalidVoidExprArrow' }],
+      errors: [{ column: 7, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: `() => { console.log('foo'); };`,
     },
     {
       code: 'foo => foo && console.log(foo);',
+      errors: [{ column: 15, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: null,
-      errors: [{ line: 1, column: 15, messageId: 'invalidVoidExprArrow' }],
     },
     {
       code: '(foo: undefined) => foo && console.log(foo);',
-      errors: [{ line: 1, column: 28, messageId: 'invalidVoidExprArrow' }],
+      errors: [{ column: 28, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: `(foo: undefined) => { foo && console.log(foo); };`,
     },
     {
       code: 'foo => foo || console.log(foo);',
+      errors: [{ column: 15, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: null,
-      errors: [{ line: 1, column: 15, messageId: 'invalidVoidExprArrow' }],
     },
     {
       code: '(foo: undefined) => foo || console.log(foo);',
-      errors: [{ line: 1, column: 28, messageId: 'invalidVoidExprArrow' }],
+      errors: [{ column: 28, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: `(foo: undefined) => { foo || console.log(foo); };`,
     },
     {
       code: '(foo: void) => foo || console.log(foo);',
-      errors: [{ line: 1, column: 23, messageId: 'invalidVoidExprArrow' }],
+      errors: [{ column: 23, line: 1, messageId: 'invalidVoidExprArrow' }],
       output: `(foo: void) => { foo || console.log(foo); };`,
     },
     {
       code: 'foo => (foo ? console.log(true) : console.log(false));',
       errors: [
-        { line: 1, column: 15, messageId: 'invalidVoidExprArrow' },
-        { line: 1, column: 35, messageId: 'invalidVoidExprArrow' },
+        { column: 15, line: 1, messageId: 'invalidVoidExprArrow' },
+        { column: 35, line: 1, messageId: 'invalidVoidExprArrow' },
       ],
       output: `foo => { foo ? console.log(true) : console.log(false); };`,
     },
@@ -248,7 +140,7 @@ function notcool(input: string) {
           console.log('bar');
         }
       `,
-      errors: [{ line: 3, column: 18, messageId: 'invalidVoidExprReturn' }],
+      errors: [{ column: 18, line: 3, messageId: 'invalidVoidExprReturn' }],
       output: `
         function f() {
           console.log('foo'); return;
@@ -264,7 +156,7 @@ function notcool(input: string) {
           console.log('quux')
         }
       `,
-      errors: [{ line: 4, column: 18, messageId: 'invalidVoidExprReturn' }],
+      errors: [{ column: 18, line: 4, messageId: 'invalidVoidExprReturn' }],
       output: `
         function f() {
           console.log('foo')
@@ -280,7 +172,7 @@ function notcool(input: string) {
           return console.log('bar');
         }
       `,
-      errors: [{ line: 4, column: 18, messageId: 'invalidVoidExprReturnLast' }],
+      errors: [{ column: 18, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: `
         function f() {
           console.log('foo');
@@ -295,7 +187,7 @@ function notcool(input: string) {
           return ['bar', 'baz'].forEach(console.log)
         }
       `,
-      errors: [{ line: 4, column: 18, messageId: 'invalidVoidExprReturnLast' }],
+      errors: [{ column: 18, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: `
         function f() {
           console.log('foo')
@@ -312,7 +204,7 @@ function notcool(input: string) {
           console.log('bar');
         };
       `,
-      errors: [{ line: 4, column: 20, messageId: 'invalidVoidExprReturn' }],
+      errors: [{ column: 20, line: 4, messageId: 'invalidVoidExprReturn' }],
       output: `
         const f = () => {
           if (cond) {
@@ -329,7 +221,7 @@ function notcool(input: string) {
           console.log('bar');
         };
       `,
-      errors: [{ line: 3, column: 28, messageId: 'invalidVoidExprReturn' }],
+      errors: [{ column: 28, line: 3, messageId: 'invalidVoidExprReturn' }],
       output: `
         const f = function () {
           if (cond) { console.error('foo'); return; }
@@ -344,8 +236,8 @@ function notcool(input: string) {
           return num ? console.log('foo') : num;
         };
       `,
+      errors: [{ column: 24, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: null,
-      errors: [{ line: 4, column: 24, messageId: 'invalidVoidExprReturnLast' }],
     },
     {
       code: `
@@ -354,7 +246,7 @@ function notcool(input: string) {
           return undef ? console.log('foo') : undef;
         };
       `,
-      errors: [{ line: 4, column: 26, messageId: 'invalidVoidExprReturnLast' }],
+      errors: [{ column: 26, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: `
         const f = function () {
           let undef = undefined;
@@ -369,8 +261,8 @@ function notcool(input: string) {
           return num || console.log('foo');
         };
       `,
+      errors: [{ column: 25, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: null,
-      errors: [{ line: 4, column: 25, messageId: 'invalidVoidExprReturnLast' }],
     },
     {
       code: `
@@ -379,7 +271,7 @@ function notcool(input: string) {
           return bar || console.log('foo');
         };
       `,
-      errors: [{ line: 4, column: 25, messageId: 'invalidVoidExprReturnLast' }],
+      errors: [{ column: 25, line: 4, messageId: 'invalidVoidExprReturnLast' }],
       output: `
         const f = function () {
           let bar = void 0;
@@ -392,36 +284,34 @@ function notcool(input: string) {
         let num = 1;
         const foo = () => (num ? console.log('foo') : num);
       `,
+      errors: [{ column: 34, line: 3, messageId: 'invalidVoidExprArrow' }],
       output: null,
-      errors: [{ line: 3, column: 34, messageId: 'invalidVoidExprArrow' }],
     },
     {
       code: `
         let bar = void 0;
         const foo = () => (bar ? console.log('foo') : bar);
       `,
-      errors: [{ line: 3, column: 34, messageId: 'invalidVoidExprArrow' }],
+      errors: [{ column: 34, line: 3, messageId: 'invalidVoidExprArrow' }],
       output: `
         let bar = void 0;
         const foo = () => { bar ? console.log('foo') : bar; };
       `,
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: "return console.log('foo');",
       errors: [
-        { line: 1, column: 8, messageId: 'invalidVoidExprReturnWrapVoid' },
+        { column: 8, line: 1, messageId: 'invalidVoidExprReturnWrapVoid' },
       ],
+      options: [{ ignoreVoidOperator: true }],
       output: "return void console.log('foo');",
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: "console.error(console.log('foo'));",
-      output: null,
       errors: [
         {
-          line: 1,
           column: 15,
+          line: 1,
           messageId: 'invalidVoidExprWrapVoid',
           suggestions: [
             {
@@ -431,15 +321,15 @@ function notcool(input: string) {
           ],
         },
       ],
+      options: [{ ignoreVoidOperator: true }],
+      output: null,
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: "console.log('foo') ? true : false;",
-      output: null,
       errors: [
         {
-          line: 1,
           column: 1,
+          line: 1,
           messageId: 'invalidVoidExprWrapVoid',
           suggestions: [
             {
@@ -449,15 +339,15 @@ function notcool(input: string) {
           ],
         },
       ],
+      options: [{ ignoreVoidOperator: true }],
+      output: null,
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: "const x = foo ?? console.log('foo');",
-      output: null,
       errors: [
         {
-          line: 1,
           column: 18,
+          line: 1,
           messageId: 'invalidVoidExprWrapVoid',
           suggestions: [
             {
@@ -467,23 +357,23 @@ function notcool(input: string) {
           ],
         },
       ],
+      options: [{ ignoreVoidOperator: true }],
+      output: null,
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: 'foo => foo || console.log(foo);',
       errors: [
-        { line: 1, column: 15, messageId: 'invalidVoidExprArrowWrapVoid' },
+        { column: 15, line: 1, messageId: 'invalidVoidExprArrowWrapVoid' },
       ],
+      options: [{ ignoreVoidOperator: true }],
       output: 'foo => foo || void console.log(foo);',
     },
     {
-      options: [{ ignoreVoidOperator: true }],
       code: "!!console.log('foo');",
-      output: null,
       errors: [
         {
-          line: 1,
           column: 3,
+          line: 1,
           messageId: 'invalidVoidExprWrapVoid',
           suggestions: [
             {
@@ -493,6 +383,116 @@ function notcool(input: string) {
           ],
         },
       ],
+      options: [{ ignoreVoidOperator: true }],
+      output: null,
+    },
+  ],
+
+  valid: [
+    '() => Math.random();',
+    "console.log('foo');",
+    'foo && console.log(foo);',
+    'foo || console.log(foo);',
+    'foo ? console.log(true) : console.log(false);',
+    "console?.log('foo');",
+
+    {
+      code: `
+        () => console.log('foo');
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => foo && console.log(foo);
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => foo || console.log(foo);
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => (foo ? console.log(true) : console.log(false));
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+
+    {
+      code: `
+        !void console.log('foo');
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        +void (foo && console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        -void (foo || console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        () => void ((foo && void console.log(true)) || console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        const x = void (foo ? console.log(true) : console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        !(foo && void console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        !!(foo || void console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        const x = (foo && void console.log(true)) || void console.log(false);
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        () => (foo ? void console.log(true) : void console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        return void console.log('foo');
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+
+    `
+function cool(input: string) {
+  return console.log(input), input;
+}
+    `,
+    {
+      code: `
+function cool(input: string) {
+  return input, console.log(input), input;
+}
+      `,
     },
   ],
 });
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 cc8ba8f430f4..0e619268ff8b 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
@@ -5,81 +5,6 @@ import rule from '../../src/rules/no-dupe-class-members';
 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 Foo {
-        foo(a: string): string;
-        foo(a: number): number;
-        foo(a: any): any {}
-      }
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -89,7 +14,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -100,7 +25,7 @@ class A {
 };
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -111,7 +36,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -122,7 +47,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: '10' } },
+        { column: 3, data: { name: '10' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -134,8 +59,8 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
-        { line: 5, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
+        { column: 3, data: { name: 'foo' }, line: 5, messageId: 'unexpected' },
       ],
     },
     {
@@ -146,7 +71,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -157,7 +82,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -168,7 +93,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -179,7 +104,7 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
     {
@@ -190,8 +115,83 @@ class A {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { column: 3, data: { name: 'foo' }, line: 4, messageId: 'unexpected' },
       ],
     },
   ],
+  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 Foo {
+        foo(a: string): string;
+        foo(a: number): number;
+        foo(a: any): any {}
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts b/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
index 3273d245e276..766cf1f2798e 100644
--- a/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
@@ -5,6 +5,64 @@ import rule from '../../src/rules/no-duplicate-enum-values';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-duplicate-enum-values', rule, {
+  invalid: [
+    {
+      code: `
+enum E {
+  A = 1,
+  B = 1,
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 1 },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+    {
+      code: `
+enum E {
+  A = 'A',
+  B = 'A',
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 'A' },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+    {
+      code: `
+enum E {
+  A = 'A',
+  B = 'A',
+  C = 1,
+  D = 1,
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 'A' },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+        {
+          column: 3,
+          data: { value: 1 },
+          line: 6,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+  ],
   valid: [
     `
 enum E {
@@ -74,62 +132,4 @@ enum E {
 }
     `,
   ],
-  invalid: [
-    {
-      code: `
-enum E {
-  A = 1,
-  B = 1,
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          column: 3,
-          messageId: 'duplicateValue',
-          data: { value: 1 },
-        },
-      ],
-    },
-    {
-      code: `
-enum E {
-  A = 'A',
-  B = 'A',
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          column: 3,
-          messageId: 'duplicateValue',
-          data: { value: 'A' },
-        },
-      ],
-    },
-    {
-      code: `
-enum E {
-  A = 'A',
-  B = 'A',
-  C = 1,
-  D = 1,
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          column: 3,
-          messageId: 'duplicateValue',
-          data: { value: 'A' },
-        },
-        {
-          line: 6,
-          column: 3,
-          messageId: 'duplicateValue',
-          data: { value: 1 },
-        },
-      ],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
index afc053781bc3..d145aca4e9ee 100644
--- a/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
@@ -8,430 +8,284 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('no-duplicate-type-constituents', rule, {
-  valid: [
-    {
-      code: 'type T = 1 | 2;',
-    },
-    {
-      code: "type T = 1 | '1';",
-    },
-    {
-      code: 'type T = true & boolean;',
-    },
-    {
-      code: 'type T = null | undefined;',
-    },
-    {
-      code: 'type T = any | unknown;',
-    },
-    {
-      code: 'type T = { a: string } | { b: string };',
-    },
-    {
-      code: 'type T = { a: string; b: number } | { b: number; a: string };',
-    },
-    {
-      code: 'type T = { a: string | number };',
-    },
-    {
-      code: 'type T = Set<string> | Set<number>;',
-    },
-    {
-      code: 'type T = Class<string> | Class<number>;',
-    },
-    {
-      code: 'type T = string[] | number[];',
-    },
-    {
-      code: 'type T = string[][] | string[];',
-    },
-    {
-      code: 'type T = [1, 2, 3] | [1, 2, 4];',
-    },
-    {
-      code: 'type T = [1, 2, 3] | [1, 2, 3, 4];',
-    },
-    {
-      code: "type T = 'A' | string[];",
-    },
-    {
-      code: 'type T = (() => string) | (() => void);',
-    },
-    {
-      code: 'type T = () => string | void;',
-    },
-    {
-      code: 'type T = () => null | undefined;',
-    },
-    {
-      code: 'type T = (arg: string | number) => void;',
-    },
-    {
-      code: 'type T = A | A;',
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = A | B;
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-const a: A | B = 'A';
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = A | /* comment */ B;
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = 'A' | 'B';
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type T = A | B | C;
-      `,
-    },
-    {
-      code: 'type T = readonly string[] | string[];',
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type D = 'D';
-type T = (A | B) | (C | D);
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = (A | B) | (A & B);
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = Record<string, A | B>;
-      `,
-    },
-    {
-      code: 'type T = A | A;',
-      options: [
-        {
-          ignoreUnions: true,
-        },
-      ],
-    },
-    {
-      code: 'type T = A & A;',
-      options: [
-        {
-          ignoreIntersections: true,
-        },
-      ],
-    },
-    {
-      code: 'type T = Class<string> | Class<string>;',
-    },
-    {
-      code: 'type T = A | A | string;',
-    },
-  ],
   invalid: [
     {
       code: 'type T = 1 | 1;',
-      output: `type T = 1  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: '1',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = 1  ;`,
     },
     {
       code: 'type T = true & true;',
-      output: `type T = true  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Intersection',
             previous: 'true',
+            type: 'Intersection',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = true  ;`,
     },
     {
       code: 'type T = null | null;',
-      output: `type T = null  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'null',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = null  ;`,
     },
     {
       code: 'type T = any | any;',
-      output: `type T = any  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'any',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = any  ;`,
     },
     {
       code: 'type T = { a: string | string };',
-      output: `type T = { a: string   };`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = { a: string   };`,
     },
     {
       code: 'type T = { a: string } | { a: string };',
-      output: `type T = { a: string }  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: '{ a: string }',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = { a: string }  ;`,
     },
     {
       code: 'type T = { a: string; b: number } | { a: string; b: number };',
-      output: `type T = { a: string; b: number }  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: '{ a: string; b: number }',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = { a: string; b: number }  ;`,
     },
     {
       code: 'type T = Set<string> | Set<string>;',
-      output: `type T = Set<string>  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'Set<string>',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = Set<string>  ;`,
     },
     {
       code: `
 type IsArray<T> = T extends any[] ? true : false;
 type ActuallyDuplicated = IsArray<number> | IsArray<string>;
-      `,
-      output: `
-type IsArray<T> = T extends any[] ? true : false;
-type ActuallyDuplicated = IsArray<number>  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'IsArray<number>',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type IsArray<T> = T extends any[] ? true : false;
+type ActuallyDuplicated = IsArray<number>  ;
+      `,
     },
     {
       code: 'type T = string[] | string[];',
-      output: `type T = string[]  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string[]',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = string[]  ;`,
     },
     {
       code: 'type T = string[][] | string[][];',
-      output: `type T = string[][]  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string[][]',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = string[][]  ;`,
     },
     {
       code: 'type T = [1, 2, 3] | [1, 2, 3];',
-      output: `type T = [1, 2, 3]  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: '[1, 2, 3]',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = [1, 2, 3]  ;`,
     },
     {
       code: 'type T = () => string | string;',
-      output: `type T = () => string  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = () => string  ;`,
     },
     {
       code: 'type T = () => null | null;',
-      output: `type T = () => null  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'null',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = () => null  ;`,
     },
     {
       code: 'type T = (arg: string | string) => void;',
-      output: `type T = (arg: string  ) => void;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = (arg: string  ) => void;`,
     },
     {
       code: "type T = 'A' | 'A';",
-      output: `type T = 'A'  ;`,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: "'A'",
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `type T = 'A'  ;`,
     },
     {
       code: `
 type A = 'A';
 type T = A | A;
-      `,
-      output: `
-type A = 'A';
-type T = A  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type T = A  ;
+      `,
     },
     {
       code: `
 type A = 'A';
 const a: A | A = 'A';
-      `,
-      output: `
-type A = 'A';
-const a: A   = 'A';
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+const a: A   = 'A';
+      `,
     },
     {
       code: `
 type A = 'A';
 type T = A | /* comment */ A;
-      `,
-      output: `
-type A = 'A';
-type T = A  /* comment */ ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type T = A  /* comment */ ;
+      `,
     },
     {
       code: `
@@ -439,106 +293,106 @@ type A1 = 'A';
 type A2 = 'A';
 type A3 = 'A';
 type T = A1 | A2 | A3;
-      `,
-      output: `
-type A1 = 'A';
-type A2 = 'A';
-type A3 = 'A';
-type T = A1    ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A1',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A1',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A1 = 'A';
+type A2 = 'A';
+type A3 = 'A';
+type T = A1    ;
+      `,
     },
     {
       code: `
 type A = 'A';
 type B = 'B';
 type T = A | B | A;
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type T = A | B  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type T = A | B  ;
+      `,
     },
     {
       code: `
 type A = 'A';
 type B = 'B';
 type T = A | B | A | B;
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type T = A | B    ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'B',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type T = A | B    ;
+      `,
     },
     {
       code: `
 type A = 'A';
 type B = 'B';
 type T = A | B | A | A;
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type T = A | B    ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type T = A | B    ;
+      `,
     },
     {
       code: `
@@ -546,69 +400,69 @@ type A = 'A';
 type B = 'B';
 type C = 'C';
 type T = A | B | A | C;
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type T = A | B   | C;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type T = A | B   | C;
+      `,
     },
     {
       code: `
 type A = 'A';
 type B = 'B';
 type T = (A | B) | (A | B);
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type T = (A | B)  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A | B',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type T = (A | B)  ;
+      `,
     },
     {
       code: `
 type A = 'A';
 type T = A | (A | A);
-      `,
-      output: `
-type A = 'A';
-type T = A  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: `A`,
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type T = A  ;
+      `,
     },
     {
       code: `
@@ -617,62 +471,208 @@ type B = 'B';
 type C = 'C';
 type D = 'D';
 type F = (A | B) | (A | B) | ((C | D) & (A | B)) | (A | B);
-      `,
-      output: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type D = 'D';
-type F = (A | B)   | ((C | D) & (A | B))  ;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A | B',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A | B',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type D = 'D';
+type F = (A | B)   | ((C | D) & (A | B))  ;
+      `,
     },
     {
       code: `
 type A = 'A';
 type T = Record<string, A | A>;
-      `,
-      output: `
-type A = 'A';
-type T = Record<string, A  >;
       `,
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'A',
+            type: 'Union',
           },
+          messageId: 'duplicate',
         },
       ],
+      output: `
+type A = 'A';
+type T = Record<string, A  >;
+      `,
     },
     {
       code: 'type T = A | A | string | string;',
-      output: 'type T = A | A | string  ;',
       errors: [
         {
-          messageId: 'duplicate',
           data: {
-            type: 'Union',
             previous: 'string',
+            type: 'Union',
           },
+          messageId: 'duplicate',
+        },
+      ],
+      output: 'type T = A | A | string  ;',
+    },
+  ],
+  valid: [
+    {
+      code: 'type T = 1 | 2;',
+    },
+    {
+      code: "type T = 1 | '1';",
+    },
+    {
+      code: 'type T = true & boolean;',
+    },
+    {
+      code: 'type T = null | undefined;',
+    },
+    {
+      code: 'type T = any | unknown;',
+    },
+    {
+      code: 'type T = { a: string } | { b: string };',
+    },
+    {
+      code: 'type T = { a: string; b: number } | { b: number; a: string };',
+    },
+    {
+      code: 'type T = { a: string | number };',
+    },
+    {
+      code: 'type T = Set<string> | Set<number>;',
+    },
+    {
+      code: 'type T = Class<string> | Class<number>;',
+    },
+    {
+      code: 'type T = string[] | number[];',
+    },
+    {
+      code: 'type T = string[][] | string[];',
+    },
+    {
+      code: 'type T = [1, 2, 3] | [1, 2, 4];',
+    },
+    {
+      code: 'type T = [1, 2, 3] | [1, 2, 3, 4];',
+    },
+    {
+      code: "type T = 'A' | string[];",
+    },
+    {
+      code: 'type T = (() => string) | (() => void);',
+    },
+    {
+      code: 'type T = () => string | void;',
+    },
+    {
+      code: 'type T = () => null | undefined;',
+    },
+    {
+      code: 'type T = (arg: string | number) => void;',
+    },
+    {
+      code: 'type T = A | A;',
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = A | B;
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+const a: A | B = 'A';
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = A | /* comment */ B;
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = 'A' | 'B';
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type T = A | B | C;
+      `,
+    },
+    {
+      code: 'type T = readonly string[] | string[];',
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type D = 'D';
+type T = (A | B) | (C | D);
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = (A | B) | (A & B);
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = Record<string, A | B>;
+      `,
+    },
+    {
+      code: 'type T = A | A;',
+      options: [
+        {
+          ignoreUnions: true,
+        },
+      ],
+    },
+    {
+      code: 'type T = A & A;',
+      options: [
+        {
+          ignoreIntersections: true,
         },
       ],
     },
+    {
+      code: 'type T = Class<string> | Class<string>;',
+    },
+    {
+      code: 'type T = A | A | string;',
+    },
   ],
 });
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 c5fcdcf2d888..534639579c61 100644
--- a/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
@@ -8,59 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 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['-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['NaN'];
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -117,8 +71,8 @@ const container: { [i: string]: 0 } = {};
 const getName = () => 'aaa';
 delete container[getName()];
       `,
-      output: null,
       errors: [{ messageId: 'dynamicDelete' }],
+      output: null,
     },
     {
       code: `
@@ -126,24 +80,70 @@ const container: { [i: string]: 0 } = {};
 const name = { foo: { bar: 'bar' } };
 delete container[name.foo.bar];
       `,
-      output: null,
       errors: [{ messageId: 'dynamicDelete' }],
+      output: null,
     },
     {
       code: `
 const container: { [i: string]: 0 } = {};
 delete container[+'Infinity'];
       `,
-      output: null,
       errors: [{ messageId: 'dynamicDelete' }],
+      output: null,
     },
     {
       code: `
 const container: { [i: string]: 0 } = {};
 delete container[typeof 1];
       `,
-      output: null,
       errors: [{ messageId: 'dynamicDelete' }],
+      output: null,
     },
   ],
+  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['-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['NaN'];
+    `,
+  ],
 });
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 0ca7f35b2f2c..0957992c5444 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
@@ -5,82 +5,6 @@ import rule from '../../src/rules/no-empty-function';
 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 {
-  constructor(private name: string) {}
-}
-      `,
-    },
-    {
-      code: `
-class Person {
-  constructor(name: string) {}
-}
-      `,
-      options: [{ allow: ['constructors'] }],
-    },
-    {
-      code: `
-class Person {
-  otherMethod(name: string) {}
-}
-      `,
-      options: [{ allow: ['methods'] }],
-    },
-    {
-      code: `
-class Foo {
-  private constructor() {}
-}
-      `,
-      options: [{ allow: ['private-constructors'] }],
-    },
-    {
-      code: `
-class Foo {
-  protected constructor() {}
-}
-      `,
-      options: [{ allow: ['protected-constructors'] }],
-    },
-    {
-      code: `
-function foo() {
-  const a = null;
-}
-      `,
-    },
-    {
-      code: `
-class Foo {
-  @decorator()
-  foo() {}
-}
-      `,
-      options: [{ allow: ['decoratedFunctions'] }],
-    },
-    {
-      code: `
-class Foo extends Base {
-  override foo() {}
-}
-      `,
-      options: [{ allow: ['overrideMethods'] }],
-    },
-  ],
-
   invalid: [
     {
       code: `
@@ -90,12 +14,12 @@ class Person {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 29,
           data: {
             name: 'constructor',
           },
           line: 3,
-          column: 29,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -107,12 +31,12 @@ class Person {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 29,
           data: {
             name: "method 'otherMethod'",
           },
           line: 3,
-          column: 29,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -124,12 +48,12 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 25,
           data: {
             name: 'constructor',
           },
           line: 3,
-          column: 25,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -141,12 +65,12 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 27,
           data: {
             name: 'constructor',
           },
           line: 3,
-          column: 27,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -156,12 +80,12 @@ function foo() {}
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 16,
           data: {
             name: "function 'foo'",
           },
           line: 2,
-          column: 16,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -174,12 +98,12 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 9,
           data: {
             name: "method 'foo'",
           },
           line: 4,
-          column: 9,
+          messageId: 'unexpected',
         },
       ],
     },
@@ -191,14 +115,90 @@ class Foo extends Base {
       `,
       errors: [
         {
-          messageId: 'unexpected',
+          column: 18,
           data: {
             name: "method 'foo'",
           },
           line: 3,
-          column: 18,
+          messageId: 'unexpected',
         },
       ],
     },
   ],
+
+  valid: [
+    {
+      code: `
+class Person {
+  private name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Person {
+  constructor(private name: string) {}
+}
+      `,
+    },
+    {
+      code: `
+class Person {
+  constructor(name: string) {}
+}
+      `,
+      options: [{ allow: ['constructors'] }],
+    },
+    {
+      code: `
+class Person {
+  otherMethod(name: string) {}
+}
+      `,
+      options: [{ allow: ['methods'] }],
+    },
+    {
+      code: `
+class Foo {
+  private constructor() {}
+}
+      `,
+      options: [{ allow: ['private-constructors'] }],
+    },
+    {
+      code: `
+class Foo {
+  protected constructor() {}
+}
+      `,
+      options: [{ allow: ['protected-constructors'] }],
+    },
+    {
+      code: `
+function foo() {
+  const a = null;
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  @decorator()
+  foo() {}
+}
+      `,
+      options: [{ allow: ['decoratedFunctions'] }],
+    },
+    {
+      code: `
+class Foo extends Base {
+  override foo() {}
+}
+      `,
+      options: [{ allow: ['overrideMethods'] }],
+    },
+  ],
 });
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 cc87f61409a3..75992c066919 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -5,69 +5,28 @@ import rule from '../../src/rules/no-empty-interface';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-interface', rule, {
-  valid: [
-    `
-interface Foo {
-  name: string;
-}
-    `,
-    `
-interface Foo {
-  name: string;
-}
-
-interface Bar {
-  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;
-}
-
-interface Bar extends Foo {}
-      `,
-      options: [{ allowSingleExtends: true }],
-    },
-    {
-      code: `
-interface Foo {
-  props: string;
-}
-
-interface Bar extends Foo {}
-
-class Bar {}
-      `,
-      options: [{ allowSingleExtends: true }],
-    },
-  ],
   invalid: [
     {
       code: 'interface Foo {}',
-      output: null,
       errors: [
         {
-          messageId: 'noEmpty',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmpty',
         },
       ],
+      output: null,
     },
     {
       code: noFormat`interface Foo extends {}`,
-      output: null,
       errors: [
         {
-          messageId: 'noEmpty',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmpty',
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -79,6 +38,14 @@ interface Bar extends Foo {}
 
 class Baz {}
       `,
+      errors: [
+        {
+          column: 11,
+          line: 6,
+          messageId: 'noEmptyWithSuper',
+        },
+      ],
+      options: [{ allowSingleExtends: false }],
       output: `
 interface Foo {
   props: string;
@@ -88,14 +55,6 @@ type Bar = Foo
 
 class Baz {}
       `,
-      options: [{ allowSingleExtends: false }],
-      errors: [
-        {
-          messageId: 'noEmptyWithSuper',
-          line: 6,
-          column: 11,
-        },
-      ],
     },
     {
       code: `
@@ -107,14 +66,14 @@ interface Bar extends Foo {}
 
 class Bar {}
       `,
-      options: [{ allowSingleExtends: false }],
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 6,
           column: 11,
+          line: 6,
+          messageId: 'noEmptyWithSuper',
         },
       ],
+      options: [{ allowSingleExtends: false }],
       output: null,
     },
     {
@@ -127,6 +86,14 @@ interface Bar extends Foo {}
 
 const bar = class Bar {};
       `,
+      errors: [
+        {
+          column: 11,
+          line: 6,
+          messageId: 'noEmptyWithSuper',
+        },
+      ],
+      options: [{ allowSingleExtends: false }],
       output: `
 interface Foo {
   props: string;
@@ -136,14 +103,6 @@ type Bar = Foo
 
 const bar = class Bar {};
       `,
-      options: [{ allowSingleExtends: false }],
-      errors: [
-        {
-          messageId: 'noEmptyWithSuper',
-          line: 6,
-          column: 11,
-        },
-      ],
     },
     {
       code: `
@@ -153,6 +112,14 @@ interface Foo {
 
 interface Bar extends Foo {}
       `,
+      errors: [
+        {
+          column: 11,
+          line: 6,
+          messageId: 'noEmptyWithSuper',
+        },
+      ],
+      options: [{ allowSingleExtends: false }],
       output: `
 interface Foo {
   name: string;
@@ -160,36 +127,28 @@ interface Foo {
 
 type Bar = Foo
       `,
-      options: [{ allowSingleExtends: false }],
-      errors: [
-        {
-          messageId: 'noEmptyWithSuper',
-          line: 6,
-          column: 11,
-        },
-      ],
     },
     {
       code: 'interface Foo extends Array<number> {}',
-      output: `type Foo = Array<number>`,
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmptyWithSuper',
         },
       ],
+      output: `type Foo = Array<number>`,
     },
     {
       code: 'interface Foo extends Array<number | {}> {}',
-      output: `type Foo = Array<number | {}>`,
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmptyWithSuper',
         },
       ],
+      output: `type Foo = Array<number | {}>`,
     },
     {
       code: `
@@ -198,54 +157,53 @@ interface Bar {
 }
 interface Foo extends Array<Bar> {}
       `,
+      errors: [
+        {
+          column: 11,
+          line: 5,
+          messageId: 'noEmptyWithSuper',
+        },
+      ],
       output: `
 interface Bar {
   bar: string;
 }
 type Foo = Array<Bar>
       `,
-      errors: [
-        {
-          messageId: 'noEmptyWithSuper',
-          line: 5,
-          column: 11,
-        },
-      ],
     },
     {
       code: `
 type R = Record<string, unknown>;
 interface Foo extends R {}
-      `,
-      output: `
-type R = Record<string, unknown>;
-type Foo = R
       `,
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'noEmptyWithSuper',
         },
       ],
+      output: `
+type R = Record<string, unknown>;
+type Foo = R
+      `,
     },
     {
       code: `
 interface Foo<T> extends Bar<T> {}
-      `,
-      output: `
-type Foo<T> = Bar<T>
       `,
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 2,
           column: 11,
+          line: 2,
+          messageId: 'noEmptyWithSuper',
         },
       ],
+      output: `
+type Foo<T> = Bar<T>
+      `,
     },
     {
-      filename: 'test.d.ts',
       code: `
 declare module FooBar {
   type Baz = typeof baz;
@@ -254,11 +212,11 @@ declare module FooBar {
       `,
       errors: [
         {
-          messageId: 'noEmptyWithSuper',
-          line: 4,
           column: 20,
-          endLine: 4,
           endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'noEmptyWithSuper',
           suggestions: [
             {
               messageId: 'noEmptyWithSuper',
@@ -272,8 +230,50 @@ declare module FooBar {
           ],
         },
       ],
+      filename: 'test.d.ts',
       // output matches input because a suggestion was made
       output: null,
     },
   ],
+  valid: [
+    `
+interface Foo {
+  name: string;
+}
+    `,
+    `
+interface Foo {
+  name: string;
+}
+
+interface Bar {
+  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;
+}
+
+interface Bar extends Foo {}
+      `,
+      options: [{ allowSingleExtends: true }],
+    },
+    {
+      code: `
+interface Foo {
+  props: string;
+}
+
+interface Bar extends Foo {}
+
+class Bar {}
+      `,
+      options: [{ allowSingleExtends: true }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts b/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
index 5bb17a31f868..6bf4d7d9cd33 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
@@ -5,75 +5,6 @@ import rule from '../../src/rules/no-empty-object-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-object-type', rule, {
-  valid: [
-    `
-interface Base {
-  name: string;
-}
-    `,
-    `
-interface Base {
-  name: string;
-}
-
-interface Derived {
-  age: number;
-}
-
-// valid because extending multiple interfaces can be used instead of a union type
-interface Both extends Base, Derived {}
-    `,
-    {
-      code: 'interface Base {}',
-      options: [{ allowInterfaces: 'always' }],
-    },
-    {
-      code: `
-interface Base {
-  name: string;
-}
-
-interface Derived extends Base {}
-      `,
-      options: [{ allowInterfaces: 'with-single-extends' }],
-    },
-    {
-      code: `
-interface Base {
-  props: string;
-}
-
-interface Derived extends Base {}
-
-class Derived {}
-      `,
-      options: [{ allowInterfaces: 'with-single-extends' }],
-    },
-    'let value: object;',
-    'let value: Object;',
-    'let value: { inner: true };',
-    'type MyNonNullable<T> = T & {};',
-    {
-      code: 'type Base = {};',
-      options: [{ allowObjectTypes: 'always' }],
-    },
-    {
-      code: 'type Base = {};',
-      options: [{ allowWithName: 'Base' }],
-    },
-    {
-      code: 'type BaseProps = {};',
-      options: [{ allowWithName: 'Props$' }],
-    },
-    {
-      code: 'interface Base {}',
-      options: [{ allowWithName: 'Base' }],
-    },
-    {
-      code: 'interface BaseProps {}',
-      options: [{ allowWithName: 'Props$' }],
-    },
-  ],
   invalid: [
     {
       code: 'interface Base {}',
@@ -182,9 +113,9 @@ const derived = class Derived {};
       `,
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 6,
           column: 11,
+          line: 6,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -212,9 +143,9 @@ interface Derived extends Base {}
       `,
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 6,
           column: 11,
+          line: 6,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -234,9 +165,9 @@ type Derived = Base
       code: 'interface Base extends Array<number> {}',
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -250,10 +181,10 @@ type Derived = Base
       code: 'interface Base extends Array<number | {}> {}',
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 1,
           column: 11,
           endColumn: 15,
+          line: 1,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -262,11 +193,11 @@ type Derived = Base
           ],
         },
         {
-          data: { option: 'allowObjectTypes' },
-          messageId: 'noEmptyObject',
-          line: 1,
           column: 39,
+          data: { option: 'allowObjectTypes' },
           endColumn: 41,
+          line: 1,
+          messageId: 'noEmptyObject',
           suggestions: [
             {
               data: { replacement: 'object' },
@@ -291,9 +222,9 @@ interface Base extends Array<Derived> {}
       `,
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 5,
           column: 11,
+          line: 5,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -315,9 +246,9 @@ interface Base extends R {}
       `,
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -334,9 +265,9 @@ type Base = R
       code: 'interface Base<T> extends Derived<T> {}',
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -347,7 +278,6 @@ type Base = R
       ],
     },
     {
-      filename: 'test.d.ts',
       code: `
 declare namespace BaseAndDerived {
   type Base = typeof base;
@@ -356,11 +286,11 @@ declare namespace BaseAndDerived {
       `,
       errors: [
         {
-          messageId: 'noEmptyInterfaceWithSuper',
-          line: 4,
           column: 20,
-          endLine: 4,
           endColumn: 27,
+          endLine: 4,
+          line: 4,
+          messageId: 'noEmptyInterfaceWithSuper',
           suggestions: [
             {
               messageId: 'replaceEmptyInterfaceWithSuper',
@@ -374,16 +304,17 @@ declare namespace BaseAndDerived {
           ],
         },
       ],
+      filename: 'test.d.ts',
     },
     {
       code: 'type Base = {};',
       errors: [
         {
           column: 13,
-          line: 1,
+          data: { option: 'allowObjectTypes' },
           endColumn: 15,
           endLine: 1,
-          data: { option: 'allowObjectTypes' },
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -405,10 +336,10 @@ declare namespace BaseAndDerived {
       errors: [
         {
           column: 13,
-          line: 1,
+          data: { option: 'allowObjectTypes' },
           endColumn: 15,
           endLine: 1,
-          data: { option: 'allowObjectTypes' },
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -431,10 +362,10 @@ declare namespace BaseAndDerived {
       errors: [
         {
           column: 12,
-          line: 1,
+          data: { option: 'allowObjectTypes' },
           endColumn: 14,
           endLine: 1,
-          data: { option: 'allowObjectTypes' },
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -456,10 +387,10 @@ declare namespace BaseAndDerived {
       errors: [
         {
           column: 12,
-          line: 1,
+          data: { option: 'allowObjectTypes' },
           endColumn: 14,
           endLine: 1,
-          data: { option: 'allowObjectTypes' },
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -485,11 +416,11 @@ let value: {
       `,
       errors: [
         {
-          line: 2,
-          endLine: 4,
           column: 12,
-          endColumn: 2,
           data: { option: 'allowObjectTypes' },
+          endColumn: 2,
+          endLine: 4,
+          line: 2,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -515,10 +446,10 @@ let value: unknown;
       errors: [
         {
           column: 23,
-          line: 1,
+          data: { option: 'allowObjectTypes' },
           endColumn: 25,
           endLine: 1,
-          data: { option: 'allowObjectTypes' },
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -540,9 +471,9 @@ let value: unknown;
       errors: [
         {
           column: 13,
-          line: 1,
           endColumn: 15,
           endLine: 1,
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -565,9 +496,9 @@ let value: unknown;
       errors: [
         {
           column: 13,
-          line: 1,
           endColumn: 15,
           endLine: 1,
+          line: 1,
           messageId: 'noEmptyObject',
           suggestions: [
             {
@@ -590,9 +521,9 @@ let value: unknown;
       errors: [
         {
           column: 11,
-          line: 1,
           endColumn: 15,
           endLine: 1,
+          line: 1,
           messageId: 'noEmptyInterface',
           suggestions: [
             {
@@ -610,4 +541,73 @@ let value: unknown;
       options: [{ allowWithName: '.*Props$' }],
     },
   ],
+  valid: [
+    `
+interface Base {
+  name: string;
+}
+    `,
+    `
+interface Base {
+  name: string;
+}
+
+interface Derived {
+  age: number;
+}
+
+// valid because extending multiple interfaces can be used instead of a union type
+interface Both extends Base, Derived {}
+    `,
+    {
+      code: 'interface Base {}',
+      options: [{ allowInterfaces: 'always' }],
+    },
+    {
+      code: `
+interface Base {
+  name: string;
+}
+
+interface Derived extends Base {}
+      `,
+      options: [{ allowInterfaces: 'with-single-extends' }],
+    },
+    {
+      code: `
+interface Base {
+  props: string;
+}
+
+interface Derived extends Base {}
+
+class Derived {}
+      `,
+      options: [{ allowInterfaces: 'with-single-extends' }],
+    },
+    'let value: object;',
+    'let value: Object;',
+    'let value: { inner: true };',
+    'type MyNonNullable<T> = T & {};',
+    {
+      code: 'type Base = {};',
+      options: [{ allowObjectTypes: 'always' }],
+    },
+    {
+      code: 'type Base = {};',
+      options: [{ allowWithName: 'Base' }],
+    },
+    {
+      code: 'type BaseProps = {};',
+      options: [{ allowWithName: 'Props$' }],
+    },
+    {
+      code: 'interface Base {}',
+      options: [{ allowWithName: 'Base' }],
+    },
+    {
+      code: 'interface BaseProps {}',
+      options: [{ allowWithName: 'Props$' }],
+    },
+  ],
 });
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 ce4011290353..51c3af20bec5 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -2,9 +2,11 @@ import type {
   InvalidTestCase,
   SuggestionOutput,
 } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../src/rules/no-explicit-any';
+
 import rule from '../../src/rules/no-explicit-any';
 
 type RuleInvalidTestCase = InvalidTestCase<MessageIds, Options>;
@@ -13,1234 +15,1234 @@ type RuleSuggestionOutput = SuggestionOutput<MessageIds>;
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-explicit-any', rule, {
-  valid: [
-    'const number: number = 1;',
-    'function greet(): string {}',
-    'function greet(): Array<string> {}',
-    'function greet(): string[] {}',
-    'function greet(): Array<Array<string>> {}',
-    'function greet(): Array<string[]> {}',
-    'function greet(param: Array<string>): Array<string> {}',
-    `
+  invalid: (
+    [
+      {
+        code: 'const number: any = 1',
+        errors: [
+          {
+            column: 15,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(): any {}',
+        errors: [
+          {
+            column: 21,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(): Array<any> {}',
+        errors: [
+          {
+            column: 27,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(): any[] {}',
+        errors: [
+          {
+            column: 21,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(param: Array<any>): number {}',
+        errors: [
+          {
+            column: 31,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(param: any[]): number {}',
+        errors: [
+          {
+            column: 25,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(param: Array<any>): Array<any> {}',
+        errors: [
+          {
+            column: 31,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'function generic(param: Array<unknown>): Array<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'function generic(param: Array<never>): Array<any> {}',
+              },
+            ],
+          },
+          {
+            column: 44,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'function generic(param: Array<any>): Array<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'function generic(param: Array<any>): Array<never> {}',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        code: 'function generic(): Array<Array<any>> {}',
+        errors: [
+          {
+            column: 33,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'function generic(): Array<any[]> {}',
+        errors: [
+          {
+            column: 27,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 class Greeter {
-  message: string;
+    constructor(param: Array<any>) {}
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 30,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 class Greeter {
-  message: Array<string>;
+    message: any;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 class Greeter {
-  message: string[];
+    message: Array<any>;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 class Greeter {
-  message: Array<Array<string>>;
+    message: any[];
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 class Greeter {
-  message: Array<string[]>;
+    message: Array<Array<any>>;
 }
-    `,
-    `
-interface Greeter {
-  message: string;
+            `,
+        errors: [
+          {
+            column: 26,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+class Greeter {
+    message: Array<any[]>;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 interface Greeter {
-  message: Array<string>;
+    message: any;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 interface Greeter {
-  message: string[];
+    message: Array<any>;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 interface Greeter {
-  message: Array<Array<string>>;
+    message: any[];
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 interface Greeter {
-  message: Array<string[]>;
+    message: Array<Array<any>>;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 26,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+interface Greeter {
+    message: Array<any[]>;
+}
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string;
-};
-    `,
-    `
+    message: any;
+}
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: Array<string>;
-};
-    `,
-    `
+    message: Array<any>;
+}
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string[];
-};
-    `,
-    `
+    message: any[];
+}
+            `,
+        errors: [
+          {
+            column: 14,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: Array<Array<string>>;
-};
-    `,
-    `
+    message: Array<Array<any>>;
+}
+            `,
+        errors: [
+          {
+            column: 26,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: Array<string[]>;
-};
-    `,
-    `
+    message: Array<any[]>;
+}
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string | number;
-};
-    `,
-    `
+    message: string | any;
+}
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string | Array<string>;
-};
-    `,
-    `
+    message: string | Array<any>;
+}
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string | string[];
-};
-    `,
-    `
+    message: string | any[];
+}
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string | Array<Array<string>>;
-};
-    `,
-    `
+    message: string | Array<Array<any>>;
+}
+            `,
+        errors: [
+          {
+            column: 35,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string & number;
-};
-    `,
-    `
+    message: string | Array<any[]>;
+}
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string & Array<string>;
-};
-    `,
-    `
+    message: string & any;
+}
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string & string[];
-};
-    `,
-    `
+    message: string & Array<any>;
+}
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string & Array<Array<string>>;
-};
-    `,
-    // https://github.com/eslint/typescript-eslint-parser/issues/397
-    {
-      code: `
-        function foo(a: number, ...rest: any[]): void {
-          return;
-        }
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo1(...args: any[]) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar1 = function (...args: any[]) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz1 = (...args: any[]) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo2(...args: readonly any[]) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar2 = function (...args: readonly any[]) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz2 = (...args: readonly any[]) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo3(...args: Array<any>) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar3 = function (...args: Array<any>) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz3 = (...args: Array<any>) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo4(...args: ReadonlyArray<any>) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar4 = function (...args: ReadonlyArray<any>) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz4 = (...args: ReadonlyArray<any>) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux1 {
-  (...args: any[]): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux2 {
-  (...args: readonly any[]): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux3 {
-  (...args: Array<any>): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux4 {
-  (...args: ReadonlyArray<any>): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux1(fn: (...args: any[]) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux2(fn: (...args: readonly any[]) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux3(fn: (...args: Array<any>) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz1(): (...args: any[]) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz2(): (...args: readonly any[]) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz3(): (...args: Array<any>) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      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;
+    message: string & any[];
 }
-      `,
-      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: (
-    [
-      {
-        code: 'const number: any = 1',
+            `,
         errors: [
           {
+            column: 23,
+            line: 3,
             messageId: 'unexpectedAny',
-            line: 1,
-            column: 15,
           },
         ],
       },
       {
-        code: 'function generic(): any {}',
+        code: `
+type obj = {
+    message: string & Array<Array<any>>;
+}
+            `,
         errors: [
           {
+            column: 35,
+            line: 3,
             messageId: 'unexpectedAny',
-            line: 1,
-            column: 21,
           },
         ],
       },
       {
-        code: 'function generic(): Array<any> {}',
+        code: `
+type obj = {
+    message: string & Array<any[]>;
+}
+            `,
         errors: [
           {
+            column: 29,
+            line: 3,
             messageId: 'unexpectedAny',
-            line: 1,
-            column: 27,
           },
         ],
       },
       {
-        code: 'function generic(): any[] {}',
+        code: 'class Foo<t = any> extends Bar<any> {}',
         errors: [
           {
-            messageId: 'unexpectedAny',
+            column: 15,
             line: 1,
-            column: 21,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'class Foo<t = unknown> extends Bar<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'class Foo<t = never> extends Bar<any> {}',
+              },
+            ],
           },
-        ],
-      },
-      {
-        code: 'function generic(param: Array<any>): number {}',
-        errors: [
           {
-            messageId: 'unexpectedAny',
+            column: 32,
             line: 1,
-            column: 31,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'class Foo<t = any> extends Bar<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'class Foo<t = any> extends Bar<never> {}',
+              },
+            ],
           },
         ],
       },
       {
-        code: 'function generic(param: any[]): number {}',
+        code: 'abstract class Foo<t = any> extends Bar<any> {}',
         errors: [
           {
+            column: 24,
+            line: 1,
             messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'abstract class Foo<t = unknown> extends Bar<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'abstract class Foo<t = never> extends Bar<any> {}',
+              },
+            ],
+          },
+          {
+            column: 41,
             line: 1,
-            column: 25,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'abstract class Foo<t = any> extends Bar<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'abstract class Foo<t = any> extends Bar<never> {}',
+              },
+            ],
           },
         ],
       },
       {
-        code: 'function generic(param: Array<any>): Array<any> {}',
+        code: 'abstract class Foo<t = any> implements Bar<any>, Baz<any> {}',
         errors: [
           {
-            messageId: 'unexpectedAny',
+            column: 24,
             line: 1,
-            column: 31,
+            messageId: 'unexpectedAny',
             suggestions: [
               {
                 messageId: 'suggestUnknown',
                 output:
-                  'function generic(param: Array<unknown>): Array<any> {}',
+                  'abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}',
               },
               {
                 messageId: 'suggestNever',
-                output: 'function generic(param: Array<never>): Array<any> {}',
+                output:
+                  'abstract class Foo<t = never> implements Bar<any>, Baz<any> {}',
               },
             ],
           },
           {
+            column: 44,
+            line: 1,
             messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output:
+                  'abstract class Foo<t = any> implements Bar<never>, Baz<any> {}',
+              },
+            ],
+          },
+          {
+            column: 54,
             line: 1,
-            column: 44,
+            messageId: 'unexpectedAny',
             suggestions: [
               {
                 messageId: 'suggestUnknown',
                 output:
-                  'function generic(param: Array<any>): Array<unknown> {}',
+                  'abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}',
               },
               {
                 messageId: 'suggestNever',
-                output: 'function generic(param: Array<any>): Array<never> {}',
+                output:
+                  'abstract class Foo<t = any> implements Bar<any>, Baz<never> {}',
               },
             ],
           },
         ],
       },
       {
-        code: 'function generic(): Array<Array<any>> {}',
+        code: 'new Foo<any>()',
         errors: [
           {
-            messageId: 'unexpectedAny',
+            column: 9,
             line: 1,
-            column: 33,
+            messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        code: 'function generic(): Array<any[]> {}',
+        code: 'Foo<any>()',
         errors: [
           {
-            messageId: 'unexpectedAny',
+            column: 5,
             line: 1,
-            column: 27,
+            messageId: 'unexpectedAny',
           },
         ],
       },
       {
+        // https://github.com/typescript-eslint/typescript-eslint/issues/64
         code: `
-class Greeter {
-    constructor(param: Array<any>) {}
-}
-            `,
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<any>>() => {};
+      `,
         errors: [
           {
+            column: 33,
+            line: 2,
             messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: `
+function test<T extends Partial<unknown>>() {}
+const test = <T extends Partial<any>>() => {};
+      `,
+              },
+              {
+                messageId: 'suggestNever',
+                output: `
+function test<T extends Partial<never>>() {}
+const test = <T extends Partial<any>>() => {};
+      `,
+              },
+            ],
+          },
+          {
+            column: 33,
             line: 3,
-            column: 30,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: `
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<unknown>>() => {};
+      `,
+              },
+              {
+                messageId: 'suggestNever',
+                output: `
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<never>>() => {};
+      `,
+              },
+            ],
           },
         ],
       },
       {
+        // https://github.com/eslint/typescript-eslint-parser/issues/397
         code: `
-class Greeter {
-    message: any;
-}
-            `,
+        function foo(a: number, ...rest: any[]): void {
+          return;
+        }
+      `,
         errors: [
           {
+            column: 42,
+            line: 2,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
       },
       {
-        code: `
-class Greeter {
-    message: Array<any>;
-}
-            `,
+        code: 'type Any = any;',
         errors: [
           {
+            column: 12,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-class Greeter {
-    message: any[];
-}
-            `,
+        code: 'function foo5(...args: any) {}',
         errors: [
           {
+            column: 24,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-class Greeter {
-    message: Array<Array<any>>;
-}
-            `,
+        code: 'const bar5 = function (...args: any) {}',
         errors: [
           {
+            column: 33,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 26,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-class Greeter {
-    message: Array<any[]>;
-}
-            `,
+        code: 'const baz5 = (...args: any) => {}',
         errors: [
           {
+            column: 24,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-interface Greeter {
-    message: any;
-}
-            `,
+        code: 'interface Qux5 { (...args: any): void; }',
         errors: [
           {
+            column: 28,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-interface Greeter {
-    message: Array<any>;
-}
-            `,
+        code: 'function quux5(fn: (...args: any) => void): void {}',
         errors: [
           {
+            column: 30,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-interface Greeter {
-    message: any[];
-}
-            `,
+        code: 'function quuz5(): ((...args: any) => void) {}',
         errors: [
           {
+            column: 30,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-interface Greeter {
-    message: Array<Array<any>>;
-}
-            `,
+        code: 'type Fred5 = (...args: any) => void;',
         errors: [
           {
+            column: 24,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 26,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-interface Greeter {
-    message: Array<any[]>;
-}
-            `,
+        code: 'type Corge5 = new (...args: any) => void;',
         errors: [
           {
+            column: 29,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-type obj = {
-    message: any;
-}
-            `,
+        code: 'interface Grault5 { new (...args: any): void; }',
         errors: [
           {
+            column: 35,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-type obj = {
-    message: Array<any>;
-}
-            `,
+        code: 'interface Garply5 { f(...args: any): void; }',
         errors: [
           {
+            column: 32,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: `
-type obj = {
-    message: any[];
-}
-            `,
+        code: 'declare function waldo5(...args: any): void;',
         errors: [
           {
+            column: 34,
+            line: 1,
             messageId: 'unexpectedAny',
-            line: 3,
-            column: 14,
           },
         ],
+        options: [{ ignoreRestArgs: true }],
       },
+    ] as RuleInvalidTestCase[]
+  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
+    const suggestions = (code: string): RuleSuggestionOutput[] => [
       {
-        code: `
-type obj = {
-    message: Array<Array<any>>;
-}
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 26,
-          },
-        ],
+        messageId: 'suggestUnknown',
+        output: code.replace(/any/, 'unknown'),
       },
       {
-        code: `
-type obj = {
-    message: Array<any[]>;
-}
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 20,
-          },
-        ],
+        messageId: 'suggestNever',
+        output: code.replace(/any/, 'never'),
       },
-      {
-        code: `
-type obj = {
-    message: string | any;
+    ];
+    acc.push({
+      ...testCase,
+      errors: testCase.errors.map(e => ({
+        ...e,
+        suggestions: e.suggestions ?? suggestions(testCase.code),
+      })),
+    });
+    const options = testCase.options ?? [];
+    const code = `// fixToUnknown: true\n${testCase.code}`;
+    acc.push({
+      code,
+      errors: testCase.errors.map(err => {
+        if (err.line === undefined) {
+          return err;
+        }
+
+        return {
+          ...err,
+          line: err.line + 1,
+          suggestions:
+            err.suggestions?.map(
+              (s): RuleSuggestionOutput => ({
+                ...s,
+                output: `// fixToUnknown: true\n${s.output}`,
+              }),
+            ) ?? suggestions(code),
+        };
+      }),
+      options: [{ ...options[0], fixToUnknown: true }],
+      output: code.replaceAll('any', 'unknown'),
+    });
+
+    return acc;
+  }, []),
+  valid: [
+    'const number: number = 1;',
+    'function greet(): string {}',
+    'function greet(): Array<string> {}',
+    'function greet(): string[] {}',
+    'function greet(): Array<Array<string>> {}',
+    'function greet(): Array<string[]> {}',
+    'function greet(param: Array<string>): Array<string> {}',
+    `
+class Greeter {
+  message: string;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 23,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string | Array<any>;
+    `,
+    `
+class Greeter {
+  message: Array<string>;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 29,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string | any[];
+    `,
+    `
+class Greeter {
+  message: string[];
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 23,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string | Array<Array<any>>;
+    `,
+    `
+class Greeter {
+  message: Array<Array<string>>;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 35,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string | Array<any[]>;
+    `,
+    `
+class Greeter {
+  message: Array<string[]>;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 29,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string & any;
+    `,
+    `
+interface Greeter {
+  message: string;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 23,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string & Array<any>;
+    `,
+    `
+interface Greeter {
+  message: Array<string>;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 29,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string & any[];
+    `,
+    `
+interface Greeter {
+  message: string[];
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 23,
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string & Array<Array<any>>;
+    `,
+    `
+interface Greeter {
+  message: Array<Array<string>>;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 35,
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
+interface Greeter {
+  message: Array<string[]>;
+}
+    `,
+    `
 type obj = {
-    message: string & Array<any[]>;
+  message: string;
+};
+    `,
+    `
+type obj = {
+  message: Array<string>;
+};
+    `,
+    `
+type obj = {
+  message: string[];
+};
+    `,
+    `
+type obj = {
+  message: Array<Array<string>>;
+};
+    `,
+    `
+type obj = {
+  message: Array<string[]>;
+};
+    `,
+    `
+type obj = {
+  message: string | number;
+};
+    `,
+    `
+type obj = {
+  message: string | Array<string>;
+};
+    `,
+    `
+type obj = {
+  message: string | string[];
+};
+    `,
+    `
+type obj = {
+  message: string | Array<Array<string>>;
+};
+    `,
+    `
+type obj = {
+  message: string & number;
+};
+    `,
+    `
+type obj = {
+  message: string & Array<string>;
+};
+    `,
+    `
+type obj = {
+  message: string & string[];
+};
+    `,
+    `
+type obj = {
+  message: string & Array<Array<string>>;
+};
+    `,
+    // https://github.com/eslint/typescript-eslint-parser/issues/397
+    {
+      code: `
+        function foo(a: number, ...rest: any[]): void {
+          return;
+        }
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo1(...args: any[]) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar1 = function (...args: any[]) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz1 = (...args: any[]) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo2(...args: readonly any[]) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar2 = function (...args: readonly any[]) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz2 = (...args: readonly any[]) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo3(...args: Array<any>) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar3 = function (...args: Array<any>) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz3 = (...args: Array<any>) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo4(...args: ReadonlyArray<any>) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar4 = function (...args: ReadonlyArray<any>) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz4 = (...args: ReadonlyArray<any>) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux1 {
+  (...args: any[]): void;
 }
-            `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 29,
-          },
-        ],
-      },
-      {
-        code: 'class Foo<t = any> extends Bar<any> {}',
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 15,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'class Foo<t = unknown> extends Bar<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'class Foo<t = never> extends Bar<any> {}',
-              },
-            ],
-          },
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 32,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'class Foo<t = any> extends Bar<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'class Foo<t = any> extends Bar<never> {}',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: 'abstract class Foo<t = any> extends Bar<any> {}',
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 24,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'abstract class Foo<t = unknown> extends Bar<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'abstract class Foo<t = never> extends Bar<any> {}',
-              },
-            ],
-          },
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 41,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'abstract class Foo<t = any> extends Bar<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'abstract class Foo<t = any> extends Bar<never> {}',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: 'abstract class Foo<t = any> implements Bar<any>, Baz<any> {}',
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 24,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = never> implements Bar<any>, Baz<any> {}',
-              },
-            ],
-          },
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 44,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = any> implements Bar<never>, Baz<any> {}',
-              },
-            ],
-          },
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 54,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = any> implements Bar<any>, Baz<never> {}',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: 'new Foo<any>()',
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 9,
-          },
-        ],
-      },
-      {
-        code: 'Foo<any>()',
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 5,
-          },
-        ],
-      },
-      {
-        // https://github.com/typescript-eslint/typescript-eslint/issues/64
-        code: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<any>>() => {};
       `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 2,
-            column: 33,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: `
-function test<T extends Partial<unknown>>() {}
-const test = <T extends Partial<any>>() => {};
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux2 {
+  (...args: readonly any[]): void;
+}
       `,
-              },
-              {
-                messageId: 'suggestNever',
-                output: `
-function test<T extends Partial<never>>() {}
-const test = <T extends Partial<any>>() => {};
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux3 {
+  (...args: Array<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux4 {
+  (...args: ReadonlyArray<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux1(fn: (...args: any[]) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux2(fn: (...args: readonly any[]) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux3(fn: (...args: Array<any>) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz1(): (...args: any[]) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz2(): (...args: readonly any[]) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz3(): (...args: Array<any>) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      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;
+}
       `,
-              },
-            ],
-          },
-          {
-            messageId: 'unexpectedAny',
-            line: 3,
-            column: 33,
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<unknown>>() => {};
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply2 {
+  f(...args: readonly any[]): void;
+}
       `,
-              },
-              {
-                messageId: 'suggestNever',
-                output: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<never>>() => {};
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply3 {
+  f(...args: Array<any>): void;
+}
       `,
-              },
-            ],
-          },
-        ],
-      },
-      {
-        // https://github.com/eslint/typescript-eslint-parser/issues/397
-        code: `
-        function foo(a: number, ...rest: any[]): void {
-          return;
-        }
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply4 {
+  f(...args: ReadonlyArray<any>): void;
+}
       `,
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 2,
-            column: 42,
-          },
-        ],
-      },
-      {
-        code: 'type Any = any;',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 12,
-          },
-        ],
-      },
-      {
-        code: 'function foo5(...args: any) {}',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 24,
-          },
-        ],
-      },
-      {
-        code: 'const bar5 = function (...args: any) {}',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 33,
-          },
-        ],
-      },
-      {
-        code: 'const baz5 = (...args: any) => {}',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 24,
-          },
-        ],
-      },
-      {
-        code: 'interface Qux5 { (...args: any): void; }',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 28,
-          },
-        ],
-      },
-      {
-        code: 'function quux5(fn: (...args: any) => void): void {}',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 30,
-          },
-        ],
-      },
-      {
-        code: 'function quuz5(): ((...args: any) => void) {}',
-        options: [{ ignoreRestArgs: true }],
-        errors: [
-          {
-            messageId: 'unexpectedAny',
-            line: 1,
-            column: 30,
-          },
-        ],
-      },
-      {
-        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 RuleInvalidTestCase[]
-  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
-    const suggestions = (code: string): RuleSuggestionOutput[] => [
-      {
-        messageId: 'suggestUnknown',
-        output: code.replace(/any/, 'unknown'),
-      },
-      {
-        messageId: 'suggestNever',
-        output: code.replace(/any/, 'never'),
-      },
-    ];
-    acc.push({
-      ...testCase,
-      errors: testCase.errors.map(e => ({
-        ...e,
-        suggestions: e.suggestions ?? suggestions(testCase.code),
-      })),
-    });
-    const options = testCase.options ?? [];
-    const code = `// fixToUnknown: true\n${testCase.code}`;
-    acc.push({
-      code,
-      output: code.replaceAll('any', 'unknown'),
-      options: [{ ...options[0], fixToUnknown: true }],
-      errors: testCase.errors.map(err => {
-        if (err.line === undefined) {
-          return err;
-        }
-
-        return {
-          ...err,
-          line: err.line + 1,
-          suggestions:
-            err.suggestions?.map(
-              (s): RuleSuggestionOutput => ({
-                ...s,
-                output: `// fixToUnknown: true\n${s.output}`,
-              }),
-            ) ?? suggestions(code),
-        };
-      }),
-    });
-
-    return acc;
-  }, []),
+      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 }],
+    },
+  ],
 });
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 0569712f9948..f4b856cc1e46 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
@@ -5,200 +5,200 @@ import rule from '../../src/rules/no-extra-non-null-assertion';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-extra-non-null-assertion', rule, {
-  valid: [
-    {
-      code: `
-const foo: { bar: number } | null = null;
-const bar = foo!.bar;
-      `,
-    },
-    {
-      code: `
-function foo(bar: number | undefined) {
-  const bar: number = bar!;
-}
-      `,
-    },
-    {
-      code: `
-function foo(bar?: { n: number }) {
-  return bar?.n;
-}
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2166
-    {
-      code: `
-checksCounter?.textContent!.trim();
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2732
-    {
-      code: `
-function foo(key: string | null) {
-  const obj = {};
-  return obj?.[key!];
-}
-      `,
-    },
-  ],
   invalid: [
     {
       code: `
 const foo: { bar: number } | null = null;
 const bar = foo!!.bar;
-      `,
-      output: `
-const foo: { bar: number } | null = null;
-const bar = foo!.bar;
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 17,
           column: 13,
+          endColumn: 17,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+const foo: { bar: number } | null = null;
+const bar = foo!.bar;
+      `,
     },
     {
       code: `
 function foo(bar: number | undefined) {
   const bar: number = bar!!;
-}
-      `,
-      output: `
-function foo(bar: number | undefined) {
-  const bar: number = bar!;
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 27,
           column: 23,
+          endColumn: 27,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar: number | undefined) {
+  const bar: number = bar!;
+}
+      `,
     },
     {
       code: `
 function foo(bar?: { n: number }) {
   return bar!?.n;
-}
-      `,
-      output: `
-function foo(bar?: { n: number }) {
-  return bar?.n;
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 14,
           column: 10,
+          endColumn: 14,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar?: { n: number }) {
+  return bar?.n;
+}
+      `,
     },
     {
       code: `
 function foo(bar?: { n: number }) {
   return bar!?.();
-}
-      `,
-      output: `
-function foo(bar?: { n: number }) {
-  return bar?.();
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 14,
           column: 10,
+          endColumn: 14,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar?: { n: number }) {
+  return bar?.();
+}
+      `,
     },
     // parentheses
     {
       code: noFormat`
 const foo: { bar: number } | null = null;
 const bar = (foo!)!.bar;
-      `,
-      output: `
-const foo: { bar: number } | null = null;
-const bar = (foo)!.bar;
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 18,
           column: 14,
+          endColumn: 18,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+const foo: { bar: number } | null = null;
+const bar = (foo)!.bar;
+      `,
     },
     {
       code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar!)?.n;
-}
-      `,
-      output: `
-function foo(bar?: { n: number }) {
-  return (bar)?.n;
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 15,
           column: 11,
+          endColumn: 15,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar?: { n: number }) {
+  return (bar)?.n;
+}
+      `,
     },
     {
       code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar)!?.n;
-}
-      `,
-      output: `
-function foo(bar?: { n: number }) {
-  return (bar)?.n;
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 16,
           column: 10,
+          endColumn: 16,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar?: { n: number }) {
+  return (bar)?.n;
+}
+      `,
     },
     {
       code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar!)?.();
-}
-      `,
-      output: `
-function foo(bar?: { n: number }) {
-  return (bar)?.();
 }
       `,
       errors: [
         {
-          messageId: 'noExtraNonNullAssertion',
-          endColumn: 15,
           column: 11,
+          endColumn: 15,
           line: 3,
+          messageId: 'noExtraNonNullAssertion',
         },
       ],
+      output: `
+function foo(bar?: { n: number }) {
+  return (bar)?.();
+}
+      `,
+    },
+  ],
+  valid: [
+    {
+      code: `
+const foo: { bar: number } | null = null;
+const bar = foo!.bar;
+      `,
+    },
+    {
+      code: `
+function foo(bar: number | undefined) {
+  const bar: number = bar!;
+}
+      `,
+    },
+    {
+      code: `
+function foo(bar?: { n: number }) {
+  return bar?.n;
+}
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2166
+    {
+      code: `
+checksCounter?.textContent!.trim();
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2732
+    {
+      code: `
+function foo(key: string | null) {
+  const obj = {};
+  return obj?.[key!];
+}
+      `,
     },
   ],
 });
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 885f03290dc1..cb2d23b95812 100644
--- a/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
@@ -16,90 +16,6 @@ const onlyConstructor = {
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-extraneous-class', rule, {
-  valid: [
-    `
-class Foo {
-  public prop = 1;
-  constructor() {}
-}
-    `,
-    `
-export class CClass extends BaseClass {
-  public static helper(): void {}
-  private static privateHelper(): boolean {
-    return true;
-  }
-  constructor() {}
-}
-    `,
-    `
-class Foo {
-  constructor(public bar: string) {}
-}
-    `,
-    {
-      code: 'class Foo {}',
-      options: [{ allowEmpty: true }],
-    },
-    {
-      code: `
-class Foo {
-  constructor() {}
-}
-      `,
-      options: [{ allowConstructorOnly: true }],
-    },
-    {
-      code: `
-export class Bar {
-  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!';
-  }
-}
-    `,
-    {
-      code: `
-@FooDecorator
-class Foo {}
-      `,
-      options: [{ allowWithDecorator: true }],
-    },
-    {
-      code: `
-@FooDecorator
-class Foo {
-  constructor(foo: Foo) {
-    foo.subscribe(a => {
-      console.log(a);
-    });
-  }
-}
-      `,
-      options: [{ allowWithDecorator: true }],
-    },
-    `
-abstract class Foo {
-  abstract property: string;
-}
-    `,
-    `
-abstract class Foo {
-  abstract method(): string;
-}
-    `,
-  ],
-
   invalid: [
     {
       code: 'class Foo {}',
@@ -165,12 +81,12 @@ export default class {
 @FooDecorator
 class Foo {}
       `,
-      options: [{ allowWithDecorator: false }],
       errors: [
         {
           messageId: 'empty',
         },
       ],
+      options: [{ allowWithDecorator: false }],
     },
     {
       code: `
@@ -183,12 +99,12 @@ class Foo {
   }
 }
       `,
-      options: [{ allowWithDecorator: false }],
       errors: [
         {
           messageId: 'onlyConstructor',
         },
       ],
+      options: [{ allowWithDecorator: false }],
     },
     {
       code: `
@@ -213,4 +129,88 @@ abstract class Foo {
       errors: [onlyConstructor],
     },
   ],
+
+  valid: [
+    `
+class Foo {
+  public prop = 1;
+  constructor() {}
+}
+    `,
+    `
+export class CClass extends BaseClass {
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
+  constructor() {}
+}
+    `,
+    `
+class Foo {
+  constructor(public bar: string) {}
+}
+    `,
+    {
+      code: 'class Foo {}',
+      options: [{ allowEmpty: true }],
+    },
+    {
+      code: `
+class Foo {
+  constructor() {}
+}
+      `,
+      options: [{ allowConstructorOnly: true }],
+    },
+    {
+      code: `
+export class Bar {
+  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!';
+  }
+}
+    `,
+    {
+      code: `
+@FooDecorator
+class Foo {}
+      `,
+      options: [{ allowWithDecorator: true }],
+    },
+    {
+      code: `
+@FooDecorator
+class Foo {
+  constructor(foo: Foo) {
+    foo.subscribe(a => {
+      console.log(a);
+    });
+  }
+}
+      `,
+      options: [{ allowWithDecorator: true }],
+    },
+    `
+abstract class Foo {
+  abstract property: string;
+}
+    `,
+    `
+abstract class Foo {
+  abstract method(): string;
+}
+    `,
+  ],
 });
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 097a16928ed0..e9db3157f76b 100644
--- a/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
@@ -8,318 +8,250 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 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(() => {});
-  return Promise.resolve('value');
-}
-    `,
+  invalid: [
     {
-      options: [{ ignoreVoid: true }],
       code: `
 async function test() {
-  void Promise.resolve('value');
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
-    },
-    `
-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(() => {});
-  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)().catch(() => {});
-  return (async () => true)();
-}
-    `,
-    `
-async function test() {
-  async function returnsPromise() {}
-  await returnsPromise();
-  returnsPromise().then(
-    () => {},
-    () => {},
-  );
-  returnsPromise()
-    .then(() => {})
-    .catch(() => {});
-  returnsPromise()
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  returnsPromise().catch(() => {});
-  return returnsPromise();
-}
-    `,
-    `
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
 async function test() {
-  const x = Promise.resolve();
-  const y = x.then(() => {});
-  y.catch(() => {});
+  void Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
 async function test() {
-  Math.random() > 0.5 ? Promise.resolve().catch(() => {}) : null;
+  await Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
+      `,
+            },
+          ],
+        },
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
 async function test() {
-  Promise.resolve().catch(() => {}), 123;
-  123,
-    Promise.resolve().then(
-      () => {},
-      () => {},
-    );
-  123,
-    Promise.resolve().then(
-      () => {},
-      () => {},
-    ),
-    123;
+  Promise.resolve('value');
+  void Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
 async function test() {
-  void Promise.resolve().catch(() => {});
+  Promise.resolve('value');
+  await Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
+      `,
+            },
+          ],
+        },
+        {
+          line: 5,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
 async function test() {
-  Promise.resolve().catch(() => {}) ||
-    Promise.resolve().then(
-      () => {},
-      () => {},
-    );
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  void Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
-declare const promiseValue: Promise<number>;
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
 async function test() {
-  await promiseValue;
-  promiseValue.then(
-    () => {},
-    () => {},
-  );
-  promiseValue.then(() => {}).catch(() => {});
-  promiseValue
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promiseValue.catch(() => {});
-  return promiseValue;
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  await Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-    `,
-    `
-declare const promiseUnion: Promise<number> | number;
+      `,
+            },
+          ],
+        },
+        {
+          line: 6,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
 async function test() {
-  await promiseUnion;
-  promiseUnion.then(
-    () => {},
-    () => {},
-  );
-  promiseUnion.then(() => {}).catch(() => {});
-  promiseUnion
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promiseUnion.catch(() => {});
-  promiseValue.finally(() => {});
-  return promiseUnion;
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  void Promise.resolve('value').finally();
 }
-    `,
-    `
-declare const promiseIntersection: Promise<number> & number;
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
 async function test() {
-  await promiseIntersection;
-  promiseIntersection.then(
-    () => {},
-    () => {},
-  );
-  promiseIntersection.then(() => {}).catch(() => {});
-  promiseIntersection.catch(() => {});
-  return promiseIntersection;
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  await Promise.resolve('value').finally();
 }
-    `,
-    `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  await canThen;
-  canThen.then(
-    () => {},
-    () => {},
-  );
-  canThen.then(() => {}).catch(() => {});
-  canThen
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  canThen.catch(() => {});
-  return canThen;
-}
-    `,
-    `
-declare const intersectionPromise: Promise<number> & number;
-async function test() {
-  await (Math.random() > 0.5 ? numberPromise : 0);
-  await (Math.random() > 0.5 ? foo : 0);
-  await (Math.random() > 0.5 ? bar : 0);
-
-  await intersectionPromise;
-}
-    `,
-    `
-async function test() {
-  class Thenable {
-    then(callback: () => void): Thenable {
-      return new Thenable();
-    }
-  }
-  const thenable = new Thenable();
-
-  await thenable;
-  thenable;
-  thenable.then(() => {});
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class NonFunctionParamThenable {
-    then(param: string, param2: number): NonFunctionParamThenable {
-      return new NonFunctionParamThenable();
-    }
-  }
-  const thenable = new NonFunctionParamThenable();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-  await thenable;
-  thenable;
-  thenable.then('abc', 'def');
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class NonFunctionThenable {
-    then: number;
-  }
-  const thenable = new NonFunctionThenable();
+  callback?.();
+};
 
-  thenable;
-  thenable.then;
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+doSomething();
+      `,
+      errors: [
+        {
+          line: 11,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  void obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-  await thenable;
-  return thenable;
-}
-    `,
-    `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+  callback?.();
+};
 
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
+doSomething();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  await obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-declare const PromisePolyfill: PromisePolyfillConstructor;
+  callback?.();
+};
 
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+doSomething();
+      `,
+            },
+          ],
+        },
+        {
+          line: 12,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  void obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-  await promise;
-  promise.then(
-    () => {},
-    () => {},
-  );
-  promise.then(() => {}).catch(() => {});
-  promise
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promise.catch(() => {});
-  return promise;
-}
-    `,
+  callback?.();
+};
 
-    // optional chaining
-    `
-declare const returnsPromise: () => Promise<void> | null;
-async function test() {
-  await returnsPromise?.();
-  returnsPromise()?.then(
-    () => {},
-    () => {},
-  );
-  returnsPromise()
-    ?.then(() => {})
-    ?.catch(() => {});
-  returnsPromise()?.catch(() => {});
-  return returnsPromise();
-}
-    `,
-    `
+doSomething();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
 const doSomething = async (
   obj1: { a?: { b?: { c?: () => Promise<void> } } },
   obj2: { a?: { b?: { c: () => Promise<void> } } },
@@ -329,536 +261,607 @@ const doSomething = async (
   obj6?: { a: { b: { c?: () => Promise<void> } } },
   callback?: () => Promise<void>,
 ): Promise<void> => {
-  await obj1.a?.b?.c?.();
+  obj1.a?.b?.c?.();
   await obj2.a?.b?.c();
-  await obj3.a?.b.c?.();
-  await obj4.a.b.c?.();
-  await obj5.a?.().b?.c?.();
-  await obj6?.a.b.c?.();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-  return callback?.();
+  callback?.();
 };
 
-void doSomething();
-    `,
-    // ignoreIIFE
-    {
-      code: `
-        (async () => {
-          await something();
-        })();
+doSomething();
       `,
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-        (async () => {
-          something();
-        })();
+            },
+          ],
+        },
+        {
+          line: 13,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  void obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: '(async function foo() {})();',
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-        function foo() {
-          (async function bar() {})();
-        }
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  await obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-        const foo = () =>
-          new Promise(res => {
-            (async function () {
-              await res(1);
-            })();
-          });
+            },
+          ],
+        },
+        {
+          line: 14,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  void obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-        (async function () {
-          await res(1);
-        })();
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  await obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  void (condition && myPromise());
-}
+            },
+          ],
+        },
+        {
+          line: 15,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  void obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  await (condition && myPromise());
-}
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  await obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  condition && void myPromise();
-}
+            },
+          ],
+        },
+        {
+          line: 16,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  void obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  condition && (await myPromise());
-}
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  await obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  let condition = false;
-  condition && myPromise();
-  condition = true;
-  condition || myPromise();
-  condition ?? myPromise();
-}
+            },
+          ],
+        },
+        {
+          line: 18,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  void callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-declare const definitelyCallable: () => void;
-Promise.reject().catch(definitelyCallable);
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  await callback?.();
+};
+
+doSomething();
       `,
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {});
+            },
+          ],
+        },
+        {
+          line: 21,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+void doSomething();
       `,
-    },
-    {
-      code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {})
-  .finally(() => {});
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+await doSomething();
       `,
-      options: [{ ignoreVoid: false }],
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`;
       `,
-    },
-    {
-      code: `
-await Promise.all([Promise.resolve(), Promise.resolve()]);
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`;
       `,
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-void promiseArray;
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`;
       `,
+            },
+          ],
+        },
+      ],
     },
     {
-      // Expressions aren't checked by this rule, so this just becomes an array
-      // of number | undefined, which is fine regardless of the ignoreVoid setting.
       code: `
-[1, 2, void Promise.reject(), 3];
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.then(() => {});
       `,
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-['I', 'am', 'just', 'an', 'array'];
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`.then(() => {});
       `,
-    },
-    {
-      code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: SafeThenable<number> = Promise.resolve(5);
-0, promise;
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`.then(() => {});
       `,
-      options: [
-        {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+            },
+          ],
         },
       ],
     },
     {
       code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: SafeThenable<number> = Promise.resolve(5);
-0 ? promise : 3;
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.finally(() => {});
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`.finally(() => {});
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`.finally(() => {});
+      `,
+            },
+          ],
         },
       ],
     },
+
     {
       code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: { a: SafePromise<number> } = { a: Promise.resolve(5) };
-promise.a;
+async function test() {
+  Promise.resolve('value');
+}
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-promise;
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function test() {
+  void Promise.resolve('value');
+}
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+async function test() {
+  await Promise.resolve('value');
+}
+      `,
+            },
+          ],
+        },
       ],
+      options: [{ ignoreVoid: true }],
     },
     {
       code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: Foo = Promise.resolve(5);
-0 || promise;
+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();
+}
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: Foo = Promise.resolve(5);
-promise.finally();
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function test() {
+  void Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
+}
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+async function test() {
+  await Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-0, promise();
       `,
-      options: [
+            },
+          ],
+        },
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  void Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
+}
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  await Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
+}
+      `,
+            },
+          ],
         },
-      ],
-    },
-    {
-      code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
+        {
+          line: 5,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  void Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-0 ? promise() : 3;
       `,
-      options: [
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  await Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
+}
+      `,
+            },
+          ],
+        },
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          line: 6,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  void Promise.reject(new Error('message')).finally();
+}
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+async function test() {
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  await Promise.reject(new Error('message')).finally();
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
       code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: () => Foo = () => Promise.resolve(5);
-promise();
-      `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: () => Foo = async () => 5;
-promise().finally();
-      `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: () => SafePromise<number> = async () => 5;
-0 || promise();
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: () => SafePromise<number> = async () => 5;
-null ?? promise();
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-let promise: () => PromiseLike<number> = () => Promise.resolve(5);
-promise();
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'lib', name: 'PromiseLike' }] },
-      ],
-    },
-    {
-      code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: Foo<unknown>[];
-arrayOrPromiseTuple;
-      `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
-arrayOrPromiseTuple;
-      `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-myTag\`abc\`;
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {});
-      `,
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.catch(() => {});
-      `,
-    },
-    {
-      code: `
-declare const myTag: (strings: TemplateStringsArray) => string;
-myTag\`abc\`;
-      `,
-    },
-    {
-      code: `
-declare let x: any;
-declare const promiseArray: Array<Promise<unknown>>;
-x = promiseArray;
-      `,
-    },
-    {
-      code: `
-declare let x: Promise<number>;
-x = Promise.resolve(2);
-      `,
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function f() {
-  return promiseArray;
-}
-      `,
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function* generator() {
-  yield* promiseArray;
-}
-      `,
-    },
-    {
-      code: `
-async function* generator() {
-  yield Promise.resolve();
-}
-      `,
-    },
-    {
-      code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-promise().then(() => {});
-      `,
-      options: [
-        {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
-        },
-      ],
-    },
-
-    {
-      code: `
-        declare module 'abc' {
-          export function it(name: string, action: () => void): void;
-        }
-        it('...', () => {});
-      `,
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            { from: 'package', name: 'it', package: 'abc' },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        declare module 'abc' {
-          export function it(name: string, action: () => void): void;
-        }
-
-        it('...', () => {});
-      `,
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            { from: 'package', name: 'it', package: 'abc' },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-interface SafePromise<T> extends Promise<T> {
-  brand: 'safe';
-}
-
-declare const createSafePromise: () => SafePromise<string>;
-createSafePromise();
-      `,
-      options: [
-        {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }],
-          checkThenables: true,
-        },
-      ],
-    },
-    `
-declare const createPromiseLike: () => PromiseLike<number>;
-createPromiseLike();
-    `,
-    `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-createMyThenable();
-    `,
-  ],
-
-  invalid: [
-    {
-      code: `
-async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
-}
+async function test() {
+  (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
+}
       `,
       errors: [
         {
@@ -869,10 +872,9 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  void (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -880,10 +882,9 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  await (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -897,10 +898,9 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Promise.resolve('value');
-  void Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  (async () => true)();
+  void (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -908,10 +908,9 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Promise.resolve('value');
-  await Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  (async () => true)();
+  await (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -925,10 +924,9 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  void Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  (async () => true)();
+  (async () => true)().then(() => {});
+  void (async () => true)().catch();
 }
       `,
             },
@@ -936,27 +934,42 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  await Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
-}
-      `,
+  (async () => true)();
+  (async () => true)().then(() => {});
+  await (async () => true)().catch();
+}
+      `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  async function returnsPromise() {}
+
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
+}
+      `,
+      errors: [
         {
-          line: 6,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  void Promise.resolve('value').finally();
+  async function returnsPromise() {}
+
+  void returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
@@ -964,485 +977,256 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  await Promise.resolve('value').finally();
+  async function returnsPromise() {}
+
+  await returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
-      `,
-      errors: [
         {
-          line: 11,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  void obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  void returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  await obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  await returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
+}
       `,
             },
           ],
         },
         {
-          line: 12,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  void obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  void returnsPromise().catch();
+  returnsPromise().finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  await obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  await returnsPromise().catch();
+  returnsPromise().finally();
+}
       `,
             },
           ],
         },
         {
-          line: 13,
+          line: 8,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  void obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  void returnsPromise().finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  await obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
+async function test() {
+  async function returnsPromise() {}
 
-doSomething();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  await returnsPromise().finally();
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  Math.random() > 0.5 ? null : Promise.resolve();
+}
+      `,
+      errors: [
         {
-          line: 14,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  void obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  void (Math.random() > 0.5 ? Promise.resolve() : null);
+  Math.random() > 0.5 ? null : Promise.resolve();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  await obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  await (Math.random() > 0.5 ? Promise.resolve() : null);
+  Math.random() > 0.5 ? null : Promise.resolve();
+}
       `,
             },
           ],
         },
         {
-          line: 15,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  void obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  void (Math.random() > 0.5 ? null : Promise.resolve());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  await obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  await (Math.random() > 0.5 ? null : Promise.resolve());
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
+      `,
+      errors: [
         {
-          line: 16,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  void obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  void (Promise.resolve(), 123);
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  await obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+async function test() {
+  await (Promise.resolve(), 123);
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
       `,
             },
           ],
         },
         {
-          line: 18,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  void callback?.();
-};
-
-doSomething();
+async function test() {
+  Promise.resolve(), 123;
+  void (123, Promise.resolve());
+  123, Promise.resolve(), 123;
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  await callback?.();
-};
-
-doSomething();
+async function test() {
+  Promise.resolve(), 123;
+  await (123, Promise.resolve());
+  123, Promise.resolve(), 123;
+}
       `,
             },
           ],
         },
         {
-          line: 21,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-void doSomething();
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  void (123, Promise.resolve(), 123);
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-await doSomething();
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  await (123, Promise.resolve(), 123);
+}
       `,
             },
           ],
@@ -1451,106 +1235,177 @@ await doSomething();
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`;
+async function test() {
+  void Promise.resolve();
+}
       `,
       errors: [
         {
           line: 3,
-          messageId: 'floatingVoid',
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`;
+async function test() {
+  await Promise.resolve();
+}
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function test() {
+  const promise = new Promise((resolve, reject) => resolve('value'));
+  promise;
+}
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`;
+async function test() {
+  const promise = new Promise((resolve, reject) => resolve('value'));
+  await promise;
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.then(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+void returnsPromise();
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`.then(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+await returnsPromise();
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
+      code: `
+async function returnsPromise() {
+  return 'value';
+}
+void /* ... */ returnsPromise();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`.then(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+await /* ... */ returnsPromise();
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.finally(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+1, returnsPromise();
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`.finally(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+await (1, returnsPromise());
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function returnsPromise() {
+  return 'value';
+}
+bool ? returnsPromise() : null;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`.finally(() => {});
+async function returnsPromise() {
+  return 'value';
+}
+await (bool ? returnsPromise() : null);
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
-
     {
-      options: [{ ignoreVoid: true }],
       code: `
 async function test() {
-  Promise.resolve('value');
+  const obj = { foo: Promise.resolve() };
+  obj.foo;
 }
       `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void Promise.resolve('value');
+  const obj = { foo: Promise.resolve() };
+  void obj.foo;
 }
       `,
             },
@@ -1558,7 +1413,8 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await Promise.resolve('value');
+  const obj = { foo: Promise.resolve() };
+  await obj.foo;
 }
       `,
             },
@@ -1569,10 +1425,7 @@ 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();
+  new Promise(resolve => resolve());
 }
       `,
       errors: [
@@ -1584,10 +1437,7 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  void new Promise(resolve => resolve());
 }
       `,
             },
@@ -1595,162 +1445,204 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  await new Promise(resolve => resolve());
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
+      `,
+      errors: [
         {
-          line: 4,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  void Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  void promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  await Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  await promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
           ],
         },
         {
-          line: 5,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  void Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  promiseValue;
+  void promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  await Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
+  promiseValue;
+  await promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
           ],
         },
         {
-          line: 6,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  void Promise.reject(new Error('message')).finally();
+  promiseValue;
+  promiseValue.then(() => {});
+  void promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  await Promise.reject(new Error('message')).finally();
+  promiseValue;
+  promiseValue.then(() => {});
+  await promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
-}
-      `,
-      errors: [
         {
-          line: 3,
+          line: 8,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  void (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  void promiseValue.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseValue: Promise<number>;
+
 async function test() {
-  await (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  await promiseValue.finally();
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const promiseUnion: Promise<number> | number;
+
+async function test() {
+  promiseUnion;
+}
+      `,
+      errors: [
         {
-          line: 4,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseUnion: Promise<number> | number;
+
 async function test() {
-  (async () => true)();
-  void (async () => true)().then(() => {});
-  (async () => true)().catch();
+  void promiseUnion;
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseUnion: Promise<number> | number;
+
 async function test() {
-  (async () => true)();
-  await (async () => true)().then(() => {});
-  (async () => true)().catch();
+  await promiseUnion;
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const promiseIntersection: Promise<number> & number;
+
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+}
+      `,
+      errors: [
         {
           line: 5,
           messageId: 'floatingVoid',
@@ -1758,117 +1650,119 @@ async function test() {
             {
               messageId: 'floatingFixVoid',
               output: `
+declare const promiseIntersection: Promise<number> & number;
+
 async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  void (async () => true)().catch();
+  void promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+declare const promiseIntersection: Promise<number> & number;
+
 async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  await (async () => true)().catch();
+  await promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
-}
-      `,
-      errors: [
         {
-          line: 5,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  async function returnsPromise() {}
+declare const promiseIntersection: Promise<number> & number;
 
-  void returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+async function test() {
+  promiseIntersection;
+  void promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  async function returnsPromise() {}
+declare const promiseIntersection: Promise<number> & number;
 
-  await returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+async function test() {
+  promiseIntersection;
+  await promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
           ],
         },
         {
-          line: 6,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  async function returnsPromise() {}
+declare const promiseIntersection: Promise<number> & number;
 
-  returnsPromise();
-  void returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  void promiseIntersection.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  async function returnsPromise() {}
+declare const promiseIntersection: Promise<number> & number;
 
-  returnsPromise();
-  await returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  await promiseIntersection.catch();
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
+}
+      `,
+      errors: [
         {
-          line: 7,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  async function returnsPromise() {}
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  returnsPromise();
-  returnsPromise().then(() => {});
-  void returnsPromise().catch();
-  returnsPromise().finally();
+  void canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
@@ -1876,31 +1770,33 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  async function returnsPromise() {}
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  returnsPromise();
-  returnsPromise().then(() => {});
-  await returnsPromise().catch();
-  returnsPromise().finally();
+  await canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
           ],
         },
         {
-          line: 8,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  async function returnsPromise() {}
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  void returnsPromise().finally();
+  canThen;
+  void canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
@@ -1908,37 +1804,33 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  async function returnsPromise() {}
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  await returnsPromise().finally();
+  canThen;
+  await canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  Math.random() > 0.5 ? null : Promise.resolve();
-}
-      `,
-      errors: [
         {
-          line: 3,
+          line: 8,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void (Math.random() > 0.5 ? Promise.resolve() : null);
-  Math.random() > 0.5 ? null : Promise.resolve();
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  canThen;
+  canThen.then(() => {});
+  void canThen.catch();
+  canThen.finally();
 }
       `,
             },
@@ -1946,23 +1838,33 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await (Math.random() > 0.5 ? Promise.resolve() : null);
-  Math.random() > 0.5 ? null : Promise.resolve();
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  canThen;
+  canThen.then(() => {});
+  await canThen.catch();
+  canThen.finally();
 }
       `,
             },
           ],
         },
         {
-          line: 4,
+          line: 9,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  void (Math.random() > 0.5 ? null : Promise.resolve());
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  void canThen.finally();
 }
       `,
             },
@@ -1970,8 +1872,13 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  await (Math.random() > 0.5 ? null : Promise.resolve());
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  await canThen.finally();
 }
       `,
             },
@@ -1982,23 +1889,35 @@ async function test() {
     {
       code: `
 async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  thenable;
+  thenable.then(() => {});
 }
       `,
       errors: [
         {
-          line: 3,
+          line: 10,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void (Promise.resolve(), 123);
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  void thenable;
+  thenable.then(() => {});
 }
       `,
             },
@@ -2006,25 +1925,37 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await (Promise.resolve(), 123);
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  await thenable;
+  thenable.then(() => {});
 }
       `,
             },
           ],
         },
         {
-          line: 4,
+          line: 11,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Promise.resolve(), 123;
-  void (123, Promise.resolve());
-  123, Promise.resolve(), 123;
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  thenable;
+  void thenable.then(() => {});
 }
       `,
             },
@@ -2032,85 +1963,210 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Promise.resolve(), 123;
-  await (123, Promise.resolve());
-  123, Promise.resolve(), 123;
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  thenable;
+  await thenable.then(() => {});
 }
       `,
             },
           ],
         },
+      ],
+      options: [{ checkThenables: true }],
+    },
+    {
+      code: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  promise.then(() => {});
+  promise.catch();
+}
+      `,
+      errors: [
         {
-          line: 5,
+          line: 18,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  void (123, Promise.resolve(), 123);
+  const promise = new PromisePolyfill(() => {});
+
+  void promise;
+  promise.then(() => {});
+  promise.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  await (123, Promise.resolve(), 123);
+  const promise = new PromisePolyfill(() => {});
+
+  await promise;
+  promise.then(() => {});
+  promise.catch();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
+        {
+          line: 19,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  void Promise.resolve();
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  void promise.then(() => {});
+  promise.catch();
 }
       `,
-      options: [{ ignoreVoid: false }],
-      errors: [
-        {
-          line: 3,
-          messageId: 'floating',
-          suggestions: [
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  await Promise.resolve();
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  await promise.then(() => {});
+  promise.catch();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
+        {
+          line: 20,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  const promise = new Promise((resolve, reject) => resolve('value'));
+  const promise = new PromisePolyfill(() => {});
+
   promise;
+  promise.then(() => {});
+  void promise.catch();
 }
       `,
-      options: [{ ignoreVoid: false }],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floating',
-          suggestions: [
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
 async function test() {
-  const promise = new Promise((resolve, reject) => resolve('value'));
-  await promise;
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  promise.then(() => {});
+  await promise.catch();
 }
       `,
             },
@@ -2120,24 +2176,29 @@ async function test() {
     },
     {
       code: `
-async function returnsPromise() {
-  return 'value';
-}
-void returnsPromise();
+        (async () => {
+          await something();
+        })();
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        void (async () => {
+          await something();
+        })();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await returnsPromise();
+        await (async () => {
+          await something();
+        })();
       `,
             },
           ],
@@ -2145,26 +2206,30 @@ await returnsPromise();
       ],
     },
     {
-      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
-async function returnsPromise() {
-  return 'value';
-}
-void /* ... */ returnsPromise();
+        (async () => {
+          something();
+        })();
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        void (async () => {
+          something();
+        })();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await /* ... */ returnsPromise();
+        await (async () => {
+          something();
+        })();
       `,
             },
           ],
@@ -2172,26 +2237,19 @@ await /* ... */ returnsPromise();
       ],
     },
     {
-      code: `
-async function returnsPromise() {
-  return 'value';
-}
-1, returnsPromise();
-      `,
-      options: [{ ignoreVoid: false }],
+      code: '(async function foo() {})();',
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 1,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: 'void (async function foo() {})();',
+            },
             {
               messageId: 'floatingFixAwait',
-              output: `
-async function returnsPromise() {
-  return 'value';
-}
-await (1, returnsPromise());
-      `,
+              output: 'await (async function foo() {})();',
             },
           ],
         },
@@ -2199,24 +2257,29 @@ await (1, returnsPromise());
     },
     {
       code: `
-async function returnsPromise() {
-  return 'value';
-}
-bool ? returnsPromise() : null;
+        function foo() {
+          (async function bar() {})();
+        }
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 3,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        function foo() {
+          void (async function bar() {})();
+        }
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await (bool ? returnsPromise() : null);
+        function foo() {
+          await (async function bar() {})();
+        }
       `,
             },
           ],
@@ -2225,10 +2288,12 @@ await (bool ? returnsPromise() : null);
     },
     {
       code: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  obj.foo;
-}
+        const foo = () =>
+          new Promise(res => {
+            (async function () {
+              await res(1);
+            })();
+          });
       `,
       errors: [
         {
@@ -2238,19 +2303,23 @@ async function test() {
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  void obj.foo;
-}
+        const foo = () =>
+          new Promise(res => {
+            void (async function () {
+              await res(1);
+            })();
+          });
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  await obj.foo;
-}
+        const foo = () =>
+          new Promise(res => {
+            await (async function () {
+              await res(1);
+            })();
+          });
       `,
             },
           ],
@@ -2259,29 +2328,29 @@ async function test() {
     },
     {
       code: `
-async function test() {
-  new Promise(resolve => resolve());
-}
+        (async function () {
+          await res(1);
+        })();
       `,
       errors: [
         {
-          line: 3,
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  void new Promise(resolve => resolve());
-}
+        void (async function () {
+          await res(1);
+        })();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  await new Promise(resolve => resolve());
-}
+        await (async function () {
+          await res(1);
+        })();
       `,
             },
           ],
@@ -2290,279 +2359,273 @@ async function test() {
     },
     {
       code: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+        (async function () {
+          Promise.resolve();
+        })();
       `,
       errors: [
         {
-          line: 5,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  void promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+        (async function () {
+          void Promise.resolve();
+        })();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  await promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+        (async function () {
+          await Promise.resolve();
+        })();
       `,
             },
           ],
         },
+      ],
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
+      `,
+      errors: [
         {
-          line: 6,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  void promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  void promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  await promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  await promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
         {
-          line: 7,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  void promiseValue.catch();
-  promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  void promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  await promiseValue.catch();
-  promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  await promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
         {
-          line: 8,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  void promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  void promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  await promiseValue.finally();
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  await promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-declare const promiseUnion: Promise<number> | number;
-
-async function test() {
-  promiseUnion;
-}
-      `,
-      errors: [
         {
-          line: 5,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseUnion: Promise<number> | number;
-
-async function test() {
-  void promiseUnion;
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  void promiseIntersection.finally();
+})();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseUnion: Promise<number> | number;
-
-async function test() {
-  await promiseUnion;
-}
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  await promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  void condition || myPromise();
 }
       `,
       errors: [
         {
-          line: 5,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  void promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  void (void condition || myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  await promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  await (void condition || myPromise());
 }
       `,
             },
           ],
         },
-        {
-          line: 6,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const promiseIntersection: Promise<number> & number;
+      ],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  promiseIntersection;
-  void promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  (await condition) && myPromise();
 }
       `,
-            },
+      errors: [
+        {
+          line: 6,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  promiseIntersection;
-  await promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  await ((await condition) && myPromise());
 }
       `,
             },
           ],
         },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  condition && myPromise();
+}
+      `,
+      errors: [
         {
-          line: 7,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  void promiseIntersection.catch();
+  void (condition && myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
 
-async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  await promiseIntersection.catch();
+  await (condition && myPromise());
 }
       `,
             },
@@ -2572,14 +2635,11 @@ async function test() {
     },
     {
       code: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
 
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  condition || myPromise();
 }
       `,
       errors: [
@@ -2590,571 +2650,542 @@ async function test() {
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
 
-  void canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  void (condition || myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
 
-  await canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  await (condition || myPromise());
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
+
+  condition ?? myPromise();
+}
+      `,
+      errors: [
         {
-          line: 7,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
 
-  canThen;
-  void canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  void (condition ?? myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
 
-  canThen;
-  await canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  await (condition ?? myPromise());
 }
       `,
             },
           ],
         },
-        {
-          line: 8,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  void canThen.catch();
-  canThen.finally();
+      ],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = true;
+  condition && myPromise;
 }
       `,
-            },
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  await canThen.catch();
-  canThen.finally();
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = true;
+  await (condition && myPromise);
 }
       `,
             },
           ],
         },
-        {
-          line: 9,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  void canThen.finally();
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = false;
+  condition || myPromise;
 }
       `,
-            },
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  await canThen.finally();
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = false;
+  await (condition || myPromise);
 }
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
-
-  thenable;
-  thenable.then(() => {});
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = null;
+  condition ?? myPromise;
 }
       `,
       errors: [
         {
-          line: 10,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
-
-  void thenable;
-  thenable.then(() => {});
-}
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
-
-  await thenable;
-  thenable.then(() => {});
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = null;
+  await (condition ?? myPromise);
 }
       `,
             },
           ],
         },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  condition || condition || myPromise();
+}
+      `,
+      errors: [
         {
-          line: 11,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
 
-  thenable;
-  void thenable.then(() => {});
+  void (condition || condition || myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
 
-  thenable;
-  await thenable.then(() => {});
+  await (condition || condition || myPromise());
 }
       `,
             },
           ],
         },
       ],
-      options: [{ checkThenables: true }],
     },
     {
       code: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  promise;
-  promise.then(() => {});
-  promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
       errors: [
         {
-          line: 18,
-          messageId: 'floatingVoid',
+          line: 4,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+void Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  void promise;
-  promise.then(() => {});
-  promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+await Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  await promise;
-  promise.then(() => {});
-  promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
         {
-          line: 19,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+void Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  promise;
-  void promise.then(() => {});
-  promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+await Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  promise;
-  await promise.then(() => {});
-  promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
         {
-          line: 20,
-          messageId: 'floatingVoid',
+          line: 6,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+void Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  promise;
-  promise.then(() => {});
-  void promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+await Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  promise;
-  promise.then(() => {});
-  await promise.catch();
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        (async () => {
-          await something();
-        })();
-      `,
-      errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 7,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        void (async () => {
-          await something();
-        })();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+void Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async () => {
-          await something();
-        })();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+await Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        (async () => {
-          something();
-        })();
-      `,
-      errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 10,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        void (async () => {
-          something();
-        })();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+void Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async () => {
-          something();
-        })();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+await Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: '(async function foo() {})();',
-      errors: [
         {
-          line: 1,
-          messageId: 'floatingVoid',
+          line: 11,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
-              output: 'void (async function foo() {})();',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+void Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
             },
             {
               messageId: 'floatingFixAwait',
-              output: 'await (async function foo() {})();',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+await Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        function foo() {
-          (async function bar() {})();
-        }
-      `,
-      errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 12,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        function foo() {
-          void (async function bar() {})();
-        }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-        function foo() {
-          await (async function bar() {})();
-        }
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+void Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+await Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        const foo = () =>
-          new Promise(res => {
-            (async function () {
-              await res(1);
-            })();
-          });
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 13,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        const foo = () =>
-          new Promise(res => {
-            void (async function () {
-              await res(1);
-            })();
-          });
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+void Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        const foo = () =>
-          new Promise(res => {
-            await (async function () {
-              await res(1);
-            })();
-          });
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+await Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
@@ -3163,9 +3194,7 @@ async function test() {
     },
     {
       code: `
-        (async function () {
-          await res(1);
-        })();
+Promise.reject() || 3;
       `,
       errors: [
         {
@@ -3175,17 +3204,13 @@ async function test() {
             {
               messageId: 'floatingFixVoid',
               output: `
-        void (async function () {
-          await res(1);
-        })();
+void (Promise.reject() || 3);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async function () {
-          await res(1);
-        })();
+await (Promise.reject() || 3);
       `,
             },
           ],
@@ -3194,274 +3219,297 @@ async function test() {
     },
     {
       code: `
-        (async function () {
-          Promise.resolve();
-        })();
+void Promise.resolve().then(() => {}, undefined);
       `,
-      options: [{ ignoreIIFE: true }],
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 2,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-        (async function () {
-          void Promise.resolve();
-        })();
+await Promise.resolve().then(() => {}, undefined);
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+declare const maybeCallable: string | (() => void);
+Promise.resolve().then(() => {}, maybeCallable);
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-        (async function () {
-          await Promise.resolve();
-        })();
+declare const maybeCallable: string | (() => void);
+await Promise.resolve().then(() => {}, maybeCallable);
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
-      options: [{ ignoreIIFE: true }],
       errors: [
         {
           line: 4,
-          messageId: 'floatingVoid',
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  void promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  await promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+await Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
         {
           line: 5,
-          messageId: 'floatingVoid',
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  void promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  await promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+await Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
         {
           line: 6,
-          messageId: 'floatingVoid',
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  void promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+await Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
+          ],
+        },
+        {
+          line: 7,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  await promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+await Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
         {
-          line: 7,
-          messageId: 'floatingVoid',
+          line: 10,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  void promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+await Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
+          ],
+        },
+        {
+          line: 11,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  await promiseIntersection.finally();
-})();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+await Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  void condition || myPromise();
-}
-      `,
-      errors: [
         {
-          line: 6,
-          messageId: 'floatingVoid',
+          line: 12,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  void (void condition || myPromise());
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+await Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
+          ],
+        },
+        {
+          line: 13,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-  await (void condition || myPromise());
-}
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+await Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  (await condition) && myPromise();
-}
+Promise.reject() || 3;
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 6,
+          line: 2,
           messageId: 'floating',
           suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  await ((await condition) && myPromise());
-}
+await (Promise.reject() || 3);
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  condition && myPromise();
-}
+Promise.reject().finally(() => {});
       `,
       errors: [
         {
-          line: 6,
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  void (condition && myPromise());
-}
+void Promise.reject().finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  await (condition && myPromise());
-}
+await Promise.reject().finally(() => {});
       `,
             },
           ],
@@ -3470,78 +3518,56 @@ async function foo() {
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  condition || myPromise();
-}
+Promise.reject()
+  .finally(() => {})
+  .finally(() => {});
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'floatingVoid',
+          line: 2,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  void (condition || myPromise());
-}
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  await (condition || myPromise());
-}
+await Promise.reject()
+  .finally(() => {})
+  .finally(() => {});
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
-
-  condition ?? myPromise();
-}
+Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
       errors: [
         {
-          line: 6,
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
-
-  void (condition ?? myPromise());
-}
+void Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
-
-  await (condition ?? myPromise());
-}
+await Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
             },
           ],
@@ -3550,54 +3576,29 @@ async function foo() {
     },
     {
       code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = true;
-  condition && myPromise;
-}
+Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = true;
-  await (condition && myPromise);
-}
+void Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
             },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = false;
-  condition || myPromise;
-}
-      `,
-      options: [{ ignoreVoid: false }],
-      errors: [
-        {
-          line: 5,
-          messageId: 'floating',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = false;
-  await (condition || myPromise);
-}
+await Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
             },
           ],
@@ -3606,26 +3607,26 @@ async function foo() {
     },
     {
       code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = null;
-  condition ?? myPromise;
-}
+declare const returnsPromise: () => Promise<void> | null;
+returnsPromise()?.finally(() => {});
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 3,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const returnsPromise: () => Promise<void> | null;
+void returnsPromise()?.finally(() => {});
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = null;
-  await (condition ?? myPromise);
-}
+declare const returnsPromise: () => Promise<void> | null;
+await returnsPromise()?.finally(() => {});
       `,
             },
           ],
@@ -3634,38 +3635,26 @@ async function foo() {
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  condition || condition || myPromise();
-}
+const promiseIntersection: Promise<number> & number;
+promiseIntersection.finally(() => {});
       `,
       errors: [
         {
-          line: 6,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  void (condition || condition || myPromise());
-}
+const promiseIntersection: Promise<number> & number;
+void promiseIntersection.finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
-
-  await (condition || condition || myPromise());
-}
+const promiseIntersection: Promise<number> & number;
+await promiseIntersection.finally(() => {});
       `,
             },
           ],
@@ -3674,633 +3663,643 @@ async function foo() {
     },
     {
       code: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+Promise.resolve().finally(() => {}), 123;
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-void Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+void (Promise.resolve().finally(() => {}), 123);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-await Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+await (Promise.resolve().finally(() => {}), 123);
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+(async () => true)().finally();
+      `,
+      errors: [
         {
-          line: 5,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-void Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+void (async () => true)().finally();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-await Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+await (async () => true)().finally();
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+Promise.reject(new Error('message')).finally(() => {});
+      `,
+      errors: [
         {
-          line: 6,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-void Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+void Promise.reject(new Error('message')).finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-await Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+await Promise.reject(new Error('message')).finally(() => {});
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  maybePromiseArray?.[0];
+}
+      `,
+      errors: [
         {
-          line: 7,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 5,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-void Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  void maybePromiseArray?.[0];
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-await Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  await maybePromiseArray?.[0];
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+[1, 2, 3].map(() => Promise.reject());
+      `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+declare const array: unknown[];
+array.map(() => Promise.reject());
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+void promiseArray;
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArray' }],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+async function f() {
+  await promiseArray;
+}
+      `,
+      errors: [{ line: 4, messageId: 'floatingPromiseArray' }],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+[1, 2, Promise.reject(), 3];
+      `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+[1, 2, Promise.reject().catch(() => {}), 3];
+      `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+const data = ['test'];
+data.map(async () => {
+  await new Promise((_res, rej) => setTimeout(rej, 1000));
+});
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+function _<T, S extends Array<T | Array<T | Promise<T>>>>(
+  maybePromiseArrayArray: S | undefined,
+): void {
+  maybePromiseArrayArray?.[0];
+}
+      `,
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+function f<T extends Array<Promise<number>>>(a: T): void {
+  a;
+}
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+declare const a: Array<Promise<number>> | undefined;
+a;
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+function f<T extends Array<Promise<number>>>(a: T | undefined): void {
+  a;
+}
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+[Promise.reject()] as const;
+      `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+declare function cursed(): [Promise<number>, Promise<string>];
+cursed();
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+[
+  'Type Argument number ',
+  1,
+  'is not',
+  Promise.resolve(),
+  'but it still is flagged',
+] as const;
+      `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+        declare const arrayOrPromiseTuple:
+          | Array<number>
+          | [number, number, Promise<unknown>, string];
+        arrayOrPromiseTuple;
+      `,
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+        declare const okArrayOrPromiseArray: Array<number> | Array<Promise<unknown>>;
+        okArrayOrPromiseArray;
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+interface UnsafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): UnsafeThenable<TResult1 | TResult2>;
+}
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+promise;
+      `,
+      errors: [
         {
-          line: 10,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 15,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-void Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface UnsafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): UnsafeThenable<TResult1 | TResult2>;
+}
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+void promise;
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-await Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface UnsafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): UnsafeThenable<TResult1 | TResult2>;
+}
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+await promise;
       `,
             },
           ],
         },
+      ],
+      options: [
         {
-          line: 11,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          checkThenables: true,
+        },
+      ],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+promise.catch();
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-void Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+void promise.catch();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-await Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+await promise.catch();
       `,
             },
           ],
         },
-        {
-          line: 12,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+      ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+promise().finally();
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-void Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+void promise().finally();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-await Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+await promise().finally();
       `,
             },
           ],
         },
+      ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+0 ? promise.catch() : 2;
+      `,
+      errors: [
         {
-          line: 13,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-void Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+void (0 ? promise.catch() : 2);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-await Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+await (0 ? promise.catch() : 2);
       `,
             },
           ],
         },
       ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
     },
     {
       code: `
-Promise.reject() || 3;
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+null ?? promise().catch();
       `,
       errors: [
         {
-          line: 2,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void (Promise.reject() || 3);
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+void (null ?? promise().catch());
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.reject() || 3);
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+await (null ?? promise().catch());
       `,
             },
           ],
         },
       ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
     },
     {
       code: `
-void Promise.resolve().then(() => {}, undefined);
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: Foo<unknown>[];
+arrayOrPromiseTuple;
+      `,
+      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
+    },
+    // an array containing elements of `Promise` type and a branded Promise type will be treated as just an ordinary `Promise`.
+    // see https://github.com/typescript-eslint/typescript-eslint/pull/8502#issuecomment-2105734406
+    {
+      code: `
+type SafePromise = Promise<number> & { hey?: string };
+let foo: SafePromise = Promise.resolve(1);
+let bar = [Promise.resolve(2), foo];
+bar;
+      `,
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
+arrayOrPromiseTuple;
+      `,
+      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
+    },
+    {
+      code: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+myTag\`abc\`;
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 2,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+void myTag\`abc\`;
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.resolve().then(() => {}, undefined);
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+await myTag\`abc\`;
       `,
             },
           ],
         },
       ],
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
     },
     {
       code: `
-declare const maybeCallable: string | (() => void);
-Promise.resolve().then(() => {}, maybeCallable);
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        unsafe('...', () => {});
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 3,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 4,
+          messageId: 'floatingVoid',
+
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        void unsafe('...', () => {});
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-await Promise.resolve().then(() => {}, maybeCallable);
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        await unsafe('...', () => {});
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowForKnownSafeCalls: [
+            {
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+        declare function it(...args: unknown[]): Promise<void>;
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        it('...', () => {}).then(() => {});
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
           line: 4,
-          messageId: 'floatingUselessRejectionHandler',
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        void it('...', () => {}).then(() => {});
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-await Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+        declare function it(...args: unknown[]): Promise<void>;
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        await it('...', () => {}).then(() => {});
       `,
             },
           ],
         },
+      ],
+      options: [
         {
-          line: 5,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
+          allowForKnownSafeCalls: [
             {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-await Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
-      `,
-            },
-          ],
-        },
-        {
-          line: 6,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-await Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
-      `,
-            },
-          ],
-        },
-        {
-          line: 7,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-await Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
-      `,
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
             },
           ],
         },
-        {
-          line: 10,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+      ],
+    },
+    {
+      code: `
+        declare function it(...args: unknown[]): Promise<void>;
 
-await Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        it('...', () => {}).finally(() => {});
       `,
-            },
-          ],
-        },
+      errors: [
         {
-          line: 11,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+        declare function it(...args: unknown[]): Promise<void>;
 
-Promise.resolve().catch(undefined);
-await Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        void it('...', () => {}).finally(() => {});
       `,
             },
-          ],
-        },
-        {
-          line: 12,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+        declare function it(...args: unknown[]): Promise<void>;
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-await Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        await it('...', () => {}).finally(() => {});
       `,
             },
           ],
         },
+      ],
+      options: [
         {
-          line: 13,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
+          allowForKnownSafeCalls: [
             {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-await Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
-      `,
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
             },
           ],
         },
@@ -4308,67 +4307,99 @@ Promise.resolve().catch(definitelyCallable);
     },
     {
       code: `
-Promise.reject() || 3;
+declare const createPromise: () => PromiseLike<number>;
+createPromise();
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 2,
-          messageId: 'floating',
+          line: 3,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const createPromise: () => PromiseLike<number>;
+void createPromise();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.reject() || 3);
+declare const createPromise: () => PromiseLike<number>;
+await createPromise();
       `,
             },
           ],
         },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-Promise.reject().finally(() => {});
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+createMyThenable();
       `,
       errors: [
         {
-          line: 2,
+          line: 8,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject().finally(() => {});
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+void createMyThenable();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject().finally(() => {});
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+await createMyThenable();
       `,
             },
           ],
         },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-Promise.reject()
-  .finally(() => {})
-  .finally(() => {});
+declare const createPromise: () => Promise<number>;
+createPromise();
       `,
-      options: [{ ignoreVoid: false }],
       errors: [
         {
-          line: 2,
-          messageId: 'floating',
+          line: 3,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const createPromise: () => Promise<number>;
+void createPromise();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .finally(() => {})
-  .finally(() => {});
+declare const createPromise: () => Promise<number>;
+await createPromise();
       `,
             },
           ],
@@ -4377,32 +4408,29 @@ await Promise.reject()
     },
     {
       code: `
-Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+createMyPromise();
       `,
       errors: [
         {
-          line: 2,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+void createMyPromise();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+await createMyPromise();
       `,
             },
           ],
@@ -4411,57 +4439,69 @@ await Promise.reject()
     },
     {
       code: `
-Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+createMyPromise();
       `,
       errors: [
         {
-          line: 2,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+void createMyPromise();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+await createMyPromise();
       `,
             },
           ],
         },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-declare const returnsPromise: () => Promise<void> | null;
-returnsPromise()?.finally(() => {});
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  yield x;
+}
       `,
       errors: [
         {
-          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const returnsPromise: () => Promise<void> | null;
-void returnsPromise()?.finally(() => {});
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  void (yield x);
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const returnsPromise: () => Promise<void> | null;
-await returnsPromise()?.finally(() => {});
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  await (yield x);
+}
       `,
             },
           ],
@@ -4470,26 +4510,31 @@ await returnsPromise()?.finally(() => {});
     },
     {
       code: `
-const promiseIntersection: Promise<number> & number;
-promiseIntersection.finally(() => {});
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  yield* x;
+}
       `,
       errors: [
         {
-          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const promiseIntersection: Promise<number> & number;
-void promiseIntersection.finally(() => {});
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  void (yield* x);
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const promiseIntersection: Promise<number> & number;
-await promiseIntersection.finally(() => {});
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  await (yield* x);
+}
       `,
             },
           ],
@@ -4498,23 +4543,26 @@ await promiseIntersection.finally(() => {});
     },
     {
       code: `
-Promise.resolve().finally(() => {}), 123;
+const value = {};
+value as Promise<number>;
       `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void (Promise.resolve().finally(() => {}), 123);
+const value = {};
+void (value as Promise<number>);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.resolve().finally(() => {}), 123);
+const value = {};
+await (value as Promise<number>);
       `,
             },
           ],
@@ -4523,7 +4571,7 @@ await (Promise.resolve().finally(() => {}), 123);
     },
     {
       code: `
-(async () => true)().finally();
+({}) as Promise<number> & number;
       `,
       errors: [
         {
@@ -4533,13 +4581,13 @@ await (Promise.resolve().finally(() => {}), 123);
             {
               messageId: 'floatingFixVoid',
               output: `
-void (async () => true)().finally();
+void (({}) as Promise<number> & number);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (async () => true)().finally();
+await (({}) as Promise<number> & number);
       `,
             },
           ],
@@ -4548,7 +4596,7 @@ await (async () => true)().finally();
     },
     {
       code: `
-Promise.reject(new Error('message')).finally(() => {});
+({}) as Promise<number> & { yolo?: string };
       `,
       errors: [
         {
@@ -4558,13 +4606,13 @@ Promise.reject(new Error('message')).finally(() => {});
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject(new Error('message')).finally(() => {});
+void (({}) as Promise<number> & { yolo?: string });
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject(new Error('message')).finally(() => {});
+await (({}) as Promise<number> & { yolo?: string });
       `,
             },
           ],
@@ -4573,911 +4621,863 @@ await Promise.reject(new Error('message')).finally(() => {});
     },
     {
       code: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  maybePromiseArray?.[0];
-}
+<Promise<number>>{};
       `,
       errors: [
         {
-          line: 5,
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  void maybePromiseArray?.[0];
-}
+void (<Promise<number>>{});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  await maybePromiseArray?.[0];
-}
+await (<Promise<number>>{});
       `,
             },
           ],
         },
       ],
     },
-    {
-      code: `
-[1, 2, 3].map(() => Promise.reject());
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const array: unknown[];
-array.map(() => Promise.reject());
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-void promiseArray;
-      `,
-      options: [{ ignoreVoid: false }],
-      errors: [{ line: 3, messageId: 'floatingPromiseArray' }],
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function f() {
-  await promiseArray;
+  ],
+
+  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(() => {});
+  return Promise.resolve('value');
 }
-      `,
-      options: [{ ignoreVoid: false }],
-      errors: [{ line: 4, messageId: 'floatingPromiseArray' }],
-    },
-    {
-      code: `
-[1, 2, Promise.reject(), 3];
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-[1, 2, Promise.reject().catch(() => {}), 3];
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
+    `,
     {
       code: `
-const data = ['test'];
-data.map(async () => {
-  await new Promise((_res, rej) => setTimeout(rej, 1000));
-});
+async function test() {
+  void Promise.resolve('value');
+}
       `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreVoid: true }],
     },
-    {
-      code: `
-function _<T, S extends Array<T | Array<T | Promise<T>>>>(
-  maybePromiseArrayArray: S | undefined,
-): void {
-  maybePromiseArrayArray?.[0];
+    `
+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(() => {});
+  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)().catch(() => {});
+  return (async () => true)();
+}
+    `,
+    `
+async function test() {
+  async function returnsPromise() {}
+  await returnsPromise();
+  returnsPromise().then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {});
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  returnsPromise().catch(() => {});
+  return returnsPromise();
+}
+    `,
+    `
+async function test() {
+  const x = Promise.resolve();
+  const y = x.then(() => {});
+  y.catch(() => {});
+}
+    `,
+    `
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve().catch(() => {}) : null;
+}
+    `,
+    `
+async function test() {
+  Promise.resolve().catch(() => {}), 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(
+      () => {},
+      () => {},
+    );
+}
+    `,
+    `
+declare const promiseValue: Promise<number>;
+async function test() {
+  await promiseValue;
+  promiseValue.then(
+    () => {},
+    () => {},
+  );
+  promiseValue.then(() => {}).catch(() => {});
+  promiseValue
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promiseValue.catch(() => {});
+  return promiseValue;
+}
+    `,
+    `
+declare const promiseUnion: Promise<number> | number;
+async function test() {
+  await promiseUnion;
+  promiseUnion.then(
+    () => {},
+    () => {},
+  );
+  promiseUnion.then(() => {}).catch(() => {});
+  promiseUnion
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promiseUnion.catch(() => {});
+  promiseValue.finally(() => {});
+  return promiseUnion;
+}
+    `,
+    `
+declare const promiseIntersection: Promise<number> & number;
+async function test() {
+  await promiseIntersection;
+  promiseIntersection.then(
+    () => {},
+    () => {},
+  );
+  promiseIntersection.then(() => {}).catch(() => {});
+  promiseIntersection.catch(() => {});
+  return promiseIntersection;
+}
+    `,
+    `
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
+
+  await canThen;
+  canThen.then(
+    () => {},
+    () => {},
+  );
+  canThen.then(() => {}).catch(() => {});
+  canThen
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  canThen.catch(() => {});
+  return canThen;
+}
+    `,
+    `
+declare const intersectionPromise: Promise<number> & number;
+async function test() {
+  await (Math.random() > 0.5 ? numberPromise : 0);
+  await (Math.random() > 0.5 ? foo : 0);
+  await (Math.random() > 0.5 ? bar : 0);
+
+  await intersectionPromise;
+}
+    `,
+    `
+async function test() {
+  class Thenable {
+    then(callback: () => void): Thenable {
+      return new Thenable();
+    }
+  }
+  const thenable = new Thenable();
+
+  await thenable;
+  thenable;
+  thenable.then(() => {});
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class NonFunctionParamThenable {
+    then(param: string, param2: number): NonFunctionParamThenable {
+      return new NonFunctionParamThenable();
+    }
+  }
+  const thenable = new NonFunctionParamThenable();
+
+  await thenable;
+  thenable;
+  thenable.then('abc', 'def');
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class NonFunctionThenable {
+    then: number;
+  }
+  const thenable = new NonFunctionThenable();
+
+  thenable;
+  thenable.then;
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  await thenable;
+  return thenable;
+}
+    `,
+    `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  await promise;
+  promise.then(
+    () => {},
+    () => {},
+  );
+  promise.then(() => {}).catch(() => {});
+  promise
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promise.catch(() => {});
+  return promise;
 }
-      `,
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-function f<T extends Array<Promise<number>>>(a: T): void {
-  a;
+    `,
+
+    // optional chaining
+    `
+declare const returnsPromise: () => Promise<void> | null;
+async function test() {
+  await returnsPromise?.();
+  returnsPromise()?.then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    ?.then(() => {})
+    ?.catch(() => {});
+  returnsPromise()?.catch(() => {});
+  return returnsPromise();
 }
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const a: Array<Promise<number>> | undefined;
-a;
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
+    `,
+    `
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  await obj1.a?.b?.c?.();
+  await obj2.a?.b?.c();
+  await obj3.a?.b.c?.();
+  await obj4.a.b.c?.();
+  await obj5.a?.().b?.c?.();
+  await obj6?.a.b.c?.();
+
+  return callback?.();
+};
+
+void doSomething();
+    `,
+    // ignoreIIFE
     {
       code: `
-function f<T extends Array<Promise<number>>>(a: T | undefined): void {
-  a;
-}
+        (async () => {
+          await something();
+        })();
       `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-[Promise.reject()] as const;
+        (async () => {
+          something();
+        })();
       `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreIIFE: true }],
     },
     {
-      code: `
-declare function cursed(): [Promise<number>, Promise<string>];
-cursed();
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+      code: '(async function foo() {})();',
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-[
-  'Type Argument number ',
-  1,
-  'is not',
-  Promise.resolve(),
-  'but it still is flagged',
-] as const;
+        function foo() {
+          (async function bar() {})();
+        }
       `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-        declare const arrayOrPromiseTuple:
-          | Array<number>
-          | [number, number, Promise<unknown>, string];
-        arrayOrPromiseTuple;
+        const foo = () =>
+          new Promise(res => {
+            (async function () {
+              await res(1);
+            })();
+          });
       `,
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-        declare const okArrayOrPromiseArray: Array<number> | Array<Promise<unknown>>;
-        okArrayOrPromiseArray;
+        (async function () {
+          await res(1);
+        })();
       `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
-}
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-promise;
-      `,
-      options: [
-        {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
-          checkThenables: true,
-        },
-      ],
-      errors: [
-        {
-          line: 15,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
-}
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-void promise;
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  void (condition && myPromise());
 }
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-await promise;
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-promise.catch();
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-void promise.catch();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-await promise.catch();
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  await (condition && myPromise());
+}
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-promise().finally();
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-void promise().finally();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-await promise().finally();
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  condition && void myPromise();
+}
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-0 ? promise.catch() : 2;
-      `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-void (0 ? promise.catch() : 2);
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-await (0 ? promise.catch() : 2);
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  condition && (await myPromise());
+}
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-null ?? promise().catch();
+async function foo() {
+  const myPromise = async () => void 0;
+  let condition = false;
+  condition && myPromise();
+  condition = true;
+  condition || myPromise();
+  condition ?? myPromise();
+}
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-void (null ?? promise().catch());
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+declare const definitelyCallable: () => void;
+Promise.reject().catch(definitelyCallable);
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-await (null ?? promise().catch());
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {});
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: Foo<unknown>[];
-arrayOrPromiseTuple;
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
-      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ ignoreVoid: false }],
     },
-    // an array containing elements of `Promise` type and a branded Promise type will be treated as just an ordinary `Promise`.
-    // see https://github.com/typescript-eslint/typescript-eslint/pull/8502#issuecomment-2105734406
     {
       code: `
-type SafePromise = Promise<number> & { hey?: string };
-let foo: SafePromise = Promise.resolve(1);
-let bar = [Promise.resolve(2), foo];
-bar;
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
-arrayOrPromiseTuple;
+await Promise.all([Promise.resolve(), Promise.resolve()]);
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
-      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-myTag\`abc\`;
+declare const promiseArray: Array<Promise<unknown>>;
+void promiseArray;
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-void myTag\`abc\`;
+    },
+    {
+      // Expressions aren't checked by this rule, so this just becomes an array
+      // of number | undefined, which is fine regardless of the ignoreVoid setting.
+      code: `
+[1, 2, void Promise.reject(), 3];
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-await myTag\`abc\`;
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+['I', 'am', 'just', 'an', 'array'];
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
-
-        unsafe('...', () => {});
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
+}
+let promise: SafeThenable<number> = Promise.resolve(5);
+0, promise;
       `,
-      errors: [
+      options: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
-
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
-
-        void unsafe('...', () => {});
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
-
-        await unsafe('...', () => {});
-      `,
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
+    },
+    {
+      code: `
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
+}
+let promise: SafeThenable<number> = Promise.resolve(5);
+0 ? promise : 3;
+      `,
       options: [
         {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
     },
     {
       code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {}).then(() => {});
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        void it('...', () => {}).then(() => {});
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        await it('...', () => {}).then(() => {});
+class SafePromise<T> extends Promise<T> {}
+let promise: { a: SafePromise<number> } = { a: Promise.resolve(5) };
+promise.a;
       `,
-            },
-          ],
-        },
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+promise;
+      `,
       options: [
-        {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
-        },
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
     },
     {
       code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {}).finally(() => {});
+type Foo = Promise<number> & { hey?: string };
+let promise: Foo = Promise.resolve(5);
+0 || promise;
       `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        void it('...', () => {}).finally(() => {});
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: Foo = Promise.resolve(5);
+promise.finally();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        await it('...', () => {}).finally(() => {});
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
+}
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+0, promise();
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
     },
     {
       code: `
-declare const createPromise: () => PromiseLike<number>;
-createPromise();
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
+}
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+0 ? promise() : 3;
       `,
-      errors: [
+      options: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const createPromise: () => PromiseLike<number>;
-void createPromise();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const createPromise: () => PromiseLike<number>;
-await createPromise();
-      `,
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
-      options: [{ checkThenables: true }],
     },
     {
       code: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-createMyThenable();
+type Foo = Promise<number> & { hey?: string };
+let promise: () => Foo = () => Promise.resolve(5);
+promise();
       `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-void createMyThenable();
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: () => Foo = async () => 5;
+promise().finally();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-await createMyThenable();
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: () => SafePromise<number> = async () => 5;
+0 || promise();
       `,
-            },
-          ],
-        },
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
-      options: [{ checkThenables: true }],
     },
     {
       code: `
-declare const createPromise: () => Promise<number>;
-createPromise();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const createPromise: () => Promise<number>;
-void createPromise();
+class SafePromise<T> extends Promise<T> {}
+let promise: () => SafePromise<number> = async () => 5;
+null ?? promise();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const createPromise: () => Promise<number>;
-await createPromise();
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+let promise: () => PromiseLike<number> = () => Promise.resolve(5);
+promise();
       `,
-            },
-          ],
-        },
+      options: [
+        { allowForKnownSafePromises: [{ from: 'lib', name: 'PromiseLike' }] },
       ],
     },
     {
       code: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-createMyPromise();
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: Foo<unknown>[];
+arrayOrPromiseTuple;
       `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-void createMyPromise();
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
+arrayOrPromiseTuple;
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-await createMyPromise();
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+myTag\`abc\`;
       `,
-            },
-          ],
-        },
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
     },
     {
       code: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-createMyPromise();
+        declare function it(...args: unknown[]): Promise<void>;
+
+        it('...', () => {});
       `,
-      errors: [
+      options: [
         {
-          line: 6,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-void createMyPromise();
-      `,
-            },
+          allowForKnownSafeCalls: [
             {
-              messageId: 'floatingFixAwait',
-              output: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-await createMyPromise();
-      `,
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
             },
           ],
         },
       ],
-      options: [{ checkThenables: true }],
     },
     {
       code: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  yield x;
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.catch(() => {});
       `,
-      errors: [
-        {
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  void (yield x);
-}
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => string;
+myTag\`abc\`;
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  await (yield x);
-}
+    },
+    {
+      code: `
+declare let x: any;
+declare const promiseArray: Array<Promise<unknown>>;
+x = promiseArray;
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  yield* x;
+declare let x: Promise<number>;
+x = Promise.resolve(2);
+      `,
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+async function f() {
+  return promiseArray;
 }
       `,
-      errors: [
-        {
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  void (yield* x);
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+async function* generator() {
+  yield* promiseArray;
 }
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  await (yield* x);
+    },
+    {
+      code: `
+async function* generator() {
+  yield Promise.resolve();
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-const value = {};
-value as Promise<number>;
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
+}
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+promise().then(() => {});
       `,
-      errors: [
+      options: [
         {
-          messageId: 'floatingVoid',
-          line: 3,
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const value = {};
-void (value as Promise<number>);
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const value = {};
-await (value as Promise<number>);
-      `,
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
     },
+
     {
       code: `
-({}) as Promise<number> & number;
+        declare module 'abc' {
+          export function it(name: string, action: () => void): void;
+        }
+        it('...', () => {});
       `,
-      errors: [
+      options: [
         {
-          messageId: 'floatingVoid',
-          line: 2,
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void (({}) as Promise<number> & number);
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-await (({}) as Promise<number> & number);
-      `,
-            },
+          allowForKnownSafeCalls: [
+            { from: 'package', name: 'it', package: 'abc' },
           ],
         },
       ],
     },
     {
       code: `
-({}) as Promise<number> & { yolo?: string };
+        declare module 'abc' {
+          export function it(name: string, action: () => void): void;
+        }
+
+        it('...', () => {});
       `,
-      errors: [
+      options: [
         {
-          messageId: 'floatingVoid',
-          line: 2,
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void (({}) as Promise<number> & { yolo?: string });
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-await (({}) as Promise<number> & { yolo?: string });
-      `,
-            },
+          allowForKnownSafeCalls: [
+            { from: 'package', name: 'it', package: 'abc' },
           ],
         },
       ],
     },
     {
       code: `
-<Promise<number>>{};
+interface SafePromise<T> extends Promise<T> {
+  brand: 'safe';
+}
+
+declare const createSafePromise: () => SafePromise<string>;
+createSafePromise();
       `,
-      errors: [
+      options: [
         {
-          messageId: 'floatingVoid',
-          line: 2,
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void (<Promise<number>>{});
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-await (<Promise<number>>{});
-      `,
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }],
+          checkThenables: true,
         },
       ],
     },
+    `
+declare const createPromiseLike: () => PromiseLike<number>;
+createPromiseLike();
+    `,
+    `
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+createMyThenable();
+    `,
   ],
 });
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 d55ae851c446..f968f09977d4 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
@@ -7,26 +7,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-for-in-array', rule, {
-  valid: [
-    `
-for (const x of [3, 4, 5]) {
-  console.log(x);
-}
-    `,
-    `
-for (const x in { a: 1, b: 2, c: 3 }) {
-  console.log(x);
-}
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -36,11 +23,11 @@ for (const x in [3, 4, 5]) {
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 2,
           column: 1,
-          endLine: 2,
           endColumn: 27,
+          endLine: 2,
+          line: 2,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -53,11 +40,11 @@ for (const x in z) {
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 3,
           column: 1,
-          endLine: 3,
           endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -71,11 +58,11 @@ const fn = (arr: number[]) => {
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -89,11 +76,11 @@ const fn = (arr: number[] | string[]) => {
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -107,11 +94,11 @@ const fn = <T extends any[]>(arr: T) => {
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 3,
           column: 3,
-          endLine: 3,
           endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -138,11 +125,11 @@ for (const x
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 2,
           column: 1,
-          endLine: 11,
           endColumn: 4,
+          endLine: 11,
+          line: 2,
+          messageId: 'forInViolation',
         },
       ],
     },
@@ -169,13 +156,26 @@ for (const x
       `,
       errors: [
         {
-          messageId: 'forInViolation',
-          line: 2,
           column: 1,
-          endLine: 11,
           endColumn: 4,
+          endLine: 11,
+          line: 2,
+          messageId: 'forInViolation',
         },
       ],
     },
   ],
+
+  valid: [
+    `
+for (const x of [3, 4, 5]) {
+  console.log(x);
+}
+    `,
+    `
+for (const x in { a: 1, b: 2, c: 3 }) {
+  console.log(x);
+}
+    `,
+  ],
 });
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 c908df644c81..1933657d7433 100644
--- a/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
@@ -7,402 +7,239 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-implied-eval', rule, {
-  valid: [
-    'foo.setImmediate(null);',
-    'foo.setInterval(null);',
-    'foo.execScript(null);',
-    'foo.setTimeout(null);',
-    'foo();',
-    '(function () {})();',
-
-    'setTimeout(() => {}, 0);',
-    'window.setTimeout(() => {}, 0);',
-    "window['setTimeout'](() => {}, 0);",
-
-    'setInterval(() => {}, 0);',
-    'window.setInterval(() => {}, 0);',
-    "window['setInterval'](() => {}, 0);",
-
-    'setImmediate(() => {});',
-    'window.setImmediate(() => {});',
-    "window['setImmediate'](() => {});",
-
-    'execScript(() => {});',
-    'window.execScript(() => {});',
-    "window['execScript'](() => {});",
-
-    `
-const foo = () => {};
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-const foo = function () {};
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-function foo() {}
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: function () {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: function foo() {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn() {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-const fn = 'fn';
-
-setTimeout(foo[fn], 0);
-setInterval(foo[fn], 0);
-setImmediate(foo[fn]);
-execScript(foo[fn]);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-
-setTimeout(foo['fn'], 0);
-setInterval(foo['fn'], 0);
-setImmediate(foo['fn']);
-execScript(foo['fn']);
-    `,
-    `
-const foo: () => void = () => {};
+  invalid: [
+    {
+      code: `
+setTimeout('x = 1', 0);
+setInterval('x = 1', 0);
+setImmediate('x = 1');
+execScript('x = 1');
+      `,
+      errors: [
+        {
+          column: 12,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: `
+setTimeout(undefined, 0);
+setInterval(undefined, 0);
+setImmediate(undefined);
+execScript(undefined);
+      `,
+      errors: [
+        {
+          column: 12,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: `
+setTimeout(1 + '' + (() => {}), 0);
+setInterval(1 + '' + (() => {}), 0);
+setImmediate(1 + '' + (() => {}));
+execScript(1 + '' + (() => {}));
+      `,
+      errors: [
+        {
+          column: 12,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: `
+const foo = 'x = 1';
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
 setImmediate(foo);
 execScript(foo);
-    `,
-    `
-const foo: () => () => void = () => {
-  return () => {};
+      `,
+      errors: [
+        {
+          column: 12,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 12,
+          line: 7,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: `
+const foo = function () {
+  return 'x + 1';
 };
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
 setImmediate(foo());
 execScript(foo());
-    `,
-    `
-const foo: () => () => void = () => () => {};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = () => () => {};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = function foo() {
-  return function foo() {};
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = function () {
-  return function () {
-    return '';
-  };
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo: () => () => void = function foo() {
-  return function foo() {};
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-function foo() {
-  return function foo() {
-    return () => {};
-  };
-}
-
-setTimeout(foo()(), 0);
-setInterval(foo()(), 0);
-setImmediate(foo()());
-execScript(foo()());
-    `,
-    `
-class Foo {
-  static fn = () => {};
-}
-
-setTimeout(Foo.fn, 0);
-setInterval(Foo.fn, 0);
-setImmediate(Foo.fn);
-execScript(Foo.fn);
-    `,
-    `
-class Foo {
-  fn() {}
-}
-
-const foo = new Foo();
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-class Foo {
-  fn() {}
-}
-const foo = new Foo();
-const fn = foo.fn;
-
-setTimeout(fn.bind(null), 0);
-setInterval(fn.bind(null), 0);
-setImmediate(fn.bind(null));
-execScript(fn.bind(null));
-    `,
-    `
-const fn = (foo: () => void) => {
-  setTimeout(foo, 0);
-  setInterval(foo, 0);
-  setImmediate(foo);
-  execScript(foo);
-};
-    `,
-    `
-import { Function } from './class';
-new Function('foo');
-    `,
-    `
-const foo = (callback: Function) => {
-  setTimeout(callback, 0);
-};
-    `,
-    `
-const foo = () => {};
-const bar = () => {};
-
-setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
-setTimeout(foo || bar, 500);
-    `,
-    `
-class Foo {
-  func1() {}
-  func2(): void {
-    setTimeout(this.func1.bind(this), 1);
-  }
-}
-    `,
-    `
-class Foo {
-  private a = {
-    b: {
-      c: function () {},
-    },
-  };
-  funcw(): void {
-    setTimeout(this.a.b.c.bind(this), 1);
-  }
-}
-    `,
-    `
-function setTimeout(input: string, value: number) {}
-
-setTimeout('', 0);
-    `,
-    `
-declare module 'my-timers-promises' {
-  export function setTimeout(ms: number): void;
-}
-
-import { setTimeout } from 'my-timers-promises';
-
-setTimeout(1000);
-    `,
-    `
-function setTimeout() {}
-
-{
-  setTimeout(100);
-}
-    `,
-    `
-function setTimeout() {}
-
-{
-  setTimeout("alert('evil!')");
-}
-    `,
-  ],
-
-  invalid: [
-    {
-      code: `
-setTimeout('x = 1', 0);
-setInterval('x = 1', 0);
-setImmediate('x = 1');
-execScript('x = 1');
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 12,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 13,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 14,
+          line: 8,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 12,
+          line: 9,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-setTimeout(undefined, 0);
-setInterval(undefined, 0);
-setImmediate(undefined);
-execScript(undefined);
+const foo = function () {
+  return () => 'x + 1';
+};
+
+setTimeout(foo()(), 0);
+setInterval(foo()(), 0);
+setImmediate(foo()());
+execScript(foo()());
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 12,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 13,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 14,
+          line: 8,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 12,
+          line: 9,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-setTimeout(1 + '' + (() => {}), 0);
-setInterval(1 + '' + (() => {}), 0);
-setImmediate(1 + '' + (() => {}));
-execScript(1 + '' + (() => {}));
+const fn = function () {};
+
+setTimeout(fn + '', 0);
+setInterval(fn + '', 0);
+setImmediate(fn + '');
+execScript(fn + '');
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 12,
+          line: 4,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 13,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 12,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-const foo = 'x = 1';
+const foo: string = 'x + 1';
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
@@ -411,130 +248,30 @@ execScript(foo);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 12,
+          line: 4,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 13,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 6,
           column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 7,
           column: 12,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-const foo = function () {
-  return 'x + 1';
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-      `,
-      errors: [
-        {
-          messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 12,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 7,
-          column: 13,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 8,
-          column: 14,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 9,
-          column: 12,
-        },
-      ],
-    },
-    {
-      code: `
-const foo = function () {
-  return () => 'x + 1';
-};
-
-setTimeout(foo()(), 0);
-setInterval(foo()(), 0);
-setImmediate(foo()());
-execScript(foo()());
-      `,
-      errors: [
-        {
-          messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 12,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 7,
-          column: 13,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 8,
-          column: 14,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 9,
-          column: 12,
-        },
-      ],
-    },
-    {
-      code: `
-const fn = function () {};
-
-setTimeout(fn + '', 0);
-setInterval(fn + '', 0);
-setImmediate(fn + '');
-execScript(fn + '');
-      `,
-      errors: [
-        {
-          messageId: 'noImpliedEvalError',
-          line: 4,
-          column: 12,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 5,
-          column: 13,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 14,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 7,
-          column: 12,
-        },
-      ],
-    },
-    {
-      code: `
-const foo: string = 'x + 1';
+const foo = new String('x + 1');
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
@@ -543,56 +280,24 @@ execScript(foo);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 12,
-        },
-        {
+          line: 4,
           messageId: 'noImpliedEvalError',
-          line: 5,
-          column: 13,
         },
         {
+          column: 13,
+          line: 5,
           messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 14,
         },
         {
+          column: 14,
+          line: 6,
           messageId: 'noImpliedEvalError',
-          line: 7,
-          column: 12,
         },
-      ],
-    },
-    {
-      code: `
-const foo = new String('x + 1');
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-      `,
-      errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 12,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 5,
-          column: 13,
-        },
-        {
-          messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 14,
-        },
-        {
-          messageId: 'noImpliedEvalError',
           line: 7,
-          column: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -607,24 +312,24 @@ execScript(foo as any);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 12,
+          line: 4,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 13,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 6,
           column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 7,
           column: 12,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -639,24 +344,24 @@ const fn = (foo: string | any) => {
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 14,
+          line: 3,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 4,
           column: 15,
+          line: 4,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 16,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 6,
           column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -669,9 +374,9 @@ setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -691,44 +396,44 @@ window['execScript'](\`\`);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 19,
+          line: 2,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 22,
+          line: 3,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 20,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 6,
           column: 23,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 8,
           column: 21,
+          line: 8,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 9,
           column: 24,
+          line: 9,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 11,
           column: 19,
+          line: 11,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 12,
           column: 22,
+          line: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -748,44 +453,44 @@ global['execScript'](\`\`);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 19,
+          line: 2,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 3,
           column: 22,
+          line: 3,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 20,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 6,
           column: 23,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 8,
           column: 21,
+          line: 8,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 9,
           column: 24,
+          line: 9,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 11,
           column: 19,
+          line: 11,
+          messageId: 'noImpliedEvalError',
         },
         {
-          messageId: 'noImpliedEvalError',
-          line: 12,
           column: 22,
+          line: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -805,44 +510,44 @@ globalThis['execScript'](\`\`);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 2,
           column: 23,
-        },
-        {
+          line: 2,
           messageId: 'noImpliedEvalError',
-          line: 3,
-          column: 26,
         },
         {
+          column: 26,
+          line: 3,
           messageId: 'noImpliedEvalError',
-          line: 5,
-          column: 24,
         },
         {
+          column: 24,
+          line: 5,
           messageId: 'noImpliedEvalError',
-          line: 6,
-          column: 27,
         },
         {
+          column: 27,
+          line: 6,
           messageId: 'noImpliedEvalError',
-          line: 8,
-          column: 25,
         },
         {
+          column: 25,
+          line: 8,
           messageId: 'noImpliedEvalError',
-          line: 9,
-          column: 28,
         },
         {
+          column: 28,
+          line: 9,
           messageId: 'noImpliedEvalError',
-          line: 11,
-          column: 23,
         },
         {
+          column: 23,
+          line: 11,
           messageId: 'noImpliedEvalError',
-          line: 12,
+        },
+        {
           column: 26,
+          line: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -855,9 +560,9 @@ setTimeout(foo || bar, 500);
       `,
       errors: [
         {
-          messageId: 'noImpliedEvalError',
-          line: 5,
           column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
@@ -865,9 +570,9 @@ setTimeout(foo || bar, 500);
       code: 'const fn = Function();',
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
@@ -875,9 +580,9 @@ setTimeout(foo || bar, 500);
       code: "const fn = new Function('a', 'b', 'return a + b');",
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
@@ -885,9 +590,9 @@ setTimeout(foo || bar, 500);
       code: 'const fn = window.Function();',
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
@@ -895,9 +600,9 @@ setTimeout(foo || bar, 500);
       code: 'const fn = new window.Function();',
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
@@ -905,9 +610,9 @@ setTimeout(foo || bar, 500);
       code: "const fn = window['Function']();",
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
@@ -915,11 +620,306 @@ setTimeout(foo || bar, 500);
       code: "const fn = new window['Function']();",
       errors: [
         {
-          messageId: 'noFunctionConstructor',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
         },
       ],
     },
   ],
+
+  valid: [
+    'foo.setImmediate(null);',
+    'foo.setInterval(null);',
+    'foo.execScript(null);',
+    'foo.setTimeout(null);',
+    'foo();',
+    '(function () {})();',
+
+    'setTimeout(() => {}, 0);',
+    'window.setTimeout(() => {}, 0);',
+    "window['setTimeout'](() => {}, 0);",
+
+    'setInterval(() => {}, 0);',
+    'window.setInterval(() => {}, 0);',
+    "window['setInterval'](() => {}, 0);",
+
+    'setImmediate(() => {});',
+    'window.setImmediate(() => {});',
+    "window['setImmediate'](() => {});",
+
+    'execScript(() => {});',
+    'window.execScript(() => {});',
+    "window['execScript'](() => {});",
+
+    `
+const foo = () => {};
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+    `,
+    `
+const foo = function () {};
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+    `,
+    `
+function foo() {}
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: function () {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: function foo() {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn() {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+const fn = 'fn';
+
+setTimeout(foo[fn], 0);
+setInterval(foo[fn], 0);
+setImmediate(foo[fn]);
+execScript(foo[fn]);
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+
+setTimeout(foo['fn'], 0);
+setInterval(foo['fn'], 0);
+setImmediate(foo['fn']);
+execScript(foo['fn']);
+    `,
+    `
+const foo: () => void = () => {};
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+    `,
+    `
+const foo: () => () => void = () => {
+  return () => {};
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo: () => () => void = () => () => {};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = () => () => {};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = function foo() {
+  return function foo() {};
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = function () {
+  return function () {
+    return '';
+  };
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo: () => () => void = function foo() {
+  return function foo() {};
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+function foo() {
+  return function foo() {
+    return () => {};
+  };
+}
+
+setTimeout(foo()(), 0);
+setInterval(foo()(), 0);
+setImmediate(foo()());
+execScript(foo()());
+    `,
+    `
+class Foo {
+  static fn = () => {};
+}
+
+setTimeout(Foo.fn, 0);
+setInterval(Foo.fn, 0);
+setImmediate(Foo.fn);
+execScript(Foo.fn);
+    `,
+    `
+class Foo {
+  fn() {}
+}
+
+const foo = new Foo();
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+class Foo {
+  fn() {}
+}
+const foo = new Foo();
+const fn = foo.fn;
+
+setTimeout(fn.bind(null), 0);
+setInterval(fn.bind(null), 0);
+setImmediate(fn.bind(null));
+execScript(fn.bind(null));
+    `,
+    `
+const fn = (foo: () => void) => {
+  setTimeout(foo, 0);
+  setInterval(foo, 0);
+  setImmediate(foo);
+  execScript(foo);
+};
+    `,
+    `
+import { Function } from './class';
+new Function('foo');
+    `,
+    `
+const foo = (callback: Function) => {
+  setTimeout(callback, 0);
+};
+    `,
+    `
+const foo = () => {};
+const bar = () => {};
+
+setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
+setTimeout(foo || bar, 500);
+    `,
+    `
+class Foo {
+  func1() {}
+  func2(): void {
+    setTimeout(this.func1.bind(this), 1);
+  }
+}
+    `,
+    `
+class Foo {
+  private a = {
+    b: {
+      c: function () {},
+    },
+  };
+  funcw(): void {
+    setTimeout(this.a.b.c.bind(this), 1);
+  }
+}
+    `,
+    `
+function setTimeout(input: string, value: number) {}
+
+setTimeout('', 0);
+    `,
+    `
+declare module 'my-timers-promises' {
+  export function setTimeout(ms: number): void;
+}
+
+import { setTimeout } from 'my-timers-promises';
+
+setTimeout(1000);
+    `,
+    `
+function setTimeout() {}
+
+{
+  setTimeout(100);
+}
+    `,
+    `
+function setTimeout() {}
+
+{
+  setTimeout("alert('evil!')");
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts b/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
index b1d0e3885337..5746581d8dc4 100644
--- a/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
@@ -5,40 +5,40 @@ import rule from '../../src/rules/no-import-type-side-effects';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-import-type-side-effects', rule, {
-  valid: [
-    "import T from 'mod';",
-    "import * as T from 'mod';",
-    "import { T } from 'mod';",
-    "import type { T } from 'mod';",
-    "import type { T, U } from 'mod';",
-    "import { type T, U } from 'mod';",
-    "import { T, type U } from 'mod';",
-    "import type T from 'mod';",
-    "import type T, { U } from 'mod';",
-    "import T, { type U } from 'mod';",
-    "import type * as T from 'mod';",
-    "import 'mod';",
-  ],
   invalid: [
     {
       code: "import { type A } from 'mod';",
-      output: "import type { A } from 'mod';",
       errors: [{ messageId: 'useTopLevelQualifier' }],
+      output: "import type { A } from 'mod';",
     },
     {
       code: "import { type A as AA } from 'mod';",
-      output: "import type { A as AA } from 'mod';",
       errors: [{ messageId: 'useTopLevelQualifier' }],
+      output: "import type { A as AA } from 'mod';",
     },
     {
       code: "import { type A, type B } from 'mod';",
-      output: "import type { A, B } from 'mod';",
       errors: [{ messageId: 'useTopLevelQualifier' }],
+      output: "import type { A, B } from 'mod';",
     },
     {
       code: "import { type A as AA, type B as BB } from 'mod';",
-      output: "import type { A as AA, B as BB } from 'mod';",
       errors: [{ messageId: 'useTopLevelQualifier' }],
+      output: "import type { A as AA, B as BB } from 'mod';",
     },
   ],
+  valid: [
+    "import T from 'mod';",
+    "import * as T from 'mod';",
+    "import { T } from 'mod';",
+    "import type { T } from 'mod';",
+    "import type { T, U } from 'mod';",
+    "import { type T, U } from 'mod';",
+    "import { T, type U } from 'mod';",
+    "import type T from 'mod';",
+    "import type T, { U } from 'mod';",
+    "import T, { type U } from 'mod';",
+    "import type * as T from 'mod';",
+    "import 'mod';",
+  ],
 });
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 fa1b7f4ffa37..8ec856baf342 100644
--- a/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
@@ -1,12 +1,14 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
-import rule from '../../src/rules/no-inferrable-types';
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../../src/util';
 
+import rule from '../../src/rules/no-inferrable-types';
+
 type MessageIds = InferMessageIdsTypeFromRule<typeof rule>;
 type Options = InferOptionsTypeFromRule<typeof rule>;
 
@@ -15,7 +17,6 @@ function flatten<T>(arr: T[][]): T[] {
 }
 const testCases = [
   {
-    type: 'bigint',
     code: [
       '10n',
       '-10n',
@@ -24,13 +25,13 @@ const testCases = [
       'BigInt?.(10)',
       '-BigInt?.(10)',
     ],
+    type: 'bigint',
   },
   {
-    type: 'boolean',
     code: ['false', 'true', 'Boolean(null)', 'Boolean?.(null)', '!0'],
+    type: 'boolean',
   },
   {
-    type: 'number',
     code: [
       '10',
       '+10',
@@ -48,26 +49,27 @@ const testCases = [
       '+NaN',
       '-NaN',
     ],
+    type: 'number',
   },
   {
-    type: 'null',
     code: ['null'],
+    type: 'null',
   },
   {
-    type: 'RegExp',
     code: ['/a/', 'RegExp("a")', 'RegExp?.("a")', 'new RegExp("a")'],
+    type: 'RegExp',
   },
   {
-    type: 'string',
     code: ['"str"', "'str'", '`str`', 'String(1)', 'String?.(1)'],
+    type: 'string',
   },
   {
-    type: 'symbol',
     code: ['Symbol("a")', 'Symbol?.("a")'],
+    type: 'symbol',
   },
   {
-    type: 'undefined',
     code: ['undefined', 'void someValue'],
+    type: 'undefined',
   },
 ];
 const validTestCases = flatten(
@@ -77,17 +79,17 @@ const invalidTestCases: InvalidTestCase<MessageIds, Options>[] = flatten(
   testCases.map(cas =>
     cas.code.map(code => ({
       code: `const a: ${cas.type} = ${code}`,
-      output: `const a = ${code}`,
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 7,
           data: {
             type: cas.type,
           },
           line: 1,
-          column: 7,
+          messageId: 'noInferrableType',
         },
       ],
+      output: `const a = ${code}`,
     })),
   ),
 );
@@ -95,91 +97,27 @@ const invalidTestCases: InvalidTestCase<MessageIds, Options>[] = flatten(
 const ruleTester = new RuleTester();
 
 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') {};",
-    "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;
-}
-    `,
-
-    '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') => {};",
-      options: [{ ignoreParameters: true }],
-    },
-    {
-      code: "function fn(a: number = 5, b: boolean = true, c: string = 'foo') {}",
-      options: [{ ignoreParameters: true }],
-    },
-    {
-      code: "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';
-}
-      `,
-      options: [{ ignoreProperties: true }],
-    },
-    {
-      code: `
-class Foo {
-  a?: number = 5;
-  b?: boolean = true;
-  c?: string = 'foo';
-}
-      `,
-    },
-    {
-      code: `
-class Foo {
-  constructor(public a = true) {}
-}
-      `,
-    },
-  ],
-
   invalid: [
     ...invalidTestCases,
     {
       // This is invalid TS semantic, but it's trivial to make valid anyway
       code: 'const fn = (a?: number = 5) => {};',
-      output: 'const fn = (a = 5) => {};',
-      options: [
-        {
-          ignoreParameters: false,
-        },
-      ],
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 13,
           data: {
             type: 'number',
           },
           line: 1,
-          column: 13,
+          messageId: 'noInferrableType',
+        },
+      ],
+      options: [
+        {
+          ignoreParameters: false,
         },
       ],
+      output: 'const fn = (a = 5) => {};',
     },
     {
       // This is invalid TS semantic, but it's trivial to make valid anyway
@@ -188,62 +126,62 @@ class A {
   a!: number = 1;
 }
       `,
-      output: `
-class A {
-  a = 1;
-}
-      `,
-      options: [
-        {
-          ignoreProperties: false,
-        },
-      ],
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 3,
           data: {
             type: 'number',
           },
           line: 3,
-          column: 3,
+          messageId: 'noInferrableType',
         },
       ],
-    },
-    {
-      code: "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {};",
-      output: "const fn = (a = 5, b = true, c = 'foo') => {};",
       options: [
         {
-          ignoreParameters: false,
           ignoreProperties: false,
         },
       ],
+      output: `
+class A {
+  a = 1;
+}
+      `,
+    },
+    {
+      code: "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {};",
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 13,
           data: {
             type: 'number',
           },
           line: 1,
-          column: 13,
+          messageId: 'noInferrableType',
         },
         {
-          messageId: 'noInferrableType',
+          column: 28,
           data: {
             type: 'boolean',
           },
           line: 1,
-          column: 28,
+          messageId: 'noInferrableType',
         },
         {
-          messageId: 'noInferrableType',
+          column: 47,
           data: {
             type: 'string',
           },
           line: 1,
-          column: 47,
+          messageId: 'noInferrableType',
+        },
+      ],
+      options: [
+        {
+          ignoreParameters: false,
+          ignoreProperties: false,
         },
       ],
+      output: "const fn = (a = 5, b = true, c = 'foo') => {};",
     },
     {
       code: `
@@ -253,45 +191,45 @@ class Foo {
   c: string = 'foo';
 }
       `,
-      output: `
-class Foo {
-  a = 5;
-  b = true;
-  c = 'foo';
-}
-      `,
-      options: [
-        {
-          ignoreParameters: false,
-          ignoreProperties: false,
-        },
-      ],
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 3,
           data: {
             type: 'number',
           },
           line: 3,
-          column: 3,
+          messageId: 'noInferrableType',
         },
         {
-          messageId: 'noInferrableType',
+          column: 3,
           data: {
             type: 'boolean',
           },
           line: 4,
-          column: 3,
+          messageId: 'noInferrableType',
         },
         {
-          messageId: 'noInferrableType',
+          column: 3,
           data: {
             type: 'string',
           },
           line: 5,
-          column: 3,
+          messageId: 'noInferrableType',
         },
       ],
+      options: [
+        {
+          ignoreParameters: false,
+          ignoreProperties: false,
+        },
+      ],
+      output: `
+class Foo {
+  a = 5;
+  b = true;
+  c = 'foo';
+}
+      `,
     },
     {
       code: `
@@ -299,27 +237,91 @@ class Foo {
   constructor(public a: boolean = true) {}
 }
       `,
-      output: `
-class Foo {
-  constructor(public a = true) {}
-}
-      `,
-      options: [
-        {
-          ignoreParameters: false,
-          ignoreProperties: false,
-        },
-      ],
       errors: [
         {
-          messageId: 'noInferrableType',
+          column: 22,
           data: {
             type: 'boolean',
           },
           line: 3,
-          column: 22,
+          messageId: 'noInferrableType',
+        },
+      ],
+      options: [
+        {
+          ignoreParameters: false,
+          ignoreProperties: false,
         },
       ],
+      output: `
+class Foo {
+  constructor(public a = true) {}
+}
+      `,
+    },
+  ],
+
+  valid: [
+    ...validTestCases,
+
+    "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;
+}
+    `,
+
+    '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') => {};",
+      options: [{ ignoreParameters: true }],
+    },
+    {
+      code: "function fn(a: number = 5, b: boolean = true, c: string = 'foo') {}",
+      options: [{ ignoreParameters: true }],
+    },
+    {
+      code: "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';
+}
+      `,
+      options: [{ ignoreProperties: true }],
+    },
+    {
+      code: `
+class Foo {
+  a?: number = 5;
+  b?: boolean = true;
+  c?: string = 'foo';
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  constructor(public a = true) {}
+}
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts b/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
index b54a0af5fdf8..544ca1c90af8 100644
--- a/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
@@ -10,60 +10,69 @@ const errors = [
 ];
 
 ruleTester.run('no-invalid-this', rule, {
-  valid: [
-    `
-describe('foo', () => {
-  it('does something', function (this: Mocha.Context) {
-    this.timeout(100);
-    // done
-  });
-});
-    `,
-    `
-      interface SomeType {
-        prop: string;
-      }
-      function foo(this: SomeType) {
-        this.prop;
-      }
-    `,
-    `
-function foo(this: prop) {
-  this.propMethod();
+  invalid: [
+    {
+      code: `
+interface SomeType {
+  prop: string;
 }
-    `,
-    `
-z(function (x, this: context) {
-  console.log(x, this);
-});
-    `,
-    // https://github.com/eslint/eslint/issues/3287
-
-    `
 function foo() {
-  /** @this Obj*/ return function bar() {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
+  this.prop;
 }
-    `,
+      `,
+      errors: [{ messageId: 'unexpectedThis' }],
+    },
+    // Global.
+    {
+      code: `
+console.log(this);
+z(x => console.log(x, this));
+      `,
+      errors,
+    },
+    {
+      code: `
+console.log(this);
+z(x => console.log(x, this));
+      `,
+      errors,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
+      },
+    },
 
-    // https://github.com/eslint/eslint/issues/6824
+    // IIFE.
+    {
+      code: `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+})();
+      `,
+      errors,
+    },
 
-    `
-var Ctor = function () {
+    // Just functions.
+    {
+      code: `
+function foo() {
   console.log(this);
   z(x => console.log(x, this));
-};
-    `,
-    // Constructors.
+}
+      `,
+      errors,
+    },
     {
       code: `
-function Foo() {
+function foo() {
   console.log(this);
   z(x => console.log(x, this));
 }
       `,
+      errors,
+      options: [{ capIsConstructor: false }], // test that the option doesn't reverse the logic and mistakenly allows lowercase functions
     },
     {
       code: `
@@ -72,708 +81,281 @@ function Foo() {
   z(x => console.log(x, this));
 }
       `,
-      options: [{}], // test the default value in schema
+      errors,
+      options: [{ capIsConstructor: false }],
+    },
+    {
+      code: `
+function foo() {
+  'use strict';
+  console.log(this);
+  z(x => console.log(x, this));
+}
+      `,
+      errors,
     },
     {
       code: `
 function Foo() {
+  'use strict';
   console.log(this);
   z(x => console.log(x, this));
 }
       `,
-      options: [{ capIsConstructor: true }], // test explicitly set option to the default value
+      errors,
+      options: [{ capIsConstructor: false }],
     },
     {
       code: `
-var Foo = function Foo() {
+return function () {
   console.log(this);
   z(x => console.log(x, this));
 };
       `,
+      errors,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
+      },
     },
     {
       code: `
-class A {
-  constructor() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
+var foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}.bar(obj);
       `,
+      errors,
     },
 
-    // On a property.
+    // Functions in methods.
     {
       code: `
 var obj = {
   foo: function () {
-    console.log(this);
-    z(x => console.log(x, this));
+    function foo() {
+      console.log(this);
+      z(x => console.log(x, this));
+    }
+    foo();
   },
 };
       `,
+      errors,
     },
     {
       code: `
 var obj = {
   foo() {
-    console.log(this);
-    z(x => console.log(x, this));
+    function foo() {
+      console.log(this);
+      z(x => console.log(x, this));
+    }
+    foo();
   },
 };
       `,
+      errors,
     },
     {
       code: `
 var obj = {
-  foo:
-    foo ||
-    function () {
+  foo: function () {
+    return function () {
       console.log(this);
       z(x => console.log(x, this));
-    },
-};
-      `,
-    },
-    {
-      code: `
-var obj = {
-  foo: hasNative
-    ? foo
-    : function () {
-        console.log(this);
-        z(x => console.log(x, this));
-      },
+    };
+  },
 };
       `,
+      errors,
     },
     {
       code: `
 var obj = {
-  foo: (function () {
+  foo: function () {
+    'use strict';
     return function () {
       console.log(this);
       z(x => console.log(x, this));
     };
-  })(),
+  },
 };
       `,
+      errors,
     },
     {
       code: `
-Object.defineProperty(obj, 'foo', {
-  value: function () {
+obj.foo = function () {
+  return function () {
     console.log(this);
     z(x => console.log(x, this));
-  },
-});
+  };
+};
       `,
+      errors,
     },
     {
       code: `
-Object.defineProperties(obj, {
-  foo: {
-    value: function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    },
-  },
-});
+obj.foo = function () {
+  'use strict';
+  return function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+};
       `,
+      errors,
     },
 
-    // Assigns to a property.
+    // Class Methods.
+
     {
       code: `
-obj.foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
+class A {
+  foo() {
+    return function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+  }
+}
       `,
+      errors,
     },
+
+    // Class Properties.
+
     {
       code: `
-obj.foo =
-  foo ||
-  function () {
+class A {
+  b = new Array(1, 2, function () {
     console.log(this);
     z(x => console.log(x, this));
-  };
+  });
+}
       `,
+      errors,
     },
+
     {
       code: `
-obj.foo = foo
-  ? bar
-  : function () {
+class A {
+  b = () => {
+    function c() {
       console.log(this);
       z(x => console.log(x, this));
-    };
+    }
+  };
+}
       `,
+      errors,
     },
+
+    // Class Static methods.
+
     {
       code: `
 obj.foo = (function () {
-  return function () {
+  return () => {
     console.log(this);
     z(x => console.log(x, this));
   };
 })();
       `,
+      errors,
     },
     {
       code: `
-obj.foo = (() =>
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  })();
+obj.foo = (() => () => {
+  console.log(this);
+  z(x => console.log(x, this));
+})();
       `,
+      errors,
     },
-
     // Bind/Call/Apply
-    `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).call(obj);
-    `,
-    `
-var foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}.bind(obj);
-    `,
-    `
-Reflect.apply(
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-  obj,
-  [],
-);
-    `,
-    `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).apply(obj);
-    `,
-
-    // Class Instance Methods.
-    `
-class A {
-  foo() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
-    `,
-
-    // Class Properties.
-    `
-class A {
-  b = 0;
-  c = this.b;
-}
-    `,
-
-    `
-class A {
-  b = new Array(this, 1, 2, 3);
-}
-    `,
-
-    `
-class A {
-  b = () => {
-    console.log(this);
-  };
-}
-    `,
-
-    // Array methods.
-
-    `
-Array.from(
-  [],
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-  obj,
-);
-    `,
-
-    `
-foo.every(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.filter(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.find(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.findIndex(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.forEach(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.map(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.some(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    // @this tag.
-
-    `
-/** @this Obj */ function foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-    `,
-
-    `
-foo(
-  /* @this Obj */ function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-);
-    `,
-
-    `
-/**
- * @returns {void}
- * @this Obj
- */
-function foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-    `,
-
-    `
-Ctor = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-    `,
-
-    `
-function foo(
-  Ctor = function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-) {}
-    `,
-
-    `
-[
-  obj.method = function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-] = a;
-    `,
-
-    // Static
-
-    `
-class A {
-  static foo() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
-    `,
-    `
-class A {
-  a = 5;
-  b = this.a;
-  accessor c = this.a;
-}
-    `,
-  ],
 
-  invalid: [
-    {
-      code: `
-interface SomeType {
-  prop: string;
-}
-function foo() {
-  this.prop;
-}
-      `,
-      errors: [{ messageId: 'unexpectedThis' }],
-    },
-    // Global.
     {
       code: `
-console.log(this);
-z(x => console.log(x, this));
+var foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}.bind(null);
       `,
       errors,
     },
+
     {
       code: `
-console.log(this);
-z(x => console.log(x, this));
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).call(undefined);
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { globalReturn: true },
-        },
-      },
       errors,
     },
 
-    // IIFE.
     {
       code: `
 (function () {
   console.log(this);
   z(x => console.log(x, this));
-})();
+}).apply(void 0);
       `,
       errors,
     },
 
-    // Just functions.
+    // Array methods.
     {
       code: `
-function foo() {
+Array.from([], function () {
   console.log(this);
   z(x => console.log(x, this));
-}
+});
       `,
       errors,
     },
     {
       code: `
-function foo() {
+foo.every(function () {
   console.log(this);
   z(x => console.log(x, this));
-}
+});
       `,
-      options: [{ capIsConstructor: false }], // test that the option doesn't reverse the logic and mistakenly allows lowercase functions
       errors,
     },
     {
       code: `
-function Foo() {
+foo.filter(function () {
   console.log(this);
   z(x => console.log(x, this));
-}
+});
       `,
-      options: [{ capIsConstructor: false }],
       errors,
     },
     {
       code: `
-function foo() {
-  'use strict';
+foo.find(function () {
   console.log(this);
   z(x => console.log(x, this));
-}
+});
       `,
       errors,
     },
     {
       code: `
-function Foo() {
-  'use strict';
+foo.findIndex(function () {
   console.log(this);
   z(x => console.log(x, this));
-}
+});
       `,
-      options: [{ capIsConstructor: false }],
       errors,
     },
     {
       code: `
-return function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { globalReturn: true },
-        },
-      },
-      errors,
-    },
-    {
-      code: `
-var foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}.bar(obj);
-      `,
-      errors,
-    },
-
-    // Functions in methods.
-    {
-      code: `
-var obj = {
-  foo: function () {
-    function foo() {
-      console.log(this);
-      z(x => console.log(x, this));
-    }
-    foo();
-  },
-};
-      `,
-      errors,
-    },
-    {
-      code: `
-var obj = {
-  foo() {
-    function foo() {
-      console.log(this);
-      z(x => console.log(x, this));
-    }
-    foo();
-  },
-};
-      `,
-      errors,
-    },
-    {
-      code: `
-var obj = {
-  foo: function () {
-    return function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-  },
-};
-      `,
-      errors,
-    },
-    {
-      code: `
-var obj = {
-  foo: function () {
-    'use strict';
-    return function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-  },
-};
-      `,
-      errors,
-    },
-    {
-      code: `
-obj.foo = function () {
-  return function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-};
-      `,
-      errors,
-    },
-    {
-      code: `
-obj.foo = function () {
-  'use strict';
-  return function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-};
-      `,
-      errors,
-    },
-
-    // Class Methods.
-
-    {
-      code: `
-class A {
-  foo() {
-    return function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-  }
-}
-      `,
-      errors,
-    },
-
-    // Class Properties.
-
-    {
-      code: `
-class A {
-  b = new Array(1, 2, function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  });
-}
-      `,
-      errors,
-    },
-
-    {
-      code: `
-class A {
-  b = () => {
-    function c() {
-      console.log(this);
-      z(x => console.log(x, this));
-    }
-  };
-}
-      `,
-      errors,
-    },
-
-    // Class Static methods.
-
-    {
-      code: `
-obj.foo = (function () {
-  return () => {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-})();
-      `,
-      errors,
-    },
-    {
-      code: `
-obj.foo = (() => () => {
-  console.log(this);
-  z(x => console.log(x, this));
-})();
-      `,
-      errors,
-    },
-    // Bind/Call/Apply
-
-    {
-      code: `
-var foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}.bind(null);
-      `,
-      errors,
-    },
-
-    {
-      code: `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).call(undefined);
-      `,
-      errors,
-    },
-
-    {
-      code: `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).apply(void 0);
-      `,
-      errors,
-    },
-
-    // Array methods.
-    {
-      code: `
-Array.from([], function () {
-  console.log(this);
-  z(x => console.log(x, this));
-});
-      `,
-      errors,
-    },
-    {
-      code: `
-foo.every(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-});
-      `,
-      errors,
-    },
-    {
-      code: `
-foo.filter(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-});
-      `,
-      errors,
-    },
-    {
-      code: `
-foo.find(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-});
-      `,
-      errors,
-    },
-    {
-      code: `
-foo.findIndex(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-});
-      `,
-      errors,
-    },
-    {
-      code: `
-foo.forEach(function () {
+foo.forEach(function () {
   console.log(this);
   z(x => console.log(x, this));
 });
@@ -837,8 +419,8 @@ var Ctor = function () {
   z(x => console.log(x, this));
 };
       `,
-      options: [{ capIsConstructor: false }],
       errors,
+      options: [{ capIsConstructor: false }],
     },
     {
       code: `
@@ -856,8 +438,8 @@ var func = function () {
   z(x => console.log(x, this));
 };
       `,
-      options: [{ capIsConstructor: false }],
       errors,
+      options: [{ capIsConstructor: false }],
     },
 
     {
@@ -867,8 +449,8 @@ Ctor = function () {
   z(x => console.log(x, this));
 };
       `,
-      options: [{ capIsConstructor: false }],
       errors,
+      options: [{ capIsConstructor: false }],
     },
     {
       code: `
@@ -886,8 +468,8 @@ func = function () {
   z(x => console.log(x, this));
 };
       `,
-      options: [{ capIsConstructor: false }],
       errors,
+      options: [{ capIsConstructor: false }],
     },
 
     {
@@ -914,4 +496,422 @@ function foo(
       errors,
     },
   ],
+
+  valid: [
+    `
+describe('foo', () => {
+  it('does something', function (this: Mocha.Context) {
+    this.timeout(100);
+    // done
+  });
+});
+    `,
+    `
+      interface SomeType {
+        prop: string;
+      }
+      function foo(this: SomeType) {
+        this.prop;
+      }
+    `,
+    `
+function foo(this: prop) {
+  this.propMethod();
+}
+    `,
+    `
+z(function (x, this: context) {
+  console.log(x, this);
+});
+    `,
+    // https://github.com/eslint/eslint/issues/3287
+
+    `
+function foo() {
+  /** @this Obj*/ return function bar() {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+}
+    `,
+
+    // https://github.com/eslint/eslint/issues/6824
+
+    `
+var Ctor = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+};
+    `,
+    // Constructors.
+    {
+      code: `
+function Foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+      `,
+    },
+    {
+      code: `
+function Foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+      `,
+      options: [{}], // test the default value in schema
+    },
+    {
+      code: `
+function Foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+      `,
+      options: [{ capIsConstructor: true }], // test explicitly set option to the default value
+    },
+    {
+      code: `
+var Foo = function Foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+};
+      `,
+    },
+    {
+      code: `
+class A {
+  constructor() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
+      `,
+    },
+
+    // On a property.
+    {
+      code: `
+var obj = {
+  foo: function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+};
+      `,
+    },
+    {
+      code: `
+var obj = {
+  foo() {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+};
+      `,
+    },
+    {
+      code: `
+var obj = {
+  foo:
+    foo ||
+    function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    },
+};
+      `,
+    },
+    {
+      code: `
+var obj = {
+  foo: hasNative
+    ? foo
+    : function () {
+        console.log(this);
+        z(x => console.log(x, this));
+      },
+};
+      `,
+    },
+    {
+      code: `
+var obj = {
+  foo: (function () {
+    return function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+  })(),
+};
+      `,
+    },
+    {
+      code: `
+Object.defineProperty(obj, 'foo', {
+  value: function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+});
+      `,
+    },
+    {
+      code: `
+Object.defineProperties(obj, {
+  foo: {
+    value: function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    },
+  },
+});
+      `,
+    },
+
+    // Assigns to a property.
+    {
+      code: `
+obj.foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+};
+      `,
+    },
+    {
+      code: `
+obj.foo =
+  foo ||
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+      `,
+    },
+    {
+      code: `
+obj.foo = foo
+  ? bar
+  : function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+      `,
+    },
+    {
+      code: `
+obj.foo = (function () {
+  return function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+})();
+      `,
+    },
+    {
+      code: `
+obj.foo = (() =>
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  })();
+      `,
+    },
+
+    // Bind/Call/Apply
+    `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).call(obj);
+    `,
+    `
+var foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}.bind(obj);
+    `,
+    `
+Reflect.apply(
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+  obj,
+  [],
+);
+    `,
+    `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).apply(obj);
+    `,
+
+    // Class Instance Methods.
+    `
+class A {
+  foo() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
+    `,
+
+    // Class Properties.
+    `
+class A {
+  b = 0;
+  c = this.b;
+}
+    `,
+
+    `
+class A {
+  b = new Array(this, 1, 2, 3);
+}
+    `,
+
+    `
+class A {
+  b = () => {
+    console.log(this);
+  };
+}
+    `,
+
+    // Array methods.
+
+    `
+Array.from(
+  [],
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+  obj,
+);
+    `,
+
+    `
+foo.every(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.filter(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.find(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.findIndex(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.forEach(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.map(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.some(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    // @this tag.
+
+    `
+/** @this Obj */ function foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+    `,
+
+    `
+foo(
+  /* @this Obj */ function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+);
+    `,
+
+    `
+/**
+ * @returns {void}
+ * @this Obj
+ */
+function foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+    `,
+
+    `
+Ctor = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+};
+    `,
+
+    `
+function foo(
+  Ctor = function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+) {}
+    `,
+
+    `
+[
+  obj.method = function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+] = a;
+    `,
+
+    // Static
+
+    `
+class A {
+  static foo() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
+    `,
+    `
+class A {
+  a = 5;
+  b = this.a;
+  accessor c = this.a;
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts b/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
index 8eae0f307e81..2ca40e1de97f 100644
--- a/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
@@ -5,130 +5,107 @@ import rule from '../../src/rules/no-invalid-void-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('allowInGenericTypeArguments: false', rule, {
-  valid: [
-    {
-      code: 'type Generic<T> = [T];',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/1946
-      code: `
-function foo(): void | never {
-  throw new Error('Test');
-}
-      `,
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      code: 'type voidNeverUnion = void | never;',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      code: 'type neverVoidUnion = never | void;',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-  ],
   invalid: [
     {
       code: 'type GenericVoid = Generic<void>;',
-      options: [{ allowInGenericTypeArguments: false }],
       errors: [
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 28,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
       ],
+      options: [{ allowInGenericTypeArguments: false }],
     },
     {
       code: 'function takeVoid(thing: void) {}',
-      options: [{ allowInGenericTypeArguments: false }],
       errors: [
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
       ],
+      options: [{ allowInGenericTypeArguments: false }],
     },
     {
       code: 'let voidPromise: Promise<void> = new Promise<void>(() => {});',
-      options: [{ allowInGenericTypeArguments: false }],
       errors: [
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 46,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
       ],
+      options: [{ allowInGenericTypeArguments: false }],
     },
     {
       code: 'let voidMap: Map<string, void> = new Map<string, void>();',
-      options: [{ allowInGenericTypeArguments: false }],
       errors: [
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 50,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
       ],
+      options: [{ allowInGenericTypeArguments: false }],
     },
     {
       code: 'type invalidVoidUnion = void | number;',
-      options: [{ allowInGenericTypeArguments: false }],
       errors: [
         {
-          messageId: 'invalidVoidNotReturn',
-          line: 1,
           column: 25,
+          line: 1,
+          messageId: 'invalidVoidNotReturn',
         },
       ],
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+  ],
+  valid: [
+    {
+      code: 'type Generic<T> = [T];',
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/1946
+      code: `
+function foo(): void | never {
+  throw new Error('Test');
+}
+      `,
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      code: 'type voidNeverUnion = void | never;',
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      code: 'type neverVoidUnion = never | void;',
+      options: [{ allowInGenericTypeArguments: false }],
     },
   ],
 });
 
 ruleTester.run('allowInGenericTypeArguments: true', rule, {
-  valid: [
-    'function func(): void {}',
-    'type NormalType = () => void;',
-    'let normalArrow = (): void => {};',
-    'let ughThisThing = void 0;',
-    'function takeThing(thing: undefined) {}',
-    'takeThing(void 0);',
-    'let voidPromise: Promise<void> = new Promise<void>(() => {});',
-    'let voidMap: Map<string, void> = new Map<string, void>();',
-    `
-      function returnsVoidPromiseDirectly(): Promise<void> {
-        return Promise.resolve();
-      }
-    `,
-    'async function returnsVoidPromiseAsync(): Promise<void> {}',
-    'type UnionType = string | number;',
-    'type GenericVoid = Generic<void>;',
-    'type Generic<T> = [T];',
-    'type voidPromiseUnion = void | Promise<void>;',
-    'type promiseNeverUnion = Promise<void> | never;',
-    'const arrowGeneric1 = <T = void,>(arg: T) => {};',
-    'declare function functionDeclaration1<T = void>(arg: T): void;',
-  ],
   invalid: [
     {
       code: 'function takeVoid(thing: void) {}',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -136,9 +113,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'const arrowGeneric = <T extends void>(arg: T) => {};',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 33,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -146,9 +123,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'const arrowGeneric2 = <T extends void = void>(arg: T) => {};',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 34,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -156,9 +133,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'function functionGeneric<T extends void>(arg: T) {}',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 36,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -166,9 +143,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'function functionGeneric2<T extends void = void>(arg: T) {}',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 37,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -176,9 +153,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'declare function functionDeclaration<T extends void>(arg: T): void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 48,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -186,9 +163,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'declare function functionDeclaration2<T extends void = void>(arg: T): void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 49,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -196,9 +173,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'functionGeneric<void>(undefined);',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 17,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -206,14 +183,14 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'declare function voidArray(args: void[]): void[];',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 34,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 43,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -221,9 +198,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'let value = undefined as void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -231,9 +208,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'let value = <void>undefined;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 14,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -241,9 +218,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'function takesThings(...things: void[]): void {}',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 33,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -251,9 +228,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type KeyofVoid = keyof void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 24,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -266,9 +243,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       `,
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 4,
           column: 21,
+          line: 4,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -280,9 +257,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       `,
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 3,
           column: 38,
+          line: 3,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -290,9 +267,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'let letVoid: void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 14,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -305,9 +282,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       `,
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 2,
           column: 25,
+          line: 2,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -315,9 +292,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type UnionType2 = string | number | void;',
       errors: [
         {
-          messageId: 'invalidVoidUnionConstituent',
-          line: 1,
           column: 37,
+          line: 1,
+          messageId: 'invalidVoidUnionConstituent',
         },
       ],
     },
@@ -325,9 +302,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type UnionType3 = string | ((number & any) | (string | void));',
       errors: [
         {
-          messageId: 'invalidVoidUnionConstituent',
-          line: 1,
           column: 56,
+          line: 1,
+          messageId: 'invalidVoidUnionConstituent',
         },
       ],
     },
@@ -335,9 +312,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'declare function test(): number | void;',
       errors: [
         {
-          messageId: 'invalidVoidUnionConstituent',
-          line: 1,
           column: 35,
+          line: 1,
+          messageId: 'invalidVoidUnionConstituent',
         },
       ],
     },
@@ -345,9 +322,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'declare function test<T extends number | void>(): T;',
       errors: [
         {
-          messageId: 'invalidVoidUnionConstituent',
-          line: 1,
           column: 42,
+          line: 1,
+          messageId: 'invalidVoidUnionConstituent',
         },
       ],
     },
@@ -355,9 +332,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type IntersectionType = string & number & void;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 43,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -369,9 +346,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       `,
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 3,
           column: 27,
+          line: 3,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -383,9 +360,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       `,
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 3,
           column: 49,
+          line: 3,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -393,9 +370,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type ManyVoid = readonly void[];',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -403,9 +380,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'function foo(arr: readonly void[]) {}',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
           column: 28,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
         },
       ],
     },
@@ -413,16 +390,76 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       code: 'type invalidVoidUnion = void | Map<string, number>;',
       errors: [
         {
-          messageId: 'invalidVoidUnionConstituent',
-          line: 1,
           column: 25,
+          line: 1,
+          messageId: 'invalidVoidUnionConstituent',
         },
       ],
     },
   ],
+  valid: [
+    'function func(): void {}',
+    'type NormalType = () => void;',
+    'let normalArrow = (): void => {};',
+    'let ughThisThing = void 0;',
+    'function takeThing(thing: undefined) {}',
+    'takeThing(void 0);',
+    'let voidPromise: Promise<void> = new Promise<void>(() => {});',
+    'let voidMap: Map<string, void> = new Map<string, void>();',
+    `
+      function returnsVoidPromiseDirectly(): Promise<void> {
+        return Promise.resolve();
+      }
+    `,
+    'async function returnsVoidPromiseAsync(): Promise<void> {}',
+    'type UnionType = string | number;',
+    'type GenericVoid = Generic<void>;',
+    'type Generic<T> = [T];',
+    'type voidPromiseUnion = void | Promise<void>;',
+    'type promiseNeverUnion = Promise<void> | never;',
+    'const arrowGeneric1 = <T = void,>(arg: T) => {};',
+    'declare function functionDeclaration1<T = void>(arg: T): void;',
+  ],
 });
 
 ruleTester.run('allowInGenericTypeArguments: whitelist', rule, {
+  invalid: [
+    {
+      code: 'type BannedVoid = Banned<void>;',
+      errors: [
+        {
+          column: 26,
+          data: { generic: 'Banned' },
+          line: 1,
+          messageId: 'invalidVoidForGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+    },
+    {
+      code: 'type BannedVoid = Ex.Mx.Tx<void>;',
+      errors: [
+        {
+          column: 28,
+          data: { generic: 'Ex.Mx.Tx' },
+          line: 1,
+          messageId: 'invalidVoidForGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Tx'] }],
+    },
+    {
+      code: 'function takeVoid(thing: void) {}',
+      errors: [
+        {
+          column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+    },
+  ],
   valid: [
     'type Allowed<T> = [T];',
     'type Banned<T> = [T];',
@@ -474,46 +511,44 @@ async function foo(bar: () => void | Promise<void>) {
       options: [{ allowInGenericTypeArguments: ['Promise'] }],
     },
   ],
+});
+
+ruleTester.run('allowAsThisParameter: true', rule, {
   invalid: [
     {
-      code: 'type BannedVoid = Banned<void>;',
-      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+      code: 'type alias = void;',
       errors: [
         {
-          messageId: 'invalidVoidForGeneric',
-          data: { generic: 'Banned' },
-          line: 1,
-          column: 26,
+          messageId: 'invalidVoidNotReturnOrThisParamOrGeneric',
         },
       ],
+      options: [
+        { allowAsThisParameter: true, allowInGenericTypeArguments: true },
+      ],
     },
     {
-      code: 'type BannedVoid = Ex.Mx.Tx<void>;',
-      options: [{ allowInGenericTypeArguments: ['Tx'] }],
+      code: 'type alias = void;',
       errors: [
         {
-          messageId: 'invalidVoidForGeneric',
-          data: { generic: 'Ex.Mx.Tx' },
-          line: 1,
-          column: 28,
+          messageId: 'invalidVoidNotReturnOrThisParam',
         },
       ],
+      options: [
+        { allowAsThisParameter: true, allowInGenericTypeArguments: false },
+      ],
     },
     {
-      code: 'function takeVoid(thing: void) {}',
-      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+      code: 'type alias = Array<void>;',
       errors: [
         {
-          messageId: 'invalidVoidNotReturnOrGeneric',
-          line: 1,
-          column: 26,
+          messageId: 'invalidVoidNotReturnOrThisParam',
         },
       ],
+      options: [
+        { allowAsThisParameter: true, allowInGenericTypeArguments: false },
+      ],
     },
   ],
-});
-
-ruleTester.run('allowAsThisParameter: true', rule, {
   valid: [
     {
       code: 'function f(this: void) {}',
@@ -529,39 +564,4 @@ class Test {
       options: [{ allowAsThisParameter: true }],
     },
   ],
-  invalid: [
-    {
-      code: 'type alias = void;',
-      options: [
-        { allowAsThisParameter: true, allowInGenericTypeArguments: true },
-      ],
-      errors: [
-        {
-          messageId: 'invalidVoidNotReturnOrThisParamOrGeneric',
-        },
-      ],
-    },
-    {
-      code: 'type alias = void;',
-      options: [
-        { allowAsThisParameter: true, allowInGenericTypeArguments: false },
-      ],
-      errors: [
-        {
-          messageId: 'invalidVoidNotReturnOrThisParam',
-        },
-      ],
-    },
-    {
-      code: 'type alias = Array<void>;',
-      options: [
-        { allowAsThisParameter: true, allowInGenericTypeArguments: false },
-      ],
-      errors: [
-        {
-          messageId: 'invalidVoidNotReturnOrThisParam',
-        },
-      ],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-loop-func.test.ts b/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
index 613af3dc04ec..91aa77a2b3a4 100644
--- a/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
@@ -6,6 +6,7 @@ import rule from '../../src/rules/no-loop-func';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-loop-func', rule, {
+  invalid: [],
   valid: [
     `
 let someArray: MyType[] = [];
@@ -47,231 +48,10 @@ for (let i = 0; i < 10; i += 1) {
 }
     `,
   ],
-  invalid: [],
 });
 
 // Forked from https://github.com/eslint/eslint/blob/bf2e367bf4f6fde9930af9de8b8d8bc3d8b5782f/tests/lib/rules/no-loop-func.js
 ruleTester.run('no-loop-func ESLint tests', rule, {
-  valid: [
-    "string = 'function a() {}';",
-    `
-for (var i = 0; i < l; i++) {}
-var a = function () {
-  i;
-};
-    `,
-    `
-for (
-  var i = 0,
-    a = function () {
-      i;
-    };
-  i < l;
-  i++
-) {}
-    `,
-    `
-for (var x in xs.filter(function (x) {
-  return x != upper;
-})) {
-}
-    `,
-    {
-      code: `
-for (var x of xs.filter(function (x) {
-  return x != upper;
-})) {
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-
-    // no refers to variables that declared on upper scope.
-    `
-for (var i = 0; i < l; i++) {
-  (function () {});
-}
-    `,
-    `
-for (var i in {}) {
-  (function () {});
-}
-    `,
-    {
-      code: `
-for (var i of {}) {
-  (function () {});
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-
-    // functions which are using unmodified variables are OK.
-    {
-      code: `
-for (let i = 0; i < l; i++) {
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (let i in {}) {
-  i = 7;
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (const i of {}) {
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (let i = 0; i < 10; ++i) {
-  for (let x in xs.filter(x => x != i)) {
-  }
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i in {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i of {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    (function () {
-      a;
-    });
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i in {}) {
-  function foo() {
-    (function () {
-      a;
-    });
-  }
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i of {}) {
-  () => {
-    (function () {
-      a;
-    });
-  };
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i in {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i of {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: [
-        'let result = {};',
-        'for (const score in scores) {',
-        '  const letters = scores[score];',
-        "  letters.split('').forEach(letter => {",
-        '    result[letter] = score;',
-        '  });',
-        '}',
-        'result.__default = 6;',
-      ].join('\n'),
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: ['while (true) {', '    (function() { a; });', '}', 'let a;'].join(
-        '\n',
-      ),
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-  ],
   invalid: [
     {
       code: `
@@ -283,8 +63,8 @@ for (var i = 0; i < l; i++) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -301,8 +81,8 @@ for (var i = 0; i < l; i++) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i', 'j'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -317,8 +97,8 @@ for (var i in {}) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -331,14 +111,14 @@ for (var i of {}) {
   });
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -348,14 +128,14 @@ for (var i = 0; i < l; i++) {
   };
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.ArrowFunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -367,8 +147,8 @@ for (var i = 0; i < l; i++) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -384,8 +164,8 @@ for (var i = 0; i < l; i++) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionDeclaration,
         },
       ],
@@ -403,8 +183,8 @@ for (
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -422,8 +202,8 @@ for (
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -438,8 +218,8 @@ while (i) {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -454,8 +234,8 @@ do {
       `,
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
@@ -472,14 +252,14 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -491,14 +271,14 @@ for (let i in {}) {
   a = 1;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -510,14 +290,14 @@ for (let i of {}) {
 }
 a = 1;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -531,14 +311,14 @@ for (let i = 0; i < l; i++) {
   a = 1;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -552,14 +332,14 @@ for (let i in {}) {
   }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionDeclaration,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -573,14 +353,14 @@ for (let i of {}) {
 }
 a = 1;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.ArrowFunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -589,14 +369,14 @@ for (var i = 0; i < 10; ++i) {
   }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'i'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.ArrowFunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -610,14 +390,14 @@ for (let x of xs) {
   }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -629,14 +409,14 @@ for (var x of xs) {
   }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'x'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -646,14 +426,14 @@ for (var x of xs) {
   });
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'x'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -665,14 +445,14 @@ for (let x of xs) {
   });
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -684,14 +464,14 @@ for (let x of xs) {
   a = 1;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -706,14 +486,14 @@ for (let x of xs) {
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -728,14 +508,234 @@ function foo() {
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'unsafeRefs',
           data: { varNames: "'a'" },
+          messageId: 'unsafeRefs',
           type: AST_NODE_TYPES.FunctionExpression,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+  ],
+  valid: [
+    "string = 'function a() {}';",
+    `
+for (var i = 0; i < l; i++) {}
+var a = function () {
+  i;
+};
+    `,
+    `
+for (
+  var i = 0,
+    a = function () {
+      i;
+    };
+  i < l;
+  i++
+) {}
+    `,
+    `
+for (var x in xs.filter(function (x) {
+  return x != upper;
+})) {
+}
+    `,
+    {
+      code: `
+for (var x of xs.filter(function (x) {
+  return x != upper;
+})) {
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+
+    // no refers to variables that declared on upper scope.
+    `
+for (var i = 0; i < l; i++) {
+  (function () {});
+}
+    `,
+    `
+for (var i in {}) {
+  (function () {});
+}
+    `,
+    {
+      code: `
+for (var i of {}) {
+  (function () {});
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+
+    // functions which are using unmodified variables are OK.
+    {
+      code: `
+for (let i = 0; i < l; i++) {
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (let i in {}) {
+  i = 7;
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (const i of {}) {
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (let i = 0; i < 10; ++i) {
+  for (let x in xs.filter(x => x != i)) {
+  }
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i in {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i of {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    (function () {
+      a;
+    });
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i in {}) {
+  function foo() {
+    (function () {
+      a;
+    });
+  }
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i of {}) {
+  () => {
+    (function () {
+      a;
+    });
+  };
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i in {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i of {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: [
+        'let result = {};',
+        'for (const score in scores) {',
+        '  const letters = scores[score];',
+        "  letters.split('').forEach(letter => {",
+        '    result[letter] = score;',
+        '  });',
+        '}',
+        'result.__default = 6;',
+      ].join('\n'),
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: ['while (true) {', '    (function() { a; });', '}', 'let a;'].join(
+        '\n',
+      ),
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts b/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
index 105eacfc2250..2a1547b59cf1 100644
--- a/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
@@ -5,14 +5,6 @@ import rule from '../../src/rules/no-loss-of-precision';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-loss-of-precision', rule, {
-  valid: [
-    'const x = 12345;',
-    'const x = 123.456;',
-    'const x = -123.456;',
-    'const x = 123_456;',
-    'const x = 123_00_000_000_000_000_000_000_000;',
-    'const x = 123.000_000_000_000_000_000_000_0;',
-  ],
   invalid: [
     {
       code: 'const x = 9007199254740993;',
@@ -31,4 +23,12 @@ ruleTester.run('no-loss-of-precision', rule, {
       errors: [{ messageId: 'noLossOfPrecision' }],
     },
   ],
+  valid: [
+    'const x = 12345;',
+    'const x = 123.456;',
+    'const x = -123.456;',
+    'const x = 123_456;',
+    'const x = 123_00_000_000_000_000_000_000_000;',
+    'const x = 123.000_000_000_000_000_000_000_0;',
+  ],
 });
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 b50c25224e01..da2f2ab6d46c 100644
--- a/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
@@ -5,317 +5,86 @@ import rule from '../../src/rules/no-magic-numbers';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-magic-numbers', rule, {
-  valid: [
-    {
-      code: 'const FOO = 10;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: "type Foo = 'bar';",
-    },
-    {
-      code: 'type Foo = true;',
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = -1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = 1 | -1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: `
-        enum foo {
-          SECOND = 1000,
-          NUM = '0123456789',
-          NEG = -1,
-          POS = +1,
-        }
-      `,
-      options: [{ ignoreEnums: true }],
-    },
-    {
-      code: `
-class Foo {
-  readonly A = 1;
-  readonly B = 2;
-  public static readonly C = 1;
-  static readonly D = 1;
-  readonly E = -1;
-  readonly F = +1;
-  private readonly G = 100n;
-}
-      `,
-      options: [{ ignoreReadonlyClassProperties: true }],
-    },
-    {
-      code: 'type Foo = Bar[0];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[-1];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[0xab];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[5.6e1];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[10n];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 | -2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 & -2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 & number];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[((1 & -2) | 3) | 4];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Parameters<Bar>[2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: "type Foo = Bar['baz'];",
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: "type Foo = Bar['baz'];",
-      options: [{ ignoreTypeIndexes: false }],
-    },
-    {
-      code: `
-type Others = [['a'], ['b']];
-
-type Foo = {
-  [K in keyof Others[0]]: Others[K];
-};
-      `,
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ ignore: [1] }],
-    },
-    {
-      code: 'type Foo = -2;',
-      options: [{ ignore: [-2] }],
-    },
-    {
-      code: 'type Foo = 3n;',
-      options: [{ ignore: ['3n'] }],
-    },
-    {
-      code: 'type Foo = -4n;',
-      options: [{ ignore: ['-4n'] }],
-    },
-    {
-      code: 'type Foo = 5.6;',
-      options: [{ ignore: [5.6] }],
-    },
-    {
-      code: 'type Foo = -7.8;',
-      options: [{ ignore: [-7.8] }],
-    },
-    {
-      code: 'type Foo = 0x0a;',
-      options: [{ ignore: [0x0a] }],
-    },
-    {
-      code: 'type Foo = -0xbc;',
-      options: [{ ignore: [-0xbc] }],
-    },
-    {
-      code: 'type Foo = 1e2;',
-      options: [{ ignore: [1e2] }],
-    },
-    {
-      code: 'type Foo = -3e4;',
-      options: [{ ignore: [-3e4] }],
-    },
-    {
-      code: 'type Foo = 5e-6;',
-      options: [{ ignore: [5e-6] }],
-    },
-    {
-      code: 'type Foo = -7e-8;',
-      options: [{ ignore: [-7e-8] }],
-    },
-    {
-      code: 'type Foo = 1.1e2;',
-      options: [{ ignore: [1.1e2] }],
-    },
-    {
-      code: 'type Foo = -3.1e4;',
-      options: [{ ignore: [-3.1e4] }],
-    },
-    {
-      code: 'type Foo = 5.1e-6;',
-      options: [{ ignore: [5.1e-6] }],
-    },
-    {
-      code: 'type Foo = -7.1e-8;',
-      options: [{ ignore: [-7.1e-8] }],
-    },
-    {
-      code: `
-interface Foo {
-  bar: 1;
-}
-      `,
-      options: [{ ignoreNumericLiteralTypes: true, ignore: [1] }],
-    },
-    {
-      code: `
-enum foo {
-  SECOND = 1000,
-  NUM = '0123456789',
-  NEG = -1,
-  POS = +2,
-}
-      `,
-      options: [{ ignoreEnums: false, ignore: [1000, -1, 2] }],
-    },
-    {
-      code: `
-class Foo {
-  readonly A = 1;
-  readonly B = 2;
-  public static readonly C = 3;
-  static readonly D = 4;
-  readonly E = -5;
-  readonly F = +6;
-  private readonly G = 100n;
-  private static readonly H = -2000n;
-}
-      `,
-      options: [
-        {
-          ignoreReadonlyClassProperties: false,
-          ignore: [1, 2, 3, 4, -5, 6, '100n', '-2000n'],
-        },
-      ],
-    },
-    {
-      code: 'type Foo = Bar[0];',
-      options: [{ ignoreTypeIndexes: false, ignore: [0] }],
-    },
-    {
-      code: `
-type Other = {
-  [0]: 3;
-};
-
-type Foo = {
-  [K in keyof Other]: \`\${K & number}\`;
-};
-      `,
-      options: [{ ignoreTypeIndexes: true, ignore: [0, 3] }],
-    },
-  ],
-
   invalid: [
     {
       code: 'type Foo = 1;',
-      options: [{ ignoreNumericLiteralTypes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreNumericLiteralTypes: false }],
     },
     {
       code: 'type Foo = -1;',
-      options: [{ ignoreNumericLiteralTypes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-1',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreNumericLiteralTypes: false }],
     },
     {
       code: 'type Foo = 1 | 2 | 3;',
-      options: [{ ignoreNumericLiteralTypes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '2',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 20,
           data: {
             raw: '3',
           },
           line: 1,
-          column: 20,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreNumericLiteralTypes: false }],
     },
     {
       code: 'type Foo = 1 | -1;',
-      options: [{ ignoreNumericLiteralTypes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '-1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreNumericLiteralTypes: false }],
     },
     {
       code: `
@@ -323,17 +92,17 @@ interface Foo {
   bar: 1;
 }
       `,
-      options: [{ ignoreNumericLiteralTypes: true }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 8,
           data: {
             raw: '1',
           },
           line: 3,
-          column: 8,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreNumericLiteralTypes: true }],
     },
     {
       code: `
@@ -344,33 +113,33 @@ enum foo {
   POS = +1,
 }
       `,
-      options: [{ ignoreEnums: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1000',
           },
           line: 3,
-          column: 12,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 9,
           data: {
             raw: '-1',
           },
           line: 5,
-          column: 9,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 10,
           data: {
             raw: '1',
           },
           line: 6,
-          column: 10,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreEnums: false }],
     },
     {
       code: `
@@ -384,245 +153,245 @@ class Foo {
   private readonly G = 100n;
 }
       `,
-      options: [{ ignoreReadonlyClassProperties: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '1',
           },
           line: 3,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '2',
           },
           line: 4,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 30,
           data: {
             raw: '3',
           },
           line: 5,
-          column: 30,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 23,
           data: {
             raw: '4',
           },
           line: 6,
-          column: 23,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '-5',
           },
           line: 7,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 17,
           data: {
             raw: '6',
           },
           line: 8,
-          column: 17,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 24,
           data: {
             raw: '100n',
           },
           line: 9,
-          column: 24,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreReadonlyClassProperties: false }],
     },
     {
       code: 'type Foo = Bar[0];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '0',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[-1];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '-1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[0xab];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '0xab',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[5.6e1];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '5.6e1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[10n];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '10n',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[1 | -2];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 20,
           data: {
             raw: '-2',
           },
           line: 1,
-          column: 20,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[1 & -2];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 20,
           data: {
             raw: '-2',
           },
           line: 1,
-          column: 20,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[1 & number];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 16,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 16,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Bar[((1 & -2) | 3) | 4];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 18,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 18,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 22,
           data: {
             raw: '-2',
           },
           line: 1,
-          column: 22,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 28,
           data: {
             raw: '3',
           },
           line: 1,
-          column: 28,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 33,
           data: {
             raw: '4',
           },
           line: 1,
-          column: 33,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: 'type Foo = Parameters<Bar>[2];',
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 28,
           data: {
             raw: '2',
           },
           line: 1,
-          column: 28,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: `
@@ -632,17 +401,17 @@ type Foo = {
   [K in keyof Others[0]]: Others[K];
 };
       `,
-      options: [{ ignoreTypeIndexes: false }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 22,
           data: {
             raw: '0',
           },
           line: 5,
-          column: 22,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: false }],
     },
     {
       code: `
@@ -654,25 +423,25 @@ type Foo = {
   [K in keyof Other]: \`\${K & number}\`;
 };
       `,
-      options: [{ ignoreTypeIndexes: true }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 4,
           data: {
             raw: '0',
           },
           line: 3,
-          column: 4,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 8,
           data: {
             raw: '3',
           },
           line: 3,
-          column: 8,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: true }],
     },
     {
       code: `
@@ -680,265 +449,496 @@ type Foo = {
   [K in 0 | 1 | 2]: 0;
 };
       `,
-      options: [{ ignoreTypeIndexes: true }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 9,
           data: {
             raw: '0',
           },
           line: 3,
-          column: 9,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 13,
           data: {
             raw: '1',
           },
           line: 3,
-          column: 13,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 17,
           data: {
             raw: '2',
           },
           line: 3,
-          column: 17,
+          messageId: 'noMagic',
         },
         {
-          messageId: 'noMagic',
+          column: 21,
           data: {
             raw: '0',
           },
           line: 3,
-          column: 21,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignoreTypeIndexes: true }],
     },
     {
       code: 'type Foo = 1;',
-      options: [{ ignore: [-1] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-1] }],
     },
     {
       code: 'type Foo = -2;',
-      options: [{ ignore: [2] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-2',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [2] }],
     },
     {
       code: 'type Foo = 3n;',
-      options: [{ ignore: ['-3n'] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '3n',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: ['-3n'] }],
     },
     {
       code: 'type Foo = -4n;',
-      options: [{ ignore: ['4n'] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-4n',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: ['4n'] }],
     },
     {
       code: 'type Foo = 5.6;',
-      options: [{ ignore: [-5.6] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '5.6',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-5.6] }],
     },
     {
       code: 'type Foo = -7.8;',
-      options: [{ ignore: [7.8] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-7.8',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [7.8] }],
     },
     {
       code: 'type Foo = 0x0a;',
-      options: [{ ignore: [-0x0a] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '0x0a',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-0x0a] }],
     },
     {
       code: 'type Foo = -0xbc;',
-      options: [{ ignore: [0xbc] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-0xbc',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [0xbc] }],
     },
     {
       code: 'type Foo = 1e2;',
-      options: [{ ignore: [-1e2] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1e2',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-1e2] }],
     },
     {
       code: 'type Foo = -3e4;',
-      options: [{ ignore: [3e4] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-3e4',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [3e4] }],
     },
     {
       code: 'type Foo = 5e-6;',
-      options: [{ ignore: [-5e-6] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '5e-6',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-5e-6] }],
     },
     {
       code: 'type Foo = -7e-8;',
-      options: [{ ignore: [7e-8] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-7e-8',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [7e-8] }],
     },
     {
       code: 'type Foo = 1.1e2;',
-      options: [{ ignore: [-1.1e2] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '1.1e2',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-1.1e2] }],
     },
     {
       code: 'type Foo = -3.1e4;',
-      options: [{ ignore: [3.1e4] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-3.1e4',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [3.1e4] }],
     },
     {
       code: 'type Foo = 5.1e-6;',
-      options: [{ ignore: [-5.1e-6] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '5.1e-6',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [-5.1e-6] }],
     },
     {
       code: 'type Foo = -7.1e-8;',
-      options: [{ ignore: [7.1e-8] }],
       errors: [
         {
-          messageId: 'noMagic',
+          column: 12,
           data: {
             raw: '-7.1e-8',
           },
           line: 1,
-          column: 12,
+          messageId: 'noMagic',
         },
       ],
+      options: [{ ignore: [7.1e-8] }],
+    },
+  ],
+
+  valid: [
+    {
+      code: 'const FOO = 10;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: "type Foo = 'bar';",
+    },
+    {
+      code: 'type Foo = true;',
+    },
+    {
+      code: 'type Foo = 1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = -1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = 1 | -1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: `
+        enum foo {
+          SECOND = 1000,
+          NUM = '0123456789',
+          NEG = -1,
+          POS = +1,
+        }
+      `,
+      options: [{ ignoreEnums: true }],
+    },
+    {
+      code: `
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+  readonly E = -1;
+  readonly F = +1;
+  private readonly G = 100n;
+}
+      `,
+      options: [{ ignoreReadonlyClassProperties: true }],
+    },
+    {
+      code: 'type Foo = Bar[0];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[-1];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[0xab];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[5.6e1];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[10n];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 | -2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 & -2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 & number];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[((1 & -2) | 3) | 4];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Parameters<Bar>[2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: "type Foo = Bar['baz'];",
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: "type Foo = Bar['baz'];",
+      options: [{ ignoreTypeIndexes: false }],
+    },
+    {
+      code: `
+type Others = [['a'], ['b']];
+
+type Foo = {
+  [K in keyof Others[0]]: Others[K];
+};
+      `,
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = 1;',
+      options: [{ ignore: [1] }],
+    },
+    {
+      code: 'type Foo = -2;',
+      options: [{ ignore: [-2] }],
+    },
+    {
+      code: 'type Foo = 3n;',
+      options: [{ ignore: ['3n'] }],
+    },
+    {
+      code: 'type Foo = -4n;',
+      options: [{ ignore: ['-4n'] }],
+    },
+    {
+      code: 'type Foo = 5.6;',
+      options: [{ ignore: [5.6] }],
+    },
+    {
+      code: 'type Foo = -7.8;',
+      options: [{ ignore: [-7.8] }],
+    },
+    {
+      code: 'type Foo = 0x0a;',
+      options: [{ ignore: [0x0a] }],
+    },
+    {
+      code: 'type Foo = -0xbc;',
+      options: [{ ignore: [-0xbc] }],
+    },
+    {
+      code: 'type Foo = 1e2;',
+      options: [{ ignore: [1e2] }],
+    },
+    {
+      code: 'type Foo = -3e4;',
+      options: [{ ignore: [-3e4] }],
+    },
+    {
+      code: 'type Foo = 5e-6;',
+      options: [{ ignore: [5e-6] }],
+    },
+    {
+      code: 'type Foo = -7e-8;',
+      options: [{ ignore: [-7e-8] }],
+    },
+    {
+      code: 'type Foo = 1.1e2;',
+      options: [{ ignore: [1.1e2] }],
+    },
+    {
+      code: 'type Foo = -3.1e4;',
+      options: [{ ignore: [-3.1e4] }],
+    },
+    {
+      code: 'type Foo = 5.1e-6;',
+      options: [{ ignore: [5.1e-6] }],
+    },
+    {
+      code: 'type Foo = -7.1e-8;',
+      options: [{ ignore: [-7.1e-8] }],
+    },
+    {
+      code: `
+interface Foo {
+  bar: 1;
+}
+      `,
+      options: [{ ignore: [1], ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: `
+enum foo {
+  SECOND = 1000,
+  NUM = '0123456789',
+  NEG = -1,
+  POS = +2,
+}
+      `,
+      options: [{ ignore: [1000, -1, 2], ignoreEnums: false }],
+    },
+    {
+      code: `
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 3;
+  static readonly D = 4;
+  readonly E = -5;
+  readonly F = +6;
+  private readonly G = 100n;
+  private static readonly H = -2000n;
+}
+      `,
+      options: [
+        {
+          ignore: [1, 2, 3, 4, -5, 6, '100n', '-2000n'],
+          ignoreReadonlyClassProperties: false,
+        },
+      ],
+    },
+    {
+      code: 'type Foo = Bar[0];',
+      options: [{ ignore: [0], ignoreTypeIndexes: false }],
+    },
+    {
+      code: `
+type Other = {
+  [0]: 3;
+};
+
+type Foo = {
+  [K in keyof Other]: \`\${K & number}\`;
+};
+      `,
+      options: [{ ignore: [0, 3], ignoreTypeIndexes: true }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts b/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
index c170f576b577..db16bc4915ff 100644
--- a/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
@@ -8,64 +8,43 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-meaningless-void-operator', rule, {
-  valid: [
-    `
-(() => {})();
-
-function foo() {}
-foo(); // nothing to discard
-
-function bar(x: number) {
-  void x;
-  return 2;
-}
-void bar(); // discarding a number
-    `,
-    `
-function bar(x: never) {
-  void x;
-}
-    `,
-  ],
   invalid: [
     {
       code: 'void (() => {})();',
-      output: '(() => {})();',
       errors: [
         {
-          messageId: 'meaninglessVoidOperator',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'meaninglessVoidOperator',
         },
       ],
+      output: '(() => {})();',
     },
     {
       code: `
 function foo() {}
 void foo();
-      `,
-      output: `
-function foo() {}
-foo();
       `,
       errors: [
         {
-          messageId: 'meaninglessVoidOperator',
-          line: 3,
           column: 1,
+          line: 3,
+          messageId: 'meaninglessVoidOperator',
         },
       ],
+      output: `
+function foo() {}
+foo();
+      `,
     },
     {
-      options: [{ checkNever: true }],
-      output: null,
       code: `
 function bar(x: never) {
   void x;
@@ -73,9 +52,9 @@ function bar(x: never) {
       `,
       errors: [
         {
-          messageId: 'meaninglessVoidOperator',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'meaninglessVoidOperator',
           suggestions: [
             {
               messageId: 'removeVoid',
@@ -88,6 +67,27 @@ function bar(x: never) {
           ],
         },
       ],
+      options: [{ checkNever: true }],
+      output: null,
     },
   ],
+  valid: [
+    `
+(() => {})();
+
+function foo() {}
+foo(); // nothing to discard
+
+function bar(x: number) {
+  void x;
+  return 2;
+}
+void bar(); // discarding a number
+    `,
+    `
+function bar(x: never) {
+  void x;
+}
+    `,
+  ],
 });
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 d6bc3b9210c6..c40c195fc858 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
@@ -5,74 +5,6 @@ import rule from '../../src/rules/no-misused-new';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-misused-new', rule, {
-  valid: [
-    `
-declare abstract class C {
-  foo() {}
-  get new();
-  bar();
-}
-    `,
-    `
-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() {}
-};
-    `,
-    // OK if return type is not the interface.
-    `
-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';
-}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -83,14 +15,14 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'errorMessageInterface',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageInterface',
         },
         {
-          messageId: 'errorMessageInterface',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'errorMessageInterface',
         },
       ],
     },
@@ -103,9 +35,9 @@ interface G {
       `,
       errors: [
         {
-          messageId: 'errorMessageInterface',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageInterface',
         },
       ],
     },
@@ -118,9 +50,9 @@ type T = {
       `,
       errors: [
         {
-          messageId: 'errorMessageInterface',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageInterface',
         },
       ],
     },
@@ -132,9 +64,9 @@ class C {
       `,
       errors: [
         {
-          messageId: 'errorMessageClass',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageClass',
         },
       ],
     },
@@ -146,9 +78,9 @@ declare abstract class C {
       `,
       errors: [
         {
-          messageId: 'errorMessageClass',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageClass',
         },
       ],
     },
@@ -160,11 +92,79 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'errorMessageInterface',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'errorMessageInterface',
         },
       ],
     },
   ],
+  valid: [
+    `
+declare abstract class C {
+  foo() {}
+  get new();
+  bar();
+}
+    `,
+    `
+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() {}
+};
+    `,
+    // OK if return type is not the interface.
+    `
+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';
+}
+    `,
+  ],
 });
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 fc2229b31cf4..d5aa959f11ef 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
@@ -8,31 +8,26 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-misused-promises', rule, {
-  valid: [
-    `
-if (true) {
-}
-    `,
+  invalid: [
     {
       code: `
 if (Promise.resolve()) {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+      ],
     },
-    `
-if (true) {
-} else if (false) {
-} else {
-}
-    `,
     {
       code: `
 if (Promise.resolve()) {
@@ -40,1461 +35,1437 @@ if (Promise.resolve()) {
 } else {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'for (;;) {}',
-    'for (let i; i < 10; i++) {}',
     {
       code: 'for (let i; Promise.resolve(); i++) {}',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'do {} while (true);',
     {
       code: 'do {} while (Promise.resolve());',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'while (true) {}',
     {
       code: 'while (Promise.resolve()) {}',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'true ? 123 : 456;',
     {
       code: 'Promise.resolve() ? 123 : 456;',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    `
-if (!true) {
-}
-    `,
     {
       code: `
 if (!Promise.resolve()) {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+      ],
     },
-    '(await Promise.resolve()) || false;',
     {
       code: 'Promise.resolve() || false;',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    '(true && (await Promise.resolve())) || false;',
     {
-      code: '(true && Promise.resolve()) || false;',
-      options: [{ checksConditionals: false }],
+      code: `
+[Promise.resolve(), Promise.reject()].forEach(async val => {
+  await val;
+});
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
-    'false || (true && Promise.resolve());',
-    '(true && Promise.resolve()) || false;',
-    `
-async function test() {
-  if (await Promise.resolve()) {
-  }
-}
-    `,
-    `
-async function test() {
-  const mixed: Promise | undefined = Promise.resolve();
-  if (mixed) {
-    await mixed;
-  }
-}
-    `,
-    `
-if (~Promise.resolve()) {
-}
-    `,
-    `
-interface NotQuiteThenable {
-  then(param: string): void;
-  then(): void;
-}
-const value: NotQuiteThenable = { then() {} };
-if (value) {
-}
-    `,
-    '[1, 2, 3].forEach(val => {});',
     {
-      code: '[1, 2, 3].forEach(async val => {});',
-      options: [{ checksVoidReturn: false }],
+      code: `
+new Promise(async (resolve, reject) => {
+  await Promise.resolve();
+  resolve();
+});
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
-    'new Promise((resolve, reject) => resolve());',
     {
-      code: 'new Promise(async (resolve, reject) => resolve());',
-      options: [{ checksVoidReturn: false }],
-    },
-    `
-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: { call: () => Promise<void> } | null;
-if (returnsPromise?.call()) {
-}
-    `,
-    'Promise.resolve() ?? false;',
-    `
-function test(a: Promise<void> | undefinded) {
-  const foo = a ?? Promise.reject();
-}
-    `,
-    `
-function test(p: Promise<boolean> | undefined, bool: boolean) {
-  if (p ?? bool) {
-  }
-}
-    `,
-    `
-async function test(p: Promise<boolean | undefined>, bool: boolean) {
-  if ((await p) ?? bool) {
-  }
-}
-    `,
-    `
-async function test(p: Promise<boolean> | undefined) {
-  if (await (p ?? Promise.reject())) {
-  }
-}
-    `,
-    `
-let f;
-f = async () => 10;
-    `,
-    `
-let f: () => Promise<void>;
-f = async () => 10;
-const g = async () => 0;
-const h: () => Promise<void> = async () => 10;
-    `,
-    `
-const obj = {
-  f: async () => 10,
-};
-    `,
-    `
-const f = async () => 123;
-const obj = {
-  f,
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
 };
-    `,
-    `
-const obj = {
-  async f() {
-    return 0;
-  },
+
+fnWithCallback('val', async (err, res) => {
+  await res;
+});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
 };
-    `,
-    `
-type O = { f: () => Promise<void>; g: () => Promise<void> };
-const g = async () => 0;
-const obj: O = {
-  f: async () => 10,
-  g,
+
+fnWithCallback('val', (err, res) => Promise.resolve(res));
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
 };
-    `,
-    `
-type O = { f: () => Promise<void> };
-const name = 'f';
-const obj: O = {
-  async [name]() {
-    return 10;
-  },
-};
-    `,
-    `
-const obj: number = {
-  g() {
-    return 10;
-  },
-};
-    `,
-    `
-const obj = {
-  f: async () => 'foo',
-  async g() {
-    return 0;
-  },
-};
-    `,
-    `
-function f() {
-  return async () => 0;
-}
-function g() {
-  return;
-}
-    `,
-    {
-      code: `
-type O = {
-  bool: boolean;
-  func: () => Promise<void>;
-};
-const Component = (obj: O) => null;
-<Component bool func={async () => 10} />;
+
+fnWithCallback('val', (err, res) => {
+  if (err) {
+    return 'abc';
+  } else {
+    return Promise.resolve(res);
+  }
+});
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
         },
-      },
+      ],
     },
     {
       code: `
-const Component: any = () => null;
-<Component func={async () => 10} />;
+const fnWithCallback:
+  | ((arg: string, cb: (err: any, res: string) => void) => void)
+  | null = (arg, cb) => {
+  cb(null, arg);
+};
+
+fnWithCallback?.('val', (err, res) => Promise.resolve(res));
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
         },
-      },
+      ],
     },
     {
       code: `
-interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
-  (name: string, callback: () => void): void;
-}
-
-declare const it: ItLike;
+const fnWithCallback:
+  | ((arg: string, cb: (err: any, res: string) => void) => void)
+  | null = (arg, cb) => {
+  cb(null, arg);
+};
 
-it('', async () => {});
+fnWithCallback('val', (err, res) => {
+  if (err) {
+    return 'abc';
+  } else {
+    return Promise.resolve(res);
+  }
+});
       `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
-interface ItLike {
-  (name: string, callback: () => void): void;
-  (name: string, callback: () => Promise<void>): void;
+function test(bool: boolean, p: Promise<void>) {
+  if (bool || p) {
+  }
 }
-
-declare const it: ItLike;
-
-it('', async () => {});
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
     },
     {
       code: `
-interface ItLike {
-  (name: string, callback: () => void): void;
-}
-interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
+function test(bool: boolean, p: Promise<void>) {
+  if (bool && p) {
+  }
 }
-
-declare const it: ItLike;
-
-it('', async () => {});
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
     },
     {
       code: `
-interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
-}
-interface ItLike {
-  (name: string, callback: () => void): void;
+function test(a: any, p: Promise<void>) {
+  if (a ?? p) {
+  }
 }
-
-declare const it: ItLike;
-
-it('', async () => {});
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
     },
     {
       code: `
-interface Props {
-  onEvent: (() => void) | (() => Promise<void>);
+function test(p: Promise<void> | undefined) {
+  if (p ?? Promise.reject()) {
+  }
 }
-
-declare function Component(props: Props): any;
-
-const _ = <Component onEvent={async () => {}} />;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
         },
-      },
+      ],
     },
-    `
-console.log({ ...(await Promise.resolve({ key: 42 })) });
-    `,
-    `
-const getData = () => Promise.resolve({ key: 42 });
-
-console.log({
-  someData: 42,
-  ...(await getData()),
-});
-    `,
-    `
-declare const condition: boolean;
-
-console.log({ ...(condition && (await Promise.resolve({ key: 42 }))) });
-console.log({ ...(condition || (await Promise.resolve({ key: 42 }))) });
-console.log({ ...(condition ? {} : await Promise.resolve({ key: 42 })) });
-console.log({ ...(condition ? await Promise.resolve({ key: 42 }) : {}) });
-    `,
-    `
-console.log([...(await Promise.resolve(42))]);
-    `,
     {
       code: `
-console.log({ ...Promise.resolve({ key: 42 }) });
+let f: () => void;
+f = async () => {
+  return 3;
+};
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnVariable',
+        },
+      ],
     },
     {
       code: `
-const getData = () => Promise.resolve({ key: 42 });
-
-console.log({
-  someData: 42,
-  ...getData(),
-});
+let f: () => void;
+f = async () => {
+  return 3;
+};
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnVariable',
+        },
+      ],
+      options: [{ checksVoidReturn: { variables: true } }],
     },
     {
       code: `
-declare const condition: boolean;
-
-console.log({ ...(condition && Promise.resolve({ key: 42 })) });
-console.log({ ...(condition || Promise.resolve({ key: 42 })) });
-console.log({ ...(condition ? {} : Promise.resolve({ key: 42 })) });
-console.log({ ...(condition ? Promise.resolve({ key: 42 }) : {}) });
+const f: () => void = async () => {
+  return 0;
+};
+const g = async () => 1,
+  h: () => void = async () => {};
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnVariable',
+        },
+        {
+          line: 6,
+          messageId: 'voidReturnVariable',
+        },
+      ],
     },
     {
       code: `
-// This is invalid Typescript, but it shouldn't trigger this linter specifically
-console.log([...Promise.resolve(42)]);
-      `,
-      options: [{ checksSpreads: false }],
-    },
-    `
-function spreadAny(..._args: any): void {}
-
-spreadAny(
-  true,
-  () => Promise.resolve(1),
-  () => Promise.resolve(false),
-);
-    `,
-    `
-function spreadArrayAny(..._args: Array<any>): void {}
-
-spreadArrayAny(
-  true,
-  () => Promise.resolve(1),
-  () => Promise.resolve(false),
-);
-    `,
-    `
-function spreadArrayUnknown(..._args: Array<unknown>): void {}
-
-spreadArrayUnknown(() => Promise.resolve(true), 1, 2);
-
-function spreadArrayFuncPromise(
-  ..._args: Array<() => Promise<undefined>>
-): void {}
-
-spreadArrayFuncPromise(
-  () => Promise.resolve(undefined),
-  () => Promise.resolve(undefined),
-);
-    `,
-    // Prettier adds a () but this tests arguments being undefined, not []
-    // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
-    `
-class TakeCallbacks {
-  constructor(...callbacks: Array<() => void>) {}
-}
-
-new TakeCallbacks;
-new TakeCallbacks();
-new TakeCallbacks(
-  () => 1,
-  () => true,
-);
-    `,
-    `
-function restTuple(...args: []): void;
-function restTuple(...args: [string]): void;
-function restTuple(..._args: string[]): void {}
-
-restTuple();
-restTuple('Hello');
-    `,
-    `
-      let value: Record<string, () => void>;
-      value.sync = () => {};
-    `,
-    `
-      type ReturnsRecord = () => Record<string, () => void>;
-
-      const test: ReturnsRecord = () => {
-        return { sync: () => {} };
-      };
-    `,
-    `
-      type ReturnsRecord = () => Record<string, () => void>;
-
-      function sync() {}
-
-      const test: ReturnsRecord = () => {
-        return { sync };
-      };
-    `,
-    `
-      function withTextRecurser<Text extends string>(
-        recurser: (text: Text) => void,
-      ): (text: Text) => void {
-        return (text: Text): void => {
-          if (text.length) {
-            return;
-          }
-
-          return recurser(node);
-        };
-      }
-    `,
-    `
-declare function foo(cb: undefined | (() => void));
-declare const bar: undefined | (() => void);
-foo(bar);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6637
-    {
-      code: `
-        type OnSelectNodeFn = (node: string | null) => void;
-
-        interface ASTViewerBaseProps {
-          readonly onSelectNode?: OnSelectNodeFn;
-        }
-
-        declare function ASTViewer(props: ASTViewerBaseProps): null;
-        declare const onSelectFn: OnSelectNodeFn;
-
-        <ASTViewer onSelectNode={onSelectFn} />;
+const obj: {
+  f?: () => void;
+} = {};
+obj.f = async () => {
+  return 0;
+};
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          line: 5,
+          messageId: 'voidReturnVariable',
         },
-      },
-      options: [{ checksVoidReturn: { attributes: true } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  setThing(): void {
-    return;
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-class MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-interface MyInterfaceExtendsMyClass extends MyClass {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-interface MyInterfaceExtendsMyClass extends MyClass {
-  setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
-  setThing(): void {
-    return;
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
-  abstract setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
-  abstract setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
-  setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-interface MySubInterfaceExtendsMyInterface extends MyInterface {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      ],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-interface MySubInterfaceExtendsMyInterface extends MyInterface {
-  setThing(): Promise<void>;
-}
+type O = { f: () => void };
+const obj: O = {
+  f: async () => 'foo',
+};
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-class MyClassImplementsMyInterface implements MyInterface {
-  setThing(): void {
-    return;
-  }
-}
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+    },
+    {
+      code: `
+type O = { f: () => void };
+const obj: O = {
+  f: async () => 'foo',
+};
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+      options: [{ checksVoidReturn: { properties: true } }],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-class MyClassImplementsMyInterface implements MyInterface {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
+type O = { f: () => void };
+const f = async () => 0;
+const obj: O = {
+  f,
+};
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          line: 5,
+          messageId: 'voidReturnProperty',
+        },
+      ],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): void;
-}
+type O = { f: () => void };
+const obj: O = {
+  async f() {
+    return 0;
+  },
+};
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): Promise<void>;
+type O = { f: () => void; g: () => void; h: () => void };
+function f(): O {
+  const h = async () => 0;
+  return {
+    async f() {
+      return 123;
+    },
+    g: async () => 0,
+    h,
+  };
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnProperty',
+        },
+        {
+          line: 9,
+          messageId: 'voidReturnProperty',
+        },
+        {
+          line: 10,
+          messageId: 'voidReturnProperty',
+        },
+      ],
     },
     {
       code: `
-type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
-
-class MyClass implements MyTypeLiteralsIntersection {
-  thing = 1;
-  setThing(): void {
-    return;
-  }
+function f(): () => void {
+  return async () => 0;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnReturnValue',
+        },
+      ],
     },
     {
       code: `
-type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
-
-class MyClass implements MyTypeLiteralsIntersection {
-  thing = 1;
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
+function f(): () => void {
+  return async () => 0;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnReturnValue',
+        },
+      ],
+      options: [{ checksVoidReturn: { returns: true } }],
     },
     {
       code: `
-type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
-  ? { setThing(): Promise<void> }
-  : { setThing(): void };
-
-interface MyAsyncInterface extends MyGenericType {
-  setThing(): Promise<void>;
-}
+type O = {
+  func: () => void;
+};
+const Component = (obj: O) => null;
+<Component func={async () => 0} />;
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
     },
     {
       code: `
-type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
-  ? { setThing(): Promise<void> }
-  : { setThing(): void };
-
-interface MyAsyncInterface extends MyGenericType<false> {
-  setThing(): Promise<void>;
-}
+type O = {
+  func: () => void;
+};
+const Component = (obj: O) => null;
+<Component func={async () => 0} />;
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+      options: [{ checksVoidReturn: { attributes: true } }],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-interface MyOtherInterface {
-  setThing(): void;
-}
-
-interface MyThirdInterface extends MyInterface, MyOtherInterface {
-  setThing(): void;
-}
+type O = {
+  func: () => void;
+};
+const g = async () => 'foo';
+const Component = (obj: O) => null;
+<Component func={g} />;
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 7,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
+interface ItLike {
+  (name: string, callback: () => number): void;
+  (name: string, callback: () => void): void;
 }
 
-class MyOtherClass {
-  setThing(): void {
-    return;
-  }
-}
+declare const it: ItLike;
 
-interface MyInterface extends MyClass, MyOtherClass {
-  setThing(): void;
-}
+it('', async () => {});
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 9,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
+interface ItLike {
+  (name: string, callback: () => number): void;
 }
-
-interface MyOtherInterface {
-  setThing(): void;
+interface ItLike {
+  (name: string, callback: () => void): void;
 }
 
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
+declare const it: ItLike;
 
-class MySubclass extends MyClass implements MyInterface, MyOtherInterface {
-  setThing(): void {
-    return;
-  }
-}
+it('', async () => {});
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 11,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
+interface ItLike {
+  (name: string, callback: () => void): void;
+}
+interface ItLike {
+  (name: string, callback: () => number): void;
 }
 
-const MyClassExpressionExtendsMyClass = class extends MyClass {
-  setThing(): void {
-    return;
-  }
-};
+declare const it: ItLike;
+
+it('', async () => {});
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 11,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
-const MyClassExpression = class {
-  setThing(): void {
-    return;
-  }
-};
-
-class MyClassExtendsMyClassExpression extends MyClassExpression {
-  setThing(): void {
-    return;
-  }
-}
+console.log({ ...Promise.resolve({ key: 42 }) });
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'spread',
+        },
+      ],
     },
     {
       code: `
-const MyClassExpression = class {
-  setThing(): void {
-    return;
-  }
-};
-type MyClassExpressionType = typeof MyClassExpression;
+const getData = () => Promise.resolve({ key: 42 });
 
-interface MyInterfaceExtendsMyClassExpression extends MyClassExpressionType {
-  setThing(): void;
-}
+console.log({
+  someData: 42,
+  ...getData(),
+});
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          line: 6,
+          messageId: 'spread',
+        },
+      ],
     },
     {
       code: `
-interface MySyncCallSignatures {
-  (): void;
-  (arg: string): void;
-}
-interface MyAsyncInterface extends MySyncCallSignatures {
-  (): Promise<void>;
-  (arg: string): Promise<void>;
-}
+declare const condition: boolean;
+
+console.log({ ...(condition && Promise.resolve({ key: 42 })) });
+console.log({ ...(condition || Promise.resolve({ key: 42 })) });
+console.log({ ...(condition ? {} : Promise.resolve({ key: 42 })) });
+console.log({ ...(condition ? Promise.resolve({ key: 42 }) : {}) });
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        { line: 4, messageId: 'spread' },
+        { line: 5, messageId: 'spread' },
+        { line: 6, messageId: 'spread' },
+        { line: 7, messageId: 'spread' },
+      ],
     },
     {
       code: `
-interface MySyncConstructSignatures {
-  new (): void;
-  new (arg: string): void;
-}
-interface ThisIsADifferentIssue extends MySyncConstructSignatures {
-  new (): Promise<void>;
-  new (arg: string): Promise<void>;
-}
+function restPromises(first: Boolean, ...callbacks: Array<() => void>): void {}
+
+restPromises(
+  true,
+  () => Promise.resolve(true),
+  () => Promise.resolve(null),
+  () => true,
+  () => Promise.resolve('Hello'),
+);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        { line: 6, messageId: 'voidReturnArgument' },
+        { line: 7, messageId: 'voidReturnArgument' },
+        { line: 9, messageId: 'voidReturnArgument' },
+      ],
     },
     {
       code: `
-interface MySyncIndexSignatures {
-  [key: string]: void;
-  [key: number]: void;
-}
-interface ThisIsADifferentIssue extends MySyncIndexSignatures {
-  [key: string]: Promise<void>;
-  [key: number]: Promise<void>;
-}
+type MyUnion = (() => void) | boolean;
+
+function restUnion(first: string, ...callbacks: Array<MyUnion>): void {}
+restUnion('Testing', false, () => Promise.resolve(true));
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 5, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-interface MySyncInterfaceSignatures {
-  (): void;
-  (arg: string): void;
-  new (): void;
-  [key: string]: () => void;
-  [key: number]: () => void;
-}
-interface MyAsyncInterface extends MySyncInterfaceSignatures {
-  (): Promise<void>;
-  (arg: string): Promise<void>;
-  new (): Promise<void>;
-  [key: string]: () => Promise<void>;
-  [key: number]: () => Promise<void>;
-}
+function restTupleOne(first: string, ...callbacks: [() => void]): void {}
+restTupleOne('My string', () => Promise.resolve(1));
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 3, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-interface MyCall {
-  (): void;
-  (arg: string): void;
-}
-
-interface MyIndex {
-  [key: string]: () => void;
-  [key: number]: () => void;
-}
-
-interface MyConstruct {
-  new (): void;
-  new (arg: string): void;
-}
+function restTupleTwo(
+  first: boolean,
+  ...callbacks: [undefined, () => void, undefined]
+): void {}
 
-interface MyMethods {
-  doSyncThing(): void;
-  doOtherSyncThing(): void;
-  syncMethodProperty: () => void;
-}
-interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
-  (): void;
-  (arg: string): void;
-  new (): void;
-  new (arg: string): void;
-  [key: string]: () => void;
-  [key: number]: () => void;
-  doSyncThing(): void;
-  doAsyncThing(): Promise<void>;
-  syncMethodProperty: () => void;
-}
+restTupleTwo(true, undefined, () => Promise.resolve(true), undefined);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
     },
-    "const notAFn1: string = '';",
-    'const notAFn2: number = 1;',
-    'const notAFn3: boolean = true;',
-    'const notAFn4: { prop: 1 } = { prop: 1 };',
-    'const notAFn5: {} = {};',
-  ],
-
-  invalid: [
     {
       code: `
-if (Promise.resolve()) {
-}
+function restTupleFour(
+  first: number,
+  ...callbacks: [() => void, boolean, () => void, () => void]
+): void;
+
+restTupleFour(
+  1,
+  () => Promise.resolve(true),
+  false,
+  () => {},
+  () => Promise.resolve(1),
+);
       `,
       errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
+        { line: 9, messageId: 'voidReturnArgument' },
+        { line: 12, messageId: 'voidReturnArgument' },
       ],
     },
     {
+      // Prettier adds a () but this tests arguments being undefined, not []
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
-if (Promise.resolve()) {
-} else if (Promise.resolve()) {
-} else {
+class TakesVoidCb {
+  constructor(first: string, ...args: Array<() => void>);
 }
+
+new TakesVoidCb;
+new TakesVoidCb();
+new TakesVoidCb(
+  'Testing',
+  () => {},
+  () => Promise.resolve(true),
+);
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
+      errors: [{ line: 11, messageId: 'voidReturnArgument' }],
     },
     {
-      code: 'for (let i; Promise.resolve(); i++) {}',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      code: `
+function restTuple(...args: []): void;
+function restTuple(...args: [boolean, () => void]): void;
+function restTuple(..._args: any[]): void {}
+
+restTuple();
+restTuple(true, () => Promise.resolve(1));
+      `,
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+type ReturnsRecord = () => Record<string, () => void>;
+
+const test: ReturnsRecord = () => {
+  return { asynchronous: async () => {} };
+};
+      `,
+      errors: [{ line: 5, messageId: 'voidReturnProperty' }],
     },
     {
-      code: 'do {} while (Promise.resolve());',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      code: `
+let value: Record<string, () => void>;
+value.asynchronous = async () => {};
+      `,
+      errors: [{ line: 3, messageId: 'voidReturnVariable' }],
     },
     {
-      code: 'while (Promise.resolve()) {}',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      code: `
+type ReturnsRecord = () => Record<string, () => void>;
+
+async function asynchronous() {}
+
+const test: ReturnsRecord = () => {
+  return { asynchronous };
+};
+      `,
+      errors: [{ line: 7, messageId: 'voidReturnProperty' }],
     },
     {
-      code: 'Promise.resolve() ? 123 : 456;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      code: `
+declare function foo(cb: undefined | (() => void));
+declare const bar: undefined | (() => Promise<void>);
+foo(bar);
+      `,
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-if (!Promise.resolve()) {
-}
+declare function foo(cb: string & (() => void));
+declare const bar: string & (() => Promise<void>);
+foo(bar);
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
-      ],
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
-      code: 'Promise.resolve() || false;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      code: `
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs: Array<() => Promise<boolean>> = [
+  () => Promise.resolve(true),
+  () => Promise.resolve(true),
+];
+consume(...cbs);
+      `,
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-[Promise.resolve(), Promise.reject()].forEach(async val => {
-  await val;
-});
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)] as const;
+consume(...cbs);
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'voidReturnArgument',
-        },
-      ],
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-new Promise(async (resolve, reject) => {
-  await Promise.resolve();
-  resolve();
-});
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)];
+consume(...cbs);
+      `,
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
 
-fnWithCallback('val', async (err, res) => {
-  await res;
-});
+abstract class MyAbstractClassExtendsMyClass extends MyClass {
+  abstract setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
 
-fnWithCallback('val', (err, res) => Promise.resolve(res));
+interface MyInterfaceExtendsMyClass extends MyClass {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
 
-fnWithCallback('val', (err, res) => {
-  if (err) {
-    return 'abc';
-  } else {
-    return Promise.resolve(res);
+class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
   }
-});
+}
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const fnWithCallback:
-  | ((arg: string, cb: (err: any, res: string) => void) => void)
-  | null = (arg, cb) => {
-  cb(null, arg);
-};
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
 
-fnWithCallback?.('val', (err, res) => Promise.resolve(res));
+abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
+  abstract setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 8,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const fnWithCallback:
-  | ((arg: string, cb: (err: any, res: string) => void) => void)
-  | null = (arg, cb) => {
-  cb(null, arg);
-};
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
 
-fnWithCallback('val', (err, res) => {
-  if (err) {
-    return 'abc';
-  } else {
-    return Promise.resolve(res);
-  }
-});
+interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 8,
-          messageId: 'voidReturnArgument',
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-function test(bool: boolean, p: Promise<void>) {
-  if (bool || p) {
+interface MyInterface {
+  setThing(): void;
+}
+
+class MyInterfaceSubclass implements MyInterface {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
   }
 }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'conditional',
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-function test(bool: boolean, p: Promise<void>) {
-  if (bool && p) {
-  }
+interface MyInterface {
+  setThing(): void;
+}
+
+abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
+  abstract setThing(): Promise<void>;
 }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'conditional',
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-function test(a: any, p: Promise<void>) {
-  if (a ?? p) {
-  }
+interface MyInterface {
+  setThing(): void;
+}
+
+interface MySubInterface extends MyInterface {
+  setThing(): Promise<void>;
 }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'conditional',
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-function test(p: Promise<void> | undefined) {
-  if (p ?? Promise.reject()) {
+type MyTypeIntersection = { setThing(): void } & { thing: number };
+
+class MyClassImplementsMyTypeIntersection implements MyTypeIntersection {
+  thing = 1;
+  async setThing(): Promise<void> {
+    await Promise.resolve();
   }
 }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'conditional',
+          data: { heritageTypeName: 'MyTypeIntersection' },
+          line: 6,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-let f: () => void;
-f = async () => {
-  return 3;
-};
+type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
+  ? { setThing(): Promise<void> }
+  : { setThing(): void };
+
+interface MyAsyncInterface extends MyGenericType<false> {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'voidReturnVariable',
+          data: { heritageTypeName: '{ setThing(): void; }' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-let f: () => void;
-f = async () => {
-  return 3;
-};
+interface MyInterface {
+  setThing(): void;
+}
+
+interface MyOtherInterface {
+  setThing(): void;
+}
+
+interface MyThirdInterface extends MyInterface, MyOtherInterface {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'voidReturnVariable',
+          data: { heritageTypeName: 'MyInterface' },
+          line: 11,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MyOtherInterface' },
+          line: 11,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
-      options: [{ checksVoidReturn: { variables: true } }],
     },
     {
       code: `
-const f: () => void = async () => {
-  return 0;
-};
-const g = async () => 1,
-  h: () => void = async () => {};
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MyOtherClass {
+  setThing(): void {
+    return;
+  }
+}
+
+interface MyInterface extends MyClass, MyOtherClass {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'voidReturnVariable',
+          data: { heritageTypeName: 'MyClass' },
+          line: 15,
+          messageId: 'voidReturnInheritedMethod',
         },
         {
-          line: 6,
-          messageId: 'voidReturnVariable',
+          data: { heritageTypeName: 'MyOtherClass' },
+          line: 15,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-const obj: {
-  f?: () => void;
-} = {};
-obj.f = async () => {
-  return 0;
-};
+interface MyAsyncInterface {
+  setThing(): Promise<void>;
+}
+
+interface MySyncInterface {
+  setThing(): void;
+}
+
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MySubclass extends MyClass implements MyAsyncInterface, MySyncInterface {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'voidReturnVariable',
+          data: { heritageTypeName: 'MyClass' },
+          line: 17,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MySyncInterface' },
+          line: 17,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-type O = { f: () => void };
-const obj: O = {
-  f: async () => 'foo',
+interface MyInterface {
+  setThing(): void;
+}
+
+const MyClassExpressionExtendsMyClass = class implements MyInterface {
+  setThing(): Promise<void> {
+    await Promise.resolve();
+  }
 };
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-type O = { f: () => void };
-const obj: O = {
-  f: async () => 'foo',
+const MyClassExpression = class {
+  setThing(): void {
+    return;
+  }
 };
+
+class MyClassExtendsMyClassExpression extends MyClassExpression {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'MyClassExpression' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
-      options: [{ checksVoidReturn: { properties: true } }],
     },
     {
       code: `
-type O = { f: () => void };
-const f = async () => 0;
-const obj: O = {
-  f,
+const MyClassExpression = class {
+  setThing(): void {
+    return;
+  }
 };
+type MyClassExpressionType = typeof MyClassExpression;
+
+interface MyInterfaceExtendsMyClassExpression extends MyClassExpressionType {
+  setThing(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'typeof MyClassExpression' },
+          line: 10,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-type O = { f: () => void };
-const obj: O = {
-  async f() {
-    return 0;
-  },
-};
+interface MySyncInterface {
+  (): void;
+  (arg: string): void;
+  new (): void;
+  [key: string]: () => void;
+  [key: number]: () => void;
+  myMethod(): void;
+}
+interface MyAsyncInterface extends MySyncInterface {
+  (): Promise<void>;
+  (arg: string): Promise<void>;
+  new (): Promise<void>;
+  [key: string]: () => Promise<void>;
+  [key: number]: () => Promise<void>;
+  myMethod(): Promise<void>;
+}
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'MySyncInterface' },
+          line: 16,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
     {
       code: `
-type O = { f: () => void; g: () => void; h: () => void };
-function f(): O {
-  const h = async () => 0;
-  return {
-    async f() {
-      return 123;
-    },
-    g: async () => 0,
-    h,
-  };
+interface MyCall {
+  (): void;
+  (arg: string): void;
+}
+
+interface MyIndex {
+  [key: string]: () => void;
+  [key: number]: () => void;
+}
+
+interface MyConstruct {
+  new (): void;
+  new (arg: string): void;
+}
+
+interface MyMethods {
+  doSyncThing(): void;
+  doOtherSyncThing(): void;
+  syncMethodProperty: () => void;
+}
+interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
+  (): void;
+  (arg: string): Promise<void>;
+  new (): void;
+  new (arg: string): void;
+  [key: string]: () => Promise<void>;
+  [key: number]: () => void;
+  doSyncThing(): Promise<void>;
+  doAsyncThing(): Promise<void>;
+  syncMethodProperty: () => Promise<void>;
 }
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'voidReturnProperty',
-        },
-        {
-          line: 9,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'MyMethods' },
+          line: 29,
+          messageId: 'voidReturnInheritedMethod',
         },
         {
-          line: 10,
-          messageId: 'voidReturnProperty',
+          data: { heritageTypeName: 'MyMethods' },
+          line: 31,
+          messageId: 'voidReturnInheritedMethod',
         },
       ],
     },
+  ],
+
+  valid: [
+    `
+if (true) {
+}
+    `,
     {
       code: `
-function f(): () => void {
-  return async () => 0;
+if (Promise.resolve()) {
 }
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnReturnValue',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    `
+if (true) {
+} else if (false) {
+} else {
+}
+    `,
     {
       code: `
-function f(): () => void {
-  return async () => 0;
+if (Promise.resolve()) {
+} else if (Promise.resolve()) {
+} else {
 }
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnReturnValue',
-        },
-      ],
-      options: [{ checksVoidReturn: { returns: true } }],
+      options: [{ checksConditionals: false }],
+    },
+    'for (;;) {}',
+    'for (let i; i < 10; i++) {}',
+    {
+      code: 'for (let i; Promise.resolve(); i++) {}',
+      options: [{ checksConditionals: false }],
+    },
+    'do {} while (true);',
+    {
+      code: 'do {} while (Promise.resolve());',
+      options: [{ checksConditionals: false }],
+    },
+    'while (true) {}',
+    {
+      code: 'while (Promise.resolve()) {}',
+      options: [{ checksConditionals: false }],
+    },
+    'true ? 123 : 456;',
+    {
+      code: 'Promise.resolve() ? 123 : 456;',
+      options: [{ checksConditionals: false }],
     },
+    `
+if (!true) {
+}
+    `,
     {
       code: `
-type O = {
-  func: () => void;
-};
-const Component = (obj: O) => null;
-<Component func={async () => 0} />;
+if (!Promise.resolve()) {
+}
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
+      options: [{ checksConditionals: false }],
+    },
+    '(await Promise.resolve()) || false;',
+    {
+      code: 'Promise.resolve() || false;',
+      options: [{ checksConditionals: false }],
+    },
+    '(true && (await Promise.resolve())) || false;',
+    {
+      code: '(true && Promise.resolve()) || false;',
+      options: [{ checksConditionals: false }],
+    },
+    'false || (true && Promise.resolve());',
+    '(true && Promise.resolve()) || false;',
+    `
+async function test() {
+  if (await Promise.resolve()) {
+  }
+}
+    `,
+    `
+async function test() {
+  const mixed: Promise | undefined = Promise.resolve();
+  if (mixed) {
+    await mixed;
+  }
+}
+    `,
+    `
+if (~Promise.resolve()) {
+}
+    `,
+    `
+interface NotQuiteThenable {
+  then(param: string): void;
+  then(): void;
+}
+const value: NotQuiteThenable = { then() {} };
+if (value) {
+}
+    `,
+    '[1, 2, 3].forEach(val => {});',
+    {
+      code: '[1, 2, 3].forEach(async val => {});',
+      options: [{ checksVoidReturn: false }],
     },
+    'new Promise((resolve, reject) => resolve());',
+    {
+      code: 'new Promise(async (resolve, reject) => resolve());',
+      options: [{ checksVoidReturn: false }],
+    },
+    `
+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: { call: () => Promise<void> } | null;
+if (returnsPromise?.call()) {
+}
+    `,
+    'Promise.resolve() ?? false;',
+    `
+function test(a: Promise<void> | undefinded) {
+  const foo = a ?? Promise.reject();
+}
+    `,
+    `
+function test(p: Promise<boolean> | undefined, bool: boolean) {
+  if (p ?? bool) {
+  }
+}
+    `,
+    `
+async function test(p: Promise<boolean | undefined>, bool: boolean) {
+  if ((await p) ?? bool) {
+  }
+}
+    `,
+    `
+async function test(p: Promise<boolean> | undefined) {
+  if (await (p ?? Promise.reject())) {
+  }
+}
+    `,
+    `
+let f;
+f = async () => 10;
+    `,
+    `
+let f: () => Promise<void>;
+f = async () => 10;
+const g = async () => 0;
+const h: () => Promise<void> = async () => 10;
+    `,
+    `
+const obj = {
+  f: async () => 10,
+};
+    `,
+    `
+const f = async () => 123;
+const obj = {
+  f,
+};
+    `,
+    `
+const obj = {
+  async f() {
+    return 0;
+  },
+};
+    `,
+    `
+type O = { f: () => Promise<void>; g: () => Promise<void> };
+const g = async () => 0;
+const obj: O = {
+  f: async () => 10,
+  g,
+};
+    `,
+    `
+type O = { f: () => Promise<void> };
+const name = 'f';
+const obj: O = {
+  async [name]() {
+    return 10;
+  },
+};
+    `,
+    `
+const obj: number = {
+  g() {
+    return 10;
+  },
+};
+    `,
+    `
+const obj = {
+  f: async () => 'foo',
+  async g() {
+    return 0;
+  },
+};
+    `,
+    `
+function f() {
+  return async () => 0;
+}
+function g() {
+  return;
+}
+    `,
     {
       code: `
 type O = {
-  func: () => void;
+  bool: boolean;
+  func: () => Promise<void>;
 };
 const Component = (obj: O) => null;
-<Component func={async () => 0} />;
+<Component bool func={async () => 10} />;
       `,
       languageOptions: {
         parserOptions: {
@@ -1503,22 +1474,11 @@ const Component = (obj: O) => null;
           },
         },
       },
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
-      options: [{ checksVoidReturn: { attributes: true } }],
     },
     {
       code: `
-type O = {
-  func: () => void;
-};
-const g = async () => 'foo';
-const Component = (obj: O) => null;
-<Component func={g} />;
+const Component: any = () => null;
+<Component func={async () => 10} />;
       `,
       languageOptions: {
         parserOptions: {
@@ -1527,17 +1487,11 @@ const Component = (obj: O) => null;
           },
         },
       },
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
     },
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => number): void;
+  (name: string, callback: () => Promise<void>): void;
   (name: string, callback: () => void): void;
 }
 
@@ -1545,63 +1499,92 @@ declare const it: ItLike;
 
 it('', async () => {});
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnArgument',
-        },
-      ],
     },
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => number): void;
+  (name: string, callback: () => void): void;
+  (name: string, callback: () => Promise<void>): void;
 }
+
+declare const it: ItLike;
+
+it('', async () => {});
+      `,
+    },
+    {
+      code: `
 interface ItLike {
   (name: string, callback: () => void): void;
 }
+interface ItLike {
+  (name: string, callback: () => Promise<void>): void;
+}
 
 declare const it: ItLike;
 
 it('', async () => {});
       `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'voidReturnArgument',
-        },
-      ],
     },
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => void): void;
+  (name: string, callback: () => Promise<void>): void;
 }
 interface ItLike {
-  (name: string, callback: () => number): void;
+  (name: string, callback: () => void): void;
 }
 
 declare const it: ItLike;
 
 it('', async () => {});
       `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'voidReturnArgument',
+    },
+    {
+      code: `
+interface Props {
+  onEvent: (() => void) | (() => Promise<void>);
+}
+
+declare function Component(props: Props): any;
+
+const _ = <Component onEvent={async () => {}} />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
+      },
     },
+    `
+console.log({ ...(await Promise.resolve({ key: 42 })) });
+    `,
+    `
+const getData = () => Promise.resolve({ key: 42 });
+
+console.log({
+  someData: 42,
+  ...(await getData()),
+});
+    `,
+    `
+declare const condition: boolean;
+
+console.log({ ...(condition && (await Promise.resolve({ key: 42 }))) });
+console.log({ ...(condition || (await Promise.resolve({ key: 42 }))) });
+console.log({ ...(condition ? {} : await Promise.resolve({ key: 42 })) });
+console.log({ ...(condition ? await Promise.resolve({ key: 42 }) : {}) });
+    `,
+    `
+console.log([...(await Promise.resolve(42))]);
+    `,
     {
       code: `
 console.log({ ...Promise.resolve({ key: 42 }) });
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'spread',
-        },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
@@ -1612,12 +1595,7 @@ console.log({
   ...getData(),
 });
       `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'spread',
-        },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
@@ -1628,178 +1606,191 @@ console.log({ ...(condition || Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? {} : Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? Promise.resolve({ key: 42 }) : {}) });
       `,
-      errors: [
-        { line: 4, messageId: 'spread' },
-        { line: 5, messageId: 'spread' },
-        { line: 6, messageId: 'spread' },
-        { line: 7, messageId: 'spread' },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
-function restPromises(first: Boolean, ...callbacks: Array<() => void>): void {}
+// This is invalid Typescript, but it shouldn't trigger this linter specifically
+console.log([...Promise.resolve(42)]);
+      `,
+      options: [{ checksSpreads: false }],
+    },
+    `
+function spreadAny(..._args: any): void {}
 
-restPromises(
+spreadAny(
   true,
-  () => Promise.resolve(true),
-  () => Promise.resolve(null),
-  () => true,
-  () => Promise.resolve('Hello'),
+  () => Promise.resolve(1),
+  () => Promise.resolve(false),
 );
-      `,
-      errors: [
-        { line: 6, messageId: 'voidReturnArgument' },
-        { line: 7, messageId: 'voidReturnArgument' },
-        { line: 9, messageId: 'voidReturnArgument' },
-      ],
-    },
-    {
-      code: `
-type MyUnion = (() => void) | boolean;
+    `,
+    `
+function spreadArrayAny(..._args: Array<any>): void {}
 
-function restUnion(first: string, ...callbacks: Array<MyUnion>): void {}
-restUnion('Testing', false, () => Promise.resolve(true));
-      `,
-      errors: [{ line: 5, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleOne(first: string, ...callbacks: [() => void]): void {}
-restTupleOne('My string', () => Promise.resolve(1));
-      `,
-      errors: [{ line: 3, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleTwo(
-  first: boolean,
-  ...callbacks: [undefined, () => void, undefined]
-): void {}
+spreadArrayAny(
+  true,
+  () => Promise.resolve(1),
+  () => Promise.resolve(false),
+);
+    `,
+    `
+function spreadArrayUnknown(..._args: Array<unknown>): void {}
 
-restTupleTwo(true, undefined, () => Promise.resolve(true), undefined);
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleFour(
-  first: number,
-  ...callbacks: [() => void, boolean, () => void, () => void]
-): void;
+spreadArrayUnknown(() => Promise.resolve(true), 1, 2);
 
-restTupleFour(
-  1,
-  () => Promise.resolve(true),
-  false,
-  () => {},
-  () => Promise.resolve(1),
+function spreadArrayFuncPromise(
+  ..._args: Array<() => Promise<undefined>>
+): void {}
+
+spreadArrayFuncPromise(
+  () => Promise.resolve(undefined),
+  () => Promise.resolve(undefined),
 );
-      `,
-      errors: [
-        { line: 9, messageId: 'voidReturnArgument' },
-        { line: 12, messageId: 'voidReturnArgument' },
-      ],
-    },
-    {
-      // Prettier adds a () but this tests arguments being undefined, not []
-      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
-      code: `
-class TakesVoidCb {
-  constructor(first: string, ...args: Array<() => void>);
+    `,
+    // Prettier adds a () but this tests arguments being undefined, not []
+    // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
+    `
+class TakeCallbacks {
+  constructor(...callbacks: Array<() => void>) {}
 }
 
-new TakesVoidCb;
-new TakesVoidCb();
-new TakesVoidCb(
-  'Testing',
-  () => {},
-  () => Promise.resolve(true),
+new TakeCallbacks;
+new TakeCallbacks();
+new TakeCallbacks(
+  () => 1,
+  () => true,
 );
-      `,
-      errors: [{ line: 11, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
+    `,
+    `
 function restTuple(...args: []): void;
-function restTuple(...args: [boolean, () => void]): void;
-function restTuple(..._args: any[]): void {}
+function restTuple(...args: [string]): void;
+function restTuple(..._args: string[]): void {}
+
+restTuple();
+restTuple('Hello');
+    `,
+    `
+      let value: Record<string, () => void>;
+      value.sync = () => {};
+    `,
+    `
+      type ReturnsRecord = () => Record<string, () => void>;
+
+      const test: ReturnsRecord = () => {
+        return { sync: () => {} };
+      };
+    `,
+    `
+      type ReturnsRecord = () => Record<string, () => void>;
+
+      function sync() {}
+
+      const test: ReturnsRecord = () => {
+        return { sync };
+      };
+    `,
+    `
+      function withTextRecurser<Text extends string>(
+        recurser: (text: Text) => void,
+      ): (text: Text) => void {
+        return (text: Text): void => {
+          if (text.length) {
+            return;
+          }
 
-restTuple();
-restTuple(true, () => Promise.resolve(1));
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
-    },
+          return recurser(node);
+        };
+      }
+    `,
+    `
+declare function foo(cb: undefined | (() => void));
+declare const bar: undefined | (() => void);
+foo(bar);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6637
     {
       code: `
-type ReturnsRecord = () => Record<string, () => void>;
+        type OnSelectNodeFn = (node: string | null) => void;
 
-const test: ReturnsRecord = () => {
-  return { asynchronous: async () => {} };
-};
-      `,
-      errors: [{ line: 5, messageId: 'voidReturnProperty' }],
-    },
-    {
-      code: `
-let value: Record<string, () => void>;
-value.asynchronous = async () => {};
-      `,
-      errors: [{ line: 3, messageId: 'voidReturnVariable' }],
-    },
-    {
-      code: `
-type ReturnsRecord = () => Record<string, () => void>;
+        interface ASTViewerBaseProps {
+          readonly onSelectNode?: OnSelectNodeFn;
+        }
 
-async function asynchronous() {}
+        declare function ASTViewer(props: ASTViewerBaseProps): null;
+        declare const onSelectFn: OnSelectNodeFn;
 
-const test: ReturnsRecord = () => {
-  return { asynchronous };
-};
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnProperty' }],
-    },
-    {
-      code: `
-declare function foo(cb: undefined | (() => void));
-declare const bar: undefined | (() => Promise<void>);
-foo(bar);
+        <ASTViewer onSelectNode={onSelectFn} />;
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+      options: [{ checksVoidReturn: { attributes: true } }],
     },
     {
       code: `
-declare function foo(cb: string & (() => void));
-declare const bar: string & (() => Promise<void>);
-foo(bar);
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  setThing(): void {
+    return;
+  }
+}
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs: Array<() => Promise<boolean>> = [
-  () => Promise.resolve(true),
-  () => Promise.resolve(true),
-];
-consume(...cbs);
+class MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)] as const;
-consume(...cbs);
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)];
-consume(...cbs);
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+abstract class MyAbstractClassExtendsMyClass extends MyClass {
+  abstract setThing(): void;
+}
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1809,19 +1800,11 @@ class MyClass {
   }
 }
 
-class MySubclassExtendsMyClass extends MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
+abstract class MyAbstractClassExtendsMyClass extends MyClass {
+  abstract setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -1831,17 +1814,11 @@ class MyClass {
   }
 }
 
-abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): Promise<void>;
+interface MyInterfaceExtendsMyClass extends MyClass {
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1855,13 +1832,21 @@ interface MyInterfaceExtendsMyClass extends MyClass {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1875,13 +1860,19 @@ class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
   }
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyAbstractClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
+  abstract setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1893,13 +1884,19 @@ abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass
   abstract setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyAbstractClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
+  setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1911,13 +1908,45 @@ interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyAbstractClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+interface MySubInterfaceExtendsMyInterface extends MyInterface {
+  setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+interface MySubInterfaceExtendsMyInterface extends MyInterface {
+  setThing(): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+class MyClassImplementsMyInterface implements MyInterface {
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1925,19 +1954,13 @@ interface MyInterface {
   setThing(): void;
 }
 
-class MyInterfaceSubclass implements MyInterface {
+class MyClassImplementsMyInterface implements MyInterface {
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -1946,16 +1969,10 @@ interface MyInterface {
 }
 
 abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): Promise<void>;
+  abstract setThing(): void;
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1963,36 +1980,49 @@ interface MyInterface {
   setThing(): void;
 }
 
-interface MySubInterface extends MyInterface {
-  setThing(): Promise<void>;
+abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
+  abstract setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
-type MyTypeIntersection = { setThing(): void } & { thing: number };
+type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
 
-class MyClassImplementsMyTypeIntersection implements MyTypeIntersection {
+class MyClass implements MyTypeLiteralsIntersection {
+  thing = 1;
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
+
+class MyClass implements MyTypeLiteralsIntersection {
   thing = 1;
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyTypeIntersection' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
+  ? { setThing(): Promise<void> }
+  : { setThing(): void };
+
+interface MyAsyncInterface extends MyGenericType {
+  setThing(): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -2004,13 +2034,7 @@ interface MyAsyncInterface extends MyGenericType<false> {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: '{ setThing(): void; }' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -2023,21 +2047,10 @@ interface MyOtherInterface {
 }
 
 interface MyThirdInterface extends MyInterface, MyOtherInterface {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyInterface' },
-        },
-        {
-          line: 11,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyOtherInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -2054,29 +2067,18 @@ class MyOtherClass {
 }
 
 interface MyInterface extends MyClass, MyOtherClass {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          line: 15,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClass' },
-        },
-        {
-          line: 15,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyOtherClass' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MyAsyncInterface {
-  setThing(): Promise<void>;
+interface MyInterface {
+  setThing(): void;
 }
 
-interface MySyncInterface {
+interface MyOtherInterface {
   setThing(): void;
 }
 
@@ -2086,44 +2088,29 @@ class MyClass {
   }
 }
 
-class MySubclass extends MyClass implements MyAsyncInterface, MySyncInterface {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
+class MySubclass extends MyClass implements MyInterface, MyOtherInterface {
+  setThing(): void {
+    return;
   }
 }
       `,
-      errors: [
-        {
-          line: 17,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClass' },
-        },
-        {
-          line: 17,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MySyncInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
+class MyClass {
+  setThing(): void {
+    return;
+  }
 }
 
-const MyClassExpressionExtendsMyClass = class implements MyInterface {
-  setThing(): Promise<void> {
-    await Promise.resolve();
+const MyClassExpressionExtendsMyClass = class extends MyClass {
+  setThing(): void {
+    return;
   }
 };
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -2134,18 +2121,12 @@ const MyClassExpression = class {
 };
 
 class MyClassExtendsMyClassExpression extends MyClassExpression {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
+  setThing(): void {
+    return;
   }
 }
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyClassExpression' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -2157,43 +2138,68 @@ const MyClassExpression = class {
 type MyClassExpressionType = typeof MyClassExpression;
 
 interface MyInterfaceExtendsMyClassExpression extends MyClassExpressionType {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'typeof MyClassExpression' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MySyncInterface {
+interface MySyncCallSignatures {
+  (): void;
+  (arg: string): void;
+}
+interface MyAsyncInterface extends MySyncCallSignatures {
+  (): Promise<void>;
+  (arg: string): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncConstructSignatures {
+  new (): void;
+  new (arg: string): void;
+}
+interface ThisIsADifferentIssue extends MySyncConstructSignatures {
+  new (): Promise<void>;
+  new (arg: string): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncIndexSignatures {
+  [key: string]: void;
+  [key: number]: void;
+}
+interface ThisIsADifferentIssue extends MySyncIndexSignatures {
+  [key: string]: Promise<void>;
+  [key: number]: Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncInterfaceSignatures {
   (): void;
   (arg: string): void;
   new (): void;
   [key: string]: () => void;
   [key: number]: () => void;
-  myMethod(): void;
 }
-interface MyAsyncInterface extends MySyncInterface {
+interface MyAsyncInterface extends MySyncInterfaceSignatures {
   (): Promise<void>;
   (arg: string): Promise<void>;
   new (): Promise<void>;
   [key: string]: () => Promise<void>;
   [key: number]: () => Promise<void>;
-  myMethod(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          line: 16,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MySyncInterface' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -2219,28 +2225,22 @@ interface MyMethods {
 }
 interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
   (): void;
-  (arg: string): Promise<void>;
+  (arg: string): void;
   new (): void;
   new (arg: string): void;
-  [key: string]: () => Promise<void>;
+  [key: string]: () => void;
   [key: number]: () => void;
-  doSyncThing(): Promise<void>;
+  doSyncThing(): void;
   doAsyncThing(): Promise<void>;
-  syncMethodProperty: () => Promise<void>;
+  syncMethodProperty: () => void;
 }
       `,
-      errors: [
-        {
-          line: 29,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyMethods' },
-        },
-        {
-          line: 31,
-          messageId: 'voidReturnInheritedMethod',
-          data: { heritageTypeName: 'MyMethods' },
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
+    "const notAFn1: string = '';",
+    'const notAFn2: number = 1;',
+    'const notAFn3: boolean = true;',
+    'const notAFn4: { prop: 1 } = { prop: 1 };',
+    'const notAFn5: {} = {};',
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts b/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
index 9a64318705d4..047563ed471e 100644
--- a/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
@@ -7,253 +7,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-mixed-enums', rule, {
-  valid: [
-    `
-      enum Fruit {}
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = false,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = 0,
-        Banana,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana = 1,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = 0,
-        Banana = 1,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana = false,
-      }
-    `,
-    `
-      const getValue = () => 0;
-      enum Fruit {
-        Apple,
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => 0;
-      enum Fruit {
-        Apple = getValue(),
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = '',
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = getValue(),
-        Banana = '',
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = getValue(),
-        Banana = getValue(),
-      }
-    `,
-    `
-      enum First {
-        A = 1,
-      }
-
-      enum Second {
-        A = First.A,
-        B = 2,
-      }
-    `,
-    `
-      enum First {
-        A = '',
-      }
-
-      enum Second {
-        A = First.A,
-        B = 'b',
-      }
-    `,
-    `
-      enum Foo {
-        A,
-      }
-      enum Foo {
-        B,
-      }
-    `,
-    `
-      enum Foo {
-        A = 0,
-      }
-      enum Foo {
-        B,
-      }
-    `,
-    `
-      enum Foo {
-        A,
-      }
-      enum Foo {
-        B = 1,
-      }
-    `,
-    `
-      enum Foo {
-        A = 0,
-      }
-      enum Foo {
-        B = 1,
-      }
-    `,
-    `
-      enum Foo {
-        A = 'a',
-      }
-      enum Foo {
-        B = 'b',
-      }
-    `,
-    `
-      declare const Foo: any;
-      enum Foo {
-        A,
-      }
-    `,
-    `
-enum Foo {
-  A = 1,
-}
-enum Foo {
-  B = 2,
-}
-    `,
-    `
-enum Foo {
-  A = \`A\`,
-}
-enum Foo {
-  B = \`B\`,
-}
-    `,
-    `
-enum Foo {
-  A = false, // (TS error)
-}
-enum Foo {
-  B = \`B\`,
-}
-    `,
-    `
-enum Foo {
-  A = 'A',
-}
-enum Foo {
-  B = false, // (TS error)
-}
-    `,
-    `
-import { Enum } from './mixed-enums-decl';
-
-declare module './mixed-enums-decl' {
-  enum Enum {
-    StringLike = 'StringLike',
-  }
-}
-    `,
-    `
-import { Enum } from "module-that-does't-exist";
-
-declare module "module-that-doesn't-exist" {
-  enum Enum {
-    StringLike = 'StringLike',
-  }
-}
-    `,
-    `
-namespace Test {
-  export enum Bar {
-    A = 1,
-  }
-}
-namespace Test {
-  export enum Bar {
-    B = 2,
-  }
-}
-    `,
-    `
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      A = 1,
-    }
-  }
-}
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      B = 'B',
-    }
-  }
-}
-    `,
-    `
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      A = 1,
-    }
-  }
-}
-namespace Different {
-  namespace Test {
-    export enum Bar {
-      B = 'B',
-    }
-  }
-}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -264,8 +24,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 28,
           column: 20,
+          endColumn: 28,
           line: 4,
           messageId: 'mixed',
         },
@@ -281,8 +41,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 28,
           column: 20,
+          endColumn: 28,
           line: 4,
           messageId: 'mixed',
         },
@@ -298,8 +58,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 28,
           column: 20,
+          endColumn: 28,
           line: 5,
           messageId: 'mixed',
         },
@@ -314,8 +74,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 28,
           column: 20,
+          endColumn: 28,
           line: 4,
           messageId: 'mixed',
         },
@@ -331,8 +91,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 28,
           column: 20,
+          endColumn: 28,
           line: 5,
           messageId: 'mixed',
         },
@@ -348,8 +108,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 30,
           column: 20,
+          endColumn: 30,
           line: 5,
           messageId: 'mixed',
         },
@@ -365,8 +125,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 21,
           column: 20,
+          endColumn: 21,
           line: 5,
           messageId: 'mixed',
         },
@@ -385,8 +145,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 8,
           messageId: 'mixed',
         },
@@ -405,8 +165,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 16,
           column: 15,
+          endColumn: 16,
           line: 8,
           messageId: 'mixed',
         },
@@ -423,8 +183,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 6,
           messageId: 'mixed',
         },
@@ -441,8 +201,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 6,
           messageId: 'mixed',
         },
@@ -459,8 +219,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 12,
           column: 11,
+          endColumn: 12,
           line: 6,
           messageId: 'mixed',
         },
@@ -477,8 +237,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 16,
           column: 15,
+          endColumn: 16,
           line: 6,
           messageId: 'mixed',
         },
@@ -498,14 +258,14 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 6,
           messageId: 'mixed',
         },
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 9,
           messageId: 'mixed',
         },
@@ -525,8 +285,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 6,
           messageId: 'mixed',
         },
@@ -546,8 +306,8 @@ namespace Different {
       `,
       errors: [
         {
-          endColumn: 18,
           column: 15,
+          endColumn: 18,
           line: 9,
           messageId: 'mixed',
         },
@@ -565,8 +325,8 @@ declare module './mixed-enums-decl' {
       `,
       errors: [
         {
-          endColumn: 16,
           column: 15,
+          endColumn: 16,
           line: 6,
           messageId: 'mixed',
         },
@@ -583,8 +343,8 @@ enum Foo {
       `,
       errors: [
         {
-          endColumn: 10,
           column: 7,
+          endColumn: 10,
           line: 6,
           messageId: 'mixed',
         },
@@ -605,8 +365,8 @@ namespace Test {
       `,
       errors: [
         {
-          endColumn: 12,
           column: 9,
+          endColumn: 12,
           line: 9,
           messageId: 'mixed',
         },
@@ -627,8 +387,8 @@ namespace Test {
       `,
       errors: [
         {
-          endColumn: 12,
           column: 9,
+          endColumn: 12,
           line: 9,
           messageId: 'mixed',
         },
@@ -653,12 +413,252 @@ namespace Outer {
       `,
       errors: [
         {
-          endColumn: 14,
           column: 11,
+          endColumn: 14,
           line: 12,
           messageId: 'mixed',
         },
       ],
     },
   ],
+  valid: [
+    `
+      enum Fruit {}
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = false,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = 0,
+        Banana,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana = 1,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = 0,
+        Banana = 1,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana = false,
+      }
+    `,
+    `
+      const getValue = () => 0;
+      enum Fruit {
+        Apple,
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => 0;
+      enum Fruit {
+        Apple = getValue(),
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = '',
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = getValue(),
+        Banana = '',
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = getValue(),
+        Banana = getValue(),
+      }
+    `,
+    `
+      enum First {
+        A = 1,
+      }
+
+      enum Second {
+        A = First.A,
+        B = 2,
+      }
+    `,
+    `
+      enum First {
+        A = '',
+      }
+
+      enum Second {
+        A = First.A,
+        B = 'b',
+      }
+    `,
+    `
+      enum Foo {
+        A,
+      }
+      enum Foo {
+        B,
+      }
+    `,
+    `
+      enum Foo {
+        A = 0,
+      }
+      enum Foo {
+        B,
+      }
+    `,
+    `
+      enum Foo {
+        A,
+      }
+      enum Foo {
+        B = 1,
+      }
+    `,
+    `
+      enum Foo {
+        A = 0,
+      }
+      enum Foo {
+        B = 1,
+      }
+    `,
+    `
+      enum Foo {
+        A = 'a',
+      }
+      enum Foo {
+        B = 'b',
+      }
+    `,
+    `
+      declare const Foo: any;
+      enum Foo {
+        A,
+      }
+    `,
+    `
+enum Foo {
+  A = 1,
+}
+enum Foo {
+  B = 2,
+}
+    `,
+    `
+enum Foo {
+  A = \`A\`,
+}
+enum Foo {
+  B = \`B\`,
+}
+    `,
+    `
+enum Foo {
+  A = false, // (TS error)
+}
+enum Foo {
+  B = \`B\`,
+}
+    `,
+    `
+enum Foo {
+  A = 'A',
+}
+enum Foo {
+  B = false, // (TS error)
+}
+    `,
+    `
+import { Enum } from './mixed-enums-decl';
+
+declare module './mixed-enums-decl' {
+  enum Enum {
+    StringLike = 'StringLike',
+  }
+}
+    `,
+    `
+import { Enum } from "module-that-does't-exist";
+
+declare module "module-that-doesn't-exist" {
+  enum Enum {
+    StringLike = 'StringLike',
+  }
+}
+    `,
+    `
+namespace Test {
+  export enum Bar {
+    A = 1,
+  }
+}
+namespace Test {
+  export enum Bar {
+    B = 2,
+  }
+}
+    `,
+    `
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      A = 1,
+    }
+  }
+}
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      B = 'B',
+    }
+  }
+}
+    `,
+    `
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      A = 1,
+    }
+  }
+}
+namespace Different {
+  namespace Test {
+    export enum Bar {
+      B = 'B',
+    }
+  }
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-namespace.test.ts b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
index a4e7713413cf..00b032640b7e 100644
--- a/packages/eslint-plugin/tests/rules/no-namespace.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
@@ -5,82 +5,14 @@ import rule from '../../src/rules/no-namespace';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-namespace', rule, {
-  valid: [
-    'declare global {}',
-    "declare module 'foo' {}",
-    {
-      code: 'declare module foo {}',
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: 'declare namespace foo {}',
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare global {
-  namespace foo {}
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare module foo {
-  namespace bar {}
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare global {
-  namespace foo {
-    namespace bar {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare namespace foo {
-  namespace bar {
-    namespace baz {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-export declare namespace foo {
-  export namespace bar {
-    namespace baz {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      filename: 'test.d.ts',
-      code: 'namespace foo {}',
-      options: [{ allowDefinitionFiles: true }],
-    },
-    {
-      filename: 'test.d.ts',
-      code: 'module foo {}',
-      options: [{ allowDefinitionFiles: true }],
-    },
-  ],
   invalid: [
     {
       code: 'module foo {}',
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
     },
@@ -88,63 +20,63 @@ export declare namespace foo {
       code: 'namespace foo {}',
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
     },
     {
       code: 'module foo {}',
-      options: [{ allowDeclarations: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: false }],
     },
     {
       code: 'namespace foo {}',
-      options: [{ allowDeclarations: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: false }],
     },
     {
       code: 'module foo {}',
-      options: [{ allowDeclarations: true }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: true }],
     },
     {
       code: 'namespace foo {}',
-      options: [{ allowDeclarations: true }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: true }],
     },
     {
       code: 'declare module foo {}',
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
     },
@@ -152,92 +84,92 @@ export declare namespace foo {
       code: 'declare namespace foo {}',
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
     },
     {
       code: 'declare module foo {}',
-      options: [{ allowDeclarations: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: false }],
     },
     {
       code: 'declare namespace foo {}',
-      options: [{ allowDeclarations: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: false }],
     },
     {
-      filename: 'test.d.ts',
       code: 'namespace foo {}',
-      options: [{ allowDefinitionFiles: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: false }],
     },
     {
-      filename: 'test.d.ts',
       code: 'module foo {}',
-      options: [{ allowDefinitionFiles: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: false }],
     },
     {
-      filename: 'test.d.ts',
       code: 'declare module foo {}',
-      options: [{ allowDefinitionFiles: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: false }],
     },
     {
-      filename: 'test.d.ts',
       code: 'declare namespace foo {}',
-      options: [{ allowDefinitionFiles: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: false }],
     },
     {
       code: 'namespace Foo.Bar {}',
-      options: [{ allowDeclarations: false }],
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
+      options: [{ allowDeclarations: false }],
     },
     {
       code: `
@@ -249,14 +181,14 @@ namespace Foo.Bar {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
     },
@@ -270,14 +202,14 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -292,14 +224,14 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -314,9 +246,9 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -331,9 +263,9 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -348,9 +280,9 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -365,9 +297,9 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -382,9 +314,9 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -399,14 +331,14 @@ namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -421,14 +353,14 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -443,14 +375,14 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -465,9 +397,9 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -482,9 +414,9 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -499,9 +431,9 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -516,9 +448,9 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -533,9 +465,9 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
@@ -550,17 +482,85 @@ export namespace A {
       `,
       errors: [
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 2,
           column: 8,
+          line: 2,
+          messageId: 'moduleSyntaxIsPreferred',
         },
         {
-          messageId: 'moduleSyntaxIsPreferred',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'moduleSyntaxIsPreferred',
         },
       ],
       options: [{ allowDeclarations: true }],
     },
   ],
+  valid: [
+    'declare global {}',
+    "declare module 'foo' {}",
+    {
+      code: 'declare module foo {}',
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: 'declare namespace foo {}',
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare global {
+  namespace foo {}
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare module foo {
+  namespace bar {}
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare global {
+  namespace foo {
+    namespace bar {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare namespace foo {
+  namespace bar {
+    namespace baz {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+export declare namespace foo {
+  export namespace bar {
+    namespace baz {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: 'namespace foo {}',
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: true }],
+    },
+    {
+      code: 'module foo {}',
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: true }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts b/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
index 861cae23de9f..248888f4db8c 100644
--- a/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
@@ -5,61 +5,6 @@ import rule from '../../src/rules/no-non-null-asserted-nullish-coalescing';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-nullish-coalescing', rule, {
-  valid: [
-    'foo ?? bar;',
-    'foo ?? bar!;',
-    'foo.bazz ?? bar;',
-    'foo.bazz ?? bar!;',
-    'foo!.bazz ?? bar;',
-    'foo!.bazz ?? bar!;',
-    'foo() ?? bar;',
-    'foo() ?? bar!;',
-    '(foo ?? bar)!;',
-    `
-      let x: string;
-      x! ?? '';
-    `,
-    `
-      let x: string;
-      x ?? '';
-    `,
-    `
-      let x!: string;
-      x ?? '';
-    `,
-    `
-      let x: string;
-      foo(x);
-      x! ?? '';
-    `,
-    `
-      let x: string;
-      x! ?? '';
-      x = foo();
-    `,
-    `
-      let x: string;
-      foo(x);
-      x! ?? '';
-      x = foo();
-    `,
-    `
-      let x = foo();
-      x ?? '';
-    `,
-    `
-      function foo() {
-        let x: string;
-        return x ?? '';
-      }
-    `,
-    `
-      let x: string;
-      function foo() {
-        return x ?? '';
-      }
-    `,
-  ],
   invalid: [
     {
       code: 'foo! ?? bar;',
@@ -328,4 +273,59 @@ x   ?? '';
       ],
     },
   ],
+  valid: [
+    'foo ?? bar;',
+    'foo ?? bar!;',
+    'foo.bazz ?? bar;',
+    'foo.bazz ?? bar!;',
+    'foo!.bazz ?? bar;',
+    'foo!.bazz ?? bar!;',
+    'foo() ?? bar;',
+    'foo() ?? bar!;',
+    '(foo ?? bar)!;',
+    `
+      let x: string;
+      x! ?? '';
+    `,
+    `
+      let x: string;
+      x ?? '';
+    `,
+    `
+      let x!: string;
+      x ?? '';
+    `,
+    `
+      let x: string;
+      foo(x);
+      x! ?? '';
+    `,
+    `
+      let x: string;
+      x! ?? '';
+      x = foo();
+    `,
+    `
+      let x: string;
+      foo(x);
+      x! ?? '';
+      x = foo();
+    `,
+    `
+      let x = foo();
+      x ?? '';
+    `,
+    `
+      function foo() {
+        let x: string;
+        return x ?? '';
+      }
+    `,
+    `
+      let x: string;
+      function foo() {
+        return x ?? '';
+      }
+    `,
+  ],
 });
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 27b27ac07a8c..865dadb2c33c 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
@@ -5,21 +5,6 @@ import rule from '../../src/rules/no-non-null-asserted-optional-chain';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-optional-chain', rule, {
-  valid: [
-    'foo.bar!;',
-    'foo.bar!.baz;',
-    'foo.bar!.baz();',
-    'foo.bar()!;',
-    'foo.bar()!();',
-    'foo.bar()!.baz;',
-    'foo?.bar;',
-    'foo?.bar();',
-    '(foo?.bar).baz!;',
-    '(foo?.bar()).baz!;',
-    'foo?.bar!.baz;',
-    'foo?.bar!();',
-    "foo?.['bar']!.baz;",
-  ],
   invalid: [
     {
       code: 'foo?.bar!;',
@@ -162,4 +147,19 @@ ruleTester.run('no-non-null-asserted-optional-chain', rule, {
       ],
     },
   ],
+  valid: [
+    'foo.bar!;',
+    'foo.bar!.baz;',
+    'foo.bar!.baz();',
+    'foo.bar()!;',
+    'foo.bar()!();',
+    'foo.bar()!.baz;',
+    'foo?.bar;',
+    'foo?.bar();',
+    '(foo?.bar).baz!;',
+    '(foo?.bar()).baz!;',
+    'foo?.bar!.baz;',
+    'foo?.bar!();',
+    "foo?.['bar']!.baz;",
+  ],
 });
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 454a9e4bde51..2a8eeae99d1b 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
@@ -5,23 +5,14 @@ import rule from '../../src/rules/no-non-null-assertion';
 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;',
-  ],
   invalid: [
     {
       code: 'x!;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -30,9 +21,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!.y;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -46,9 +37,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y!;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -57,9 +48,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: '!x!.y;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 2,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -73,9 +64,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!.y?.z;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -89,9 +80,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x![y];',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -105,9 +96,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x![y]?.z;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -121,9 +112,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y.z!();',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -137,9 +128,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y?.z!();',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -154,24 +145,24 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!!!;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 5,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 4,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 3,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -180,10 +171,10 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!!.y;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 4,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -192,10 +183,10 @@ ruleTester.run('no-non-null-assertion', rule, {
           ],
         },
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 3,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -204,17 +195,17 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y!!;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 6,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 5,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -223,10 +214,10 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y.z!!();',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 8,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -235,10 +226,10 @@ ruleTester.run('no-non-null-assertion', rule, {
           ],
         },
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
           endColumn: 7,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: undefined,
         },
       ],
@@ -247,9 +238,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!?.[y].z;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -263,9 +254,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x!?.y.z;',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -279,9 +270,9 @@ ruleTester.run('no-non-null-assertion', rule, {
       code: 'x.y.z!?.();',
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -298,9 +289,9 @@ x!
       `,
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -321,9 +312,9 @@ x!
       `,
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -346,9 +337,9 @@ x!
       `,
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -371,9 +362,9 @@ x!
       `,
       errors: [
         {
-          messageId: 'noNonNull',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'noNonNull',
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
@@ -388,4 +379,13 @@ x?.
       ],
     },
   ],
+  valid: [
+    //
+    'x;',
+    'x.y;',
+    'x.y.z;',
+    'x?.y.z;',
+    'x?.y?.z;',
+    '!x;',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
index 55c263246845..24237910a6c2 100644
--- a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
@@ -13,152 +13,22 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-redeclare', rule, {
-  valid: [
-    `
-var a = 3;
-var b = function () {
-  var a = 10;
-};
-    `,
-    `
-var a = 3;
-a = 10;
-    `,
-    {
-      code: `
-if (true) {
-  let b = 2;
-} else {
-  let b = 3;
-}
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaVersion: 6,
-        },
-      },
-    },
-    { code: 'var Object = 0;', options: [{ builtinGlobals: false }] },
-    {
-      code: 'var Object = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-    },
-    {
-      code: 'var Object = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-    },
-    {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: false }],
-    },
-    { code: 'var top = 0;', options: [{ builtinGlobals: true }] },
-    {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-    },
-    {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-    },
-    {
-      code: 'var self = 1;',
-      options: [{ builtinGlobals: true }],
-    },
-    // https://github.com/eslint/typescript-eslint-parser/issues/535
-    `
-function foo({ bar }: { bar: string }) {
-  console.log(bar);
-}
-    `,
-    `
-type AST<T extends ParserOptions> = TSESTree.Program &
-  (T['range'] extends true ? { range: [number, number] } : {}) &
-  (T['tokens'] extends true ? { tokens: TSESTree.Token[] } : {}) &
-  (T['comment'] extends true ? { comments: TSESTree.Comment[] } : {});
-interface ParseAndGenerateServicesResult<T extends ParserOptions> {
-  ast: AST<T>;
-  services: ParserServices;
-}
-    `,
-    `
-function A<T>() {}
-interface B<T> {}
-type C<T> = Array<T>;
-class D<T> {}
-    `,
-    `
-function a(): string;
-function a(): number;
-function a() {}
-    `,
-    {
-      code: `
-interface A {}
-interface A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-interface A {}
-class A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-class A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-interface A {}
-class A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-enum A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-function A() {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-  ],
   invalid: [
     {
       code: `
 var a = 3;
 var a = 10;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -171,10 +41,10 @@ switch (foo) {
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'b',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -186,10 +56,10 @@ var a = 10;
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -201,10 +71,10 @@ var a = [];
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -216,10 +86,10 @@ function a() {}
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -231,10 +101,10 @@ function a() {}
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -246,10 +116,10 @@ var a = function () {};
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -261,10 +131,10 @@ var a = new Date();
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -277,17 +147,17 @@ var a = 15;
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
@@ -297,155 +167,155 @@ var a = 15;
 var a;
 var a;
       `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: `
 export var a;
 var a;
       `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: 'var Object = 0;',
-      options: [{ builtinGlobals: true }],
       errors: [
         {
-          messageId: 'redeclaredAsBuiltin',
           data: {
             id: 'Object',
           },
+          messageId: 'redeclaredAsBuiltin',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      options: [{ builtinGlobals: true }],
     },
     {
       code: 'var top = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        globals: { top: 'readonly' },
-      },
       errors: [
         {
-          messageId: 'redeclaredAsBuiltin',
           data: {
             id: 'top',
           },
+          messageId: 'redeclaredAsBuiltin',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        globals: { top: 'readonly' },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
 var a;
 var { a = 0, b: Object = 0 } = {};
       `,
-      options: [{ builtinGlobals: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
         {
-          messageId: 'redeclaredAsBuiltin',
           data: {
             id: 'Object',
           },
+          messageId: 'redeclaredAsBuiltin',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
 var a;
 var { a = 0, b: Object = 0 } = {};
       `,
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
 var a;
 var { a = 0, b: Object = 0 } = {};
       `,
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { globalReturn: true } },
-      },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true }, ecmaVersion: 6 },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
 var a;
 var { a = 0, b: Object = 0 } = {};
       `,
-      options: [{ builtinGlobals: false }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'a',
           },
+          messageId: 'redeclared',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ builtinGlobals: false }],
     },
 
     // Notifications of readonly are moved from no-undef: https://github.com/eslint/eslint/issues/4504
     {
       code: '/*global b:false*/ var b = 1;',
-      options: [{ builtinGlobals: true }],
       errors: [
         {
-          messageId: 'redeclaredBySyntax',
           data: {
             id: 'b',
           },
+          messageId: 'redeclaredBySyntax',
           type: AST_TOKEN_TYPES.Identifier,
         },
       ],
+      options: [{ builtinGlobals: true }],
     },
 
     {
@@ -455,11 +325,11 @@ type T = 2;
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'T',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
     },
@@ -467,69 +337,69 @@ type T = 2;
       code: `
 type NodeListOf = 1;
       `,
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: {
-          lib: ['dom'],
-          sourceType: 'script',
-        },
-      },
       errors: [
         {
-          messageId: 'redeclaredAsBuiltin',
           data: {
             id: 'NodeListOf',
           },
+          messageId: 'redeclaredAsBuiltin',
         },
       ],
+      languageOptions: {
+        parserOptions: {
+          lib: ['dom'],
+          sourceType: 'script',
+        },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
 interface A {}
 interface A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
 interface A {}
 class A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
 class A {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
@@ -537,23 +407,23 @@ interface A {}
 class A {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 4,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
@@ -561,32 +431,32 @@ class A {}
 class A {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: true }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: true }],
     },
     {
       code: `
 function A() {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
@@ -594,32 +464,32 @@ function A() {}
 function A() {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: true }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: true }],
     },
     {
       code: `
 function A() {}
 class A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
@@ -627,16 +497,16 @@ enum A {}
 namespace A {}
 enum A {}
       `,
-      options: [{ ignoreDeclarationMerge: true }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 4,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: true }],
     },
     {
       code: `
@@ -644,23 +514,23 @@ function A() {}
 class A {}
 namespace A {}
       `,
-      options: [{ ignoreDeclarationMerge: false }],
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 3,
+          messageId: 'redeclared',
         },
         {
-          messageId: 'redeclared',
           data: {
             id: 'A',
           },
           line: 4,
+          messageId: 'redeclared',
         },
       ],
+      options: [{ ignoreDeclarationMerge: false }],
     },
     {
       code: `
@@ -669,13 +539,143 @@ const something = 2;
       `,
       errors: [
         {
-          messageId: 'redeclared',
           data: {
             id: 'something',
           },
           line: 3,
+          messageId: 'redeclared',
         },
       ],
     },
   ],
+  valid: [
+    `
+var a = 3;
+var b = function () {
+  var a = 10;
+};
+    `,
+    `
+var a = 3;
+a = 10;
+    `,
+    {
+      code: `
+if (true) {
+  let b = 2;
+} else {
+  let b = 3;
+}
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaVersion: 6,
+        },
+      },
+    },
+    { code: 'var Object = 0;', options: [{ builtinGlobals: false }] },
+    {
+      code: 'var Object = 0;',
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var Object = 0;',
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var top = 0;',
+      options: [{ builtinGlobals: false }],
+    },
+    { code: 'var top = 0;', options: [{ builtinGlobals: true }] },
+    {
+      code: 'var top = 0;',
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var top = 0;',
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var self = 1;',
+      options: [{ builtinGlobals: true }],
+    },
+    // https://github.com/eslint/typescript-eslint-parser/issues/535
+    `
+function foo({ bar }: { bar: string }) {
+  console.log(bar);
+}
+    `,
+    `
+type AST<T extends ParserOptions> = TSESTree.Program &
+  (T['range'] extends true ? { range: [number, number] } : {}) &
+  (T['tokens'] extends true ? { tokens: TSESTree.Token[] } : {}) &
+  (T['comment'] extends true ? { comments: TSESTree.Comment[] } : {});
+interface ParseAndGenerateServicesResult<T extends ParserOptions> {
+  ast: AST<T>;
+  services: ParserServices;
+}
+    `,
+    `
+function A<T>() {}
+interface B<T> {}
+type C<T> = Array<T>;
+class D<T> {}
+    `,
+    `
+function a(): string;
+function a(): number;
+function a() {}
+    `,
+    {
+      code: `
+interface A {}
+interface A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+interface A {}
+class A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+class A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+interface A {}
+class A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+enum A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+function A() {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
index 7d165ddd0489..6e87f14f9235 100644
--- a/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
@@ -7,166 +7,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-redundant-type-constituents', rule, {
-  valid: [
-    `
-      type T = any;
-      type U = T;
-    `,
-    `
-      type T = never;
-      type U = T;
-    `,
-    `
-      type T = 1 | 2;
-      type U = T | 3;
-      type V = U;
-    `,
-    'type T = () => never;',
-    'type T = () => never | string;',
-    `
-      type B = never;
-      type T = () => B | string;
-    `,
-    `
-      type B = string;
-      type T = () => B | never;
-    `,
-    'type T = () => string | never;',
-    'type T = { (): string | never };',
-    `
-      function _(): string | never {
-        return '';
-      }
-    `,
-    `
-      const _ = (): string | never => {
-        return '';
-      };
-    `,
-    `
-      type B = string;
-      type T = { (): B | never };
-    `,
-    'type T = { new (): string | never };',
-    `
-      type B = never;
-      type T = { new (): string | B };
-    `,
-    `
-      type B = unknown;
-      type T = B;
-    `,
-    'type T = bigint;',
-    `
-      type B = bigint;
-      type T = B;
-    `,
-    'type T = 1n | 2n;',
-    `
-      type B = 1n;
-      type T = B | 2n;
-    `,
-    'type T = boolean;',
-    `
-      type B = boolean;
-      type T = B;
-    `,
-    'type T = false | true;',
-    `
-      type B = false;
-      type T = B | true;
-    `,
-    `
-      type B = true;
-      type T = B | false;
-    `,
-    'type T = number;',
-    `
-      type B = number;
-      type T = B;
-    `,
-    'type T = 1 | 2;',
-    `
-      type B = 1;
-      type T = B | 2;
-    `,
-    'type T = 1 | false;',
-    `
-      type B = 1;
-      type T = B | false;
-    `,
-    'type T = string;',
-    `
-      type B = string;
-      type T = B;
-    `,
-    "type T = 'a' | 'b';",
-    `
-      type B = 'b';
-      type T = 'a' | B;
-    `,
-    `
-      type B = 'a';
-      type T = B | 'b';
-    `,
-    'type T = bigint | null;',
-    `
-      type B = bigint;
-      type T = B | null;
-    `,
-    'type T = boolean | null;',
-    `
-      type B = boolean;
-      type T = B | null;
-    `,
-    'type T = number | null;',
-    `
-      type B = number;
-      type T = B | null;
-    `,
-    'type T = string | null;',
-    `
-      type B = string;
-      type T = B | null;
-    `,
-    'type T = bigint & null;',
-    `
-      type B = bigint;
-      type T = B & null;
-    `,
-    'type T = boolean & null;',
-    `
-      type B = boolean;
-      type T = B & null;
-    `,
-    'type T = number & null;',
-    `
-      type B = number;
-      type T = B & null;
-    `,
-    'type T = string & null;',
-    `
-      type B = string;
-      type T = B & null;
-    `,
-    'type T = `${string}` & null;',
-    `
-      type B = \`\${string}\`;
-      type T = B & null;
-    `,
-    `
-      type T = 'a' | 1 | 'b';
-      type U = T & string;
-    `,
-  ],
-
   invalid: [
     {
       code: 'type T = number | any;',
@@ -857,4 +704,157 @@ ruleTester.run('no-redundant-type-constituents', rule, {
       ],
     },
   ],
+
+  valid: [
+    `
+      type T = any;
+      type U = T;
+    `,
+    `
+      type T = never;
+      type U = T;
+    `,
+    `
+      type T = 1 | 2;
+      type U = T | 3;
+      type V = U;
+    `,
+    'type T = () => never;',
+    'type T = () => never | string;',
+    `
+      type B = never;
+      type T = () => B | string;
+    `,
+    `
+      type B = string;
+      type T = () => B | never;
+    `,
+    'type T = () => string | never;',
+    'type T = { (): string | never };',
+    `
+      function _(): string | never {
+        return '';
+      }
+    `,
+    `
+      const _ = (): string | never => {
+        return '';
+      };
+    `,
+    `
+      type B = string;
+      type T = { (): B | never };
+    `,
+    'type T = { new (): string | never };',
+    `
+      type B = never;
+      type T = { new (): string | B };
+    `,
+    `
+      type B = unknown;
+      type T = B;
+    `,
+    'type T = bigint;',
+    `
+      type B = bigint;
+      type T = B;
+    `,
+    'type T = 1n | 2n;',
+    `
+      type B = 1n;
+      type T = B | 2n;
+    `,
+    'type T = boolean;',
+    `
+      type B = boolean;
+      type T = B;
+    `,
+    'type T = false | true;',
+    `
+      type B = false;
+      type T = B | true;
+    `,
+    `
+      type B = true;
+      type T = B | false;
+    `,
+    'type T = number;',
+    `
+      type B = number;
+      type T = B;
+    `,
+    'type T = 1 | 2;',
+    `
+      type B = 1;
+      type T = B | 2;
+    `,
+    'type T = 1 | false;',
+    `
+      type B = 1;
+      type T = B | false;
+    `,
+    'type T = string;',
+    `
+      type B = string;
+      type T = B;
+    `,
+    "type T = 'a' | 'b';",
+    `
+      type B = 'b';
+      type T = 'a' | B;
+    `,
+    `
+      type B = 'a';
+      type T = B | 'b';
+    `,
+    'type T = bigint | null;',
+    `
+      type B = bigint;
+      type T = B | null;
+    `,
+    'type T = boolean | null;',
+    `
+      type B = boolean;
+      type T = B | null;
+    `,
+    'type T = number | null;',
+    `
+      type B = number;
+      type T = B | null;
+    `,
+    'type T = string | null;',
+    `
+      type B = string;
+      type T = B | null;
+    `,
+    'type T = bigint & null;',
+    `
+      type B = bigint;
+      type T = B & null;
+    `,
+    'type T = boolean & null;',
+    `
+      type B = boolean;
+      type T = B & null;
+    `,
+    'type T = number & null;',
+    `
+      type B = number;
+      type T = B & null;
+    `,
+    'type T = string & null;',
+    `
+      type B = string;
+      type T = B & null;
+    `,
+    'type T = `${string}` & null;',
+    `
+      type B = \`\${string}\`;
+      type T = B & null;
+    `,
+    `
+      type T = 'a' | 1 | 'b';
+      type U = T & string;
+    `,
+  ],
 });
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 822456fef3a5..672d7a0d68f5 100644
--- a/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
@@ -5,118 +5,14 @@ import rule from '../../src/rules/no-require-imports';
 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 { createRequire } from 'module';
-const require = createRequire();
-require('remark-preset-prettier');
-    `,
-    {
-      code: "const pkg = require('./package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: 'const pkg = require(`./package.json`);',
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('data.json');",
-      options: [{ allow: ['\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('some-package');",
-      options: [{ allow: ['^some-package$'] }],
-    },
-    {
-      code: "import foo = require('foo');",
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-trick(require('foo'));
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo = require('./foo.json') as Foo;
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo: Foo = require('./foo.json').default;
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo = <Foo>require('./foo.json');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const configValidator = new Validator(require('./a.json'));
-configValidator.addSchema(require('./a.json'));
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-require('foo');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-require?.('foo');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-import { createRequire } from 'module';
-const require = createRequire();
-require('remark-preset-prettier');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-  ],
   invalid: [
     {
       code: "var lib = require('lib');",
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -124,9 +20,9 @@ require('remark-preset-prettier');
       code: "let lib2 = require('lib2');",
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -137,14 +33,14 @@ var lib5 = require('lib5'),
       `,
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 2,
           column: 12,
+          line: 2,
+          messageId: 'noRequireImports',
         },
         {
-          messageId: 'noRequireImports',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -152,9 +48,9 @@ var lib5 = require('lib5'),
       code: "import lib8 = require('lib8');",
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 15,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -162,9 +58,9 @@ var lib5 = require('lib5'),
       code: "var lib = require?.('lib');",
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -172,9 +68,9 @@ var lib5 = require('lib5'),
       code: "let lib2 = require?.('lib2');",
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -185,14 +81,14 @@ var lib5 = require?.('lib5'),
       `,
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 2,
           column: 12,
+          line: 2,
+          messageId: 'noRequireImports',
         },
         {
-          messageId: 'noRequireImports',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'noRequireImports',
         },
       ],
     },
@@ -200,172 +96,276 @@ var lib5 = require?.('lib5'),
       code: "const pkg = require('./package.json');",
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
     },
     {
       code: "const pkg = require('./package.jsonc');",
-      options: [{ allow: ['/package\\.json$'] }],
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
+      options: [{ allow: ['/package\\.json$'] }],
     },
     {
       code: 'const pkg = require(`./package.jsonc`);',
-      options: [{ allow: ['/package\\.json$'] }],
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
+      options: [{ allow: ['/package\\.json$'] }],
     },
     {
       code: "import pkg = require('./package.json');",
       errors: [
         {
-          line: 1,
           column: 14,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
     },
     {
       code: "import pkg = require('./package.jsonc');",
-      options: [{ allow: ['/package\\.json$'] }],
       errors: [
         {
-          line: 1,
           column: 14,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
+      options: [{ allow: ['/package\\.json$'] }],
     },
     {
       code: "import pkg = require('./package.json');",
-      options: [{ allow: ['^some-package$'] }],
       errors: [
         {
-          line: 1,
           column: 14,
+          line: 1,
           messageId: 'noRequireImports',
         },
       ],
+      options: [{ allow: ['^some-package$'] }],
     },
     {
       code: "var foo = require?.('foo');",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: "let foo = trick(require?.('foo'));",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 17,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: "trick(require('foo'));",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 7,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: "const foo = require('./foo.json') as Foo;",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: "const foo: Foo = require('./foo.json').default;",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 18,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: "const foo = <Foo>require('./foo.json');",
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 18,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: `
 const configValidator = new Validator(require('./a.json'));
 configValidator.addSchema(require('./a.json'));
       `,
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 2,
           column: 39,
+          line: 2,
+          messageId: 'noRequireImports',
         },
         {
-          messageId: 'noRequireImports',
-          line: 3,
           column: 27,
+          line: 3,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: 'require(foo);',
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
     },
     {
       code: 'require?.(foo);',
-      options: [{ allowAsImport: true }],
       errors: [
         {
-          messageId: 'noRequireImports',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'noRequireImports',
         },
       ],
+      options: [{ allowAsImport: true }],
+    },
+  ],
+  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 { createRequire } from 'module';
+const require = createRequire();
+require('remark-preset-prettier');
+    `,
+    {
+      code: "const pkg = require('./package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: 'const pkg = require(`./package.json`);',
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('data.json');",
+      options: [{ allow: ['\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('some-package');",
+      options: [{ allow: ['^some-package$'] }],
+    },
+    {
+      code: "import foo = require('foo');",
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+trick(require('foo'));
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo = require('./foo.json') as Foo;
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo: Foo = require('./foo.json').default;
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo = <Foo>require('./foo.json');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const configValidator = new Validator(require('./a.json'));
+configValidator.addSchema(require('./a.json'));
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+require('foo');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+require?.('foo');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+import { createRequire } from 'module';
+const require = createRequire();
+require('remark-preset-prettier');
+      `,
+      options: [{ allowAsImport: true }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts b/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
index 1c8a93108e5c..854569b530e9 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
@@ -6,36 +6,64 @@ import rule from '../../src/rules/no-restricted-imports';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-imports', rule, {
-  valid: [
-    "import foo from 'foo';",
-    "import foo = require('foo');",
-    "import 'foo';",
+  invalid: [
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo = require('foo');",
+      code: "import foo = require('import1');",
+      errors: [
+        {
+          messageId: 'path',
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "import 'foo';",
-      options: ['import1', 'import2'],
-    },
-    {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: ['import1', 'import2'],
@@ -44,7 +72,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: ['import1', 'import2'],
@@ -53,69 +87,99 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
             {
-              name: 'import-baz',
               message: 'Please use import-quux instead.',
+              name: 'import-baz',
             },
           ],
         },
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
             {
-              name: 'import-baz',
               message: 'Please use import-quux instead.',
+              name: 'import-baz',
             },
           ],
         },
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
@@ -133,7 +197,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
@@ -151,373 +221,348 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo = require('foo');",
+      code: "import 'import-foo';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'foo',
-              importNames: ['foo'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import type foo from 'import-foo';",
+      code: "import 'import-foo';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              message: 'Please use import-bar instead.',
               allowTypeImports: true,
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import type _ = require('import-foo');",
+      code: "import foo from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              message: 'Please use import-bar instead.',
               allowTypeImports: true,
+              message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import type { Bar } from 'import-foo';",
+      code: "import foo = require('import-foo');",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
               allowTypeImports: true,
+              message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "export type { Bar } from 'import-foo';",
+      code: "import { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
+              allowTypeImports: true,
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
-              allowTypeImports: true,
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import type foo from 'import1/private/bar';",
+      code: "export { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
-          patterns: [
+          paths: [
             {
-              group: ['import1/private/*'],
-              message: 'usage of import1 private modules not allowed.',
               allowTypeImports: true,
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "export type { foo } from 'import1/private/bar';",
+      code: "import foo from 'import1/private/bar';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
             {
+              allowTypeImports: true,
               group: ['import1/private/*'],
               message: 'usage of import1 private modules not allowed.',
-              allowTypeImports: true,
             },
           ],
         },
       ],
     },
     {
-      code: "export * from 'foo';",
-      options: ['import1'],
-    },
-    {
-      code: "import type { MyType } from './types';",
+      code: "export { foo } from 'import1/private/bar';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
             {
-              group: ['fail'],
-              message: "Please do not load from 'fail'.",
               allowTypeImports: true,
+              group: ['import1/private/*'],
+              message: 'usage of import1 private modules not allowed.',
             },
           ],
         },
       ],
     },
     {
-      code: `
-import type { foo } from 'import1/private/bar';
-import type { foo } from 'import2/private/bar';
-      `,
-      options: [
+      code: "export * from 'import1';",
+      errors: [
         {
-          patterns: [
-            {
-              group: ['import1/private/*'],
-              message: 'usage of import1 private modules not allowed.',
-              allowTypeImports: true,
-            },
-            {
-              group: ['import2/private/*'],
-              message: 'usage of import2 private modules not allowed.',
-              allowTypeImports: true,
-            },
-          ],
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportAllDeclaration,
         },
       ],
+      options: ['import1'],
     },
     {
-      code: "import { type Bar } from 'import-foo';",
+      code: "import type { InvalidTestCase } from '@typescript-eslint/utils/dist/ts-eslint';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
-          paths: [
-            {
-              name: 'import-foo',
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
-              allowTypeImports: true,
-            },
-          ],
+          patterns: ['@typescript-eslint/utils/dist/*'],
         },
       ],
     },
     {
-      code: "export { type Bar } from 'import-foo';",
+      code: "import { Bar, type Baz } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
               allowTypeImports: true,
+              importNames: ['Bar', 'Baz'],
+              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import foo from 'foo';",
-      options: [],
-    },
-    {
-      code: "import foo from 'foo';",
-      options: [
+      code: "export { Bar, type Baz } from 'import-foo';",
+      errors: [
         {
-          paths: [],
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
         },
-      ],
-    },
-    {
-      code: "import foo from 'foo';",
-      options: [
         {
-          patterns: [],
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
         },
       ],
-    },
-    {
-      code: "import foo from 'foo';",
       options: [
         {
-          paths: [],
-          patterns: [],
+          paths: [
+            {
+              allowTypeImports: true,
+              importNames: ['Bar', 'Baz'],
+              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
+              name: 'import-foo',
+            },
+          ],
         },
       ],
     },
   ],
-  invalid: [
+  valid: [
+    "import foo from 'foo';",
+    "import foo = require('foo');",
+    "import 'foo';",
     {
-      code: "import foo from 'import1';",
+      code: "import foo from 'foo';",
       options: ['import1', 'import2'],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo = require('import1');",
+      code: "import foo = require('foo');",
       options: ['import1', 'import2'],
-      errors: [
-        {
-          messageId: 'path',
-        },
-      ],
     },
     {
-      code: "export { foo } from 'import1';",
+      code: "export { foo } from 'foo';",
       options: ['import1', 'import2'],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import1';",
+      code: "import foo from 'foo';",
       options: [{ paths: ['import1', 'import2'] }],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { foo } from 'import1';",
+      code: "export { foo } from 'foo';",
       options: [{ paths: ['import1', 'import2'] }],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import1/private/foo';",
+      code: "import 'foo';",
+      options: ['import1', 'import2'],
+    },
+    {
+      code: "import foo from 'foo';",
       options: [
         {
           paths: ['import1', 'import2'],
-          patterns: ['import1/private/*', 'import2/*', '!import2/good'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ImportDeclaration,
+          patterns: ['import1/private/*', 'import2/*', '!import2/good'],
         },
       ],
     },
     {
-      code: "export { foo } from 'import1/private/foo';",
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: ['import1', 'import2'],
           patterns: ['import1/private/*', 'import2/*', '!import2/good'],
         },
       ],
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import-foo';",
+      code: "import foo from 'foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
             {
-              name: 'import-baz',
               message: 'Please use import-quux instead.',
+              name: 'import-baz',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { foo } from 'import-foo';",
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
             {
-              name: 'import-baz',
               message: 'Please use import-quux instead.',
+              name: 'import-baz',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import { Bar } from 'import-foo';",
+      code: "import foo from 'foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { Bar } from 'import-foo';",
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import1/private/foo';",
+      code: "import foo from 'foo';",
       options: [
         {
           patterns: [
@@ -533,15 +578,9 @@ import type { foo } from 'import2/private/bar';
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { foo } from 'import1/private/foo';",
+      code: "export { foo } from 'foo';",
       options: [
         {
           patterns: [
@@ -557,242 +596,203 @@ import type { foo } from 'import2/private/bar';
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import 'import-foo';",
+      code: "import foo = require('foo');",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
+              importNames: ['foo'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "import 'import-foo';",
+      code: "import type foo from 'import-foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
               allowTypeImports: true,
+              message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import-foo';",
+      code: "import type _ = require('import-foo');",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              message: 'Please use import-bar instead.',
               allowTypeImports: true,
+              message: 'Please use import-bar instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo = require('import-foo');",
+      code: "import type { Bar } from 'import-foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              message: 'Please use import-bar instead.',
               allowTypeImports: true,
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-        },
-      ],
     },
     {
-      code: "import { Bar } from 'import-foo';",
+      code: "export type { Bar } from 'import-foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
+              allowTypeImports: true,
               importNames: ['Bar'],
               message: 'Please use Bar from /import-bar/baz/ instead.',
-              allowTypeImports: true,
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { Bar } from 'import-foo';",
+      code: "import type foo from 'import1/private/bar';",
       options: [
         {
-          paths: [
+          patterns: [
             {
-              name: 'import-foo',
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
               allowTypeImports: true,
+              group: ['import1/private/*'],
+              message: 'usage of import1 private modules not allowed.',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "import foo from 'import1/private/bar';",
+      code: "export type { foo } from 'import1/private/bar';",
       options: [
         {
           patterns: [
             {
+              allowTypeImports: true,
               group: ['import1/private/*'],
               message: 'usage of import1 private modules not allowed.',
-              allowTypeImports: true,
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
     },
     {
-      code: "export { foo } from 'import1/private/bar';",
+      code: "export * from 'foo';",
+      options: ['import1'],
+    },
+    {
+      code: "import type { MyType } from './types';",
       options: [
         {
           patterns: [
             {
-              group: ['import1/private/*'],
-              message: 'usage of import1 private modules not allowed.',
               allowTypeImports: true,
+              group: ['fail'],
+              message: "Please do not load from 'fail'.",
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
     },
     {
-      code: "export * from 'import1';",
-      options: ['import1'],
-      errors: [
+      code: `
+import type { foo } from 'import1/private/bar';
+import type { foo } from 'import2/private/bar';
+      `,
+      options: [
         {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportAllDeclaration,
+          patterns: [
+            {
+              allowTypeImports: true,
+              group: ['import1/private/*'],
+              message: 'usage of import1 private modules not allowed.',
+            },
+            {
+              allowTypeImports: true,
+              group: ['import2/private/*'],
+              message: 'usage of import2 private modules not allowed.',
+            },
+          ],
         },
       ],
     },
     {
-      code: "import type { InvalidTestCase } from '@typescript-eslint/utils/dist/ts-eslint';",
+      code: "import { type Bar } from 'import-foo';",
       options: [
         {
-          patterns: ['@typescript-eslint/utils/dist/*'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ImportDeclaration,
+          paths: [
+            {
+              allowTypeImports: true,
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
+            },
+          ],
         },
       ],
     },
     {
-      code: "import { Bar, type Baz } from 'import-foo';",
+      code: "export { type Bar } from 'import-foo';",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
-              importNames: ['Bar', 'Baz'],
-              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
               allowTypeImports: true,
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
+    },
+    {
+      code: "import foo from 'foo';",
+      options: [],
+    },
+    {
+      code: "import foo from 'foo';",
+      options: [
         {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
+          paths: [],
         },
       ],
     },
     {
-      code: "export { Bar, type Baz } from 'import-foo';",
+      code: "import foo from 'foo';",
       options: [
         {
-          paths: [
-            {
-              name: 'import-foo',
-              importNames: ['Bar', 'Baz'],
-              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
-              allowTypeImports: true,
-            },
-          ],
+          patterns: [],
         },
       ],
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
+    },
+    {
+      code: "import foo from 'foo';",
+      options: [
         {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
+          paths: [],
+          patterns: [],
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts b/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
index db4bfdf07f1f..e98b54210e11 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
@@ -5,591 +5,562 @@ import rule from '../../src/rules/no-restricted-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-types', rule, {
-  valid: [
-    'let f = Object();',
-    'let f: { x: number; y: number } = { x: 1, y: 1 };',
-    {
-      code: 'let f = Object();',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let f = Object(false);',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let g = Object.create(null);',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let e: namespace.Object;',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let value: _.NS.Banned;',
-      options: [{ types: { 'NS.Banned': true } }],
-    },
-    {
-      code: 'let value: NS.Banned._;',
-      options: [{ types: { 'NS.Banned': true } }],
-    },
-  ],
   invalid: [
     {
       code: 'let value: bigint;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'bigint',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { bigint: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: boolean;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'boolean',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { boolean: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: never;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'never',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { never: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: null;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'null',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { null: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: number;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'number',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { number: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: object;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'object',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { object: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: string;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'string',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { string: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: symbol;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'symbol',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { symbol: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: undefined;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'undefined',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { undefined: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: unknown;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'unknown',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { unknown: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: void;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use Ok instead.',
             name: 'void',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { void: 'Use Ok instead.' } }],
+      output: null,
     },
     {
       code: 'let value: [];',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use unknown[] instead.',
             name: '[]',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { '[]': 'Use unknown[] instead.' } }],
+      output: null,
     },
     {
       code: noFormat`let value: [  ];`,
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: ' Use unknown[] instead.',
             name: '[]',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { '[]': 'Use unknown[] instead.' } }],
+      output: null,
     },
     {
       code: 'let value: [[]];',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 13,
           data: {
             customMessage: ' Use unknown[] instead.',
             name: '[]',
           },
           line: 1,
-          column: 13,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { '[]': 'Use unknown[] instead.' } }],
+      output: null,
     },
     {
       code: 'let value: Banned;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: '',
             name: 'Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { Banned: true } }],
+      output: null,
     },
     {
       code: 'let value: Banned;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: " Use '{}' instead.",
             name: 'Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { Banned: "Use '{}' instead." } }],
+      output: null,
     },
     {
       code: 'let value: Banned[];',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: " Use '{}' instead.",
             name: 'Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { Banned: "Use '{}' instead." } }],
+      output: null,
     },
     {
       code: 'let value: [Banned];',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 13,
           data: {
             customMessage: " Use '{}' instead.",
             name: 'Banned',
           },
           line: 1,
-          column: 13,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { Banned: "Use '{}' instead." } }],
+      output: null,
     },
     {
       code: 'let value: Banned;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
             customMessage: '',
             name: 'Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [{ types: { Banned: '' } }],
+      output: null,
     },
     {
       code: 'let b: { c: Banned };',
-      output: 'let b: { c: Ok };',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 13,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 13,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: 'let b: { c: Ok };',
     },
     {
       code: '1 as Banned;',
-      output: '1 as Ok;',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 6,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 6,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: '1 as Ok;',
     },
     {
       code: 'class Derived implements Banned {}',
-      output: 'class Derived implements Ok {}',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 26,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 26,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: 'class Derived implements Ok {}',
     },
     {
       code: 'class Derived implements Banned1, Banned2 {}',
-      output: 'class Derived implements Ok1, Ok2 {}',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 26,
           data: {
-            name: 'Banned1',
             customMessage: ' Use Ok1 instead.',
+            name: 'Banned1',
           },
           line: 1,
-          column: 26,
+          messageId: 'bannedTypeMessage',
         },
         {
-          messageId: 'bannedTypeMessage',
+          column: 35,
           data: {
-            name: 'Banned2',
             customMessage: ' Use Ok2 instead.',
+            name: 'Banned2',
           },
           line: 1,
-          column: 35,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
         {
           types: {
-            Banned1: { message: 'Use Ok1 instead.', fixWith: 'Ok1' },
-            Banned2: { message: 'Use Ok2 instead.', fixWith: 'Ok2' },
+            Banned1: { fixWith: 'Ok1', message: 'Use Ok1 instead.' },
+            Banned2: { fixWith: 'Ok2', message: 'Use Ok2 instead.' },
           },
         },
       ],
+      output: 'class Derived implements Ok1, Ok2 {}',
     },
     {
       code: 'interface Derived extends Banned {}',
-      output: 'interface Derived extends Ok {}',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 27,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 27,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: 'interface Derived extends Ok {}',
     },
     {
       code: 'type Intersection = Banned & {};',
-      output: 'type Intersection = Ok & {};',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 21,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 21,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: 'type Intersection = Ok & {};',
     },
     {
       code: 'type Union = Banned | {};',
-      output: 'type Union = Ok | {};',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 14,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 14,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
-        { types: { Banned: { message: 'Use Ok instead.', fixWith: 'Ok' } } },
+        { types: { Banned: { fixWith: 'Ok', message: 'Use Ok instead.' } } },
       ],
+      output: 'type Union = Ok | {};',
     },
     {
       code: 'let value: NS.Banned;',
-      output: 'let value: NS.Ok;',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
-            name: 'NS.Banned',
             customMessage: ' Use NS.Ok instead.',
+            name: 'NS.Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
         {
           types: {
             'NS.Banned': {
-              message: 'Use NS.Ok instead.',
               fixWith: 'NS.Ok',
+              message: 'Use NS.Ok instead.',
             },
           },
         },
       ],
+      output: 'let value: NS.Ok;',
     },
     {
       code: 'let value: {} = {};',
-      output: 'let value: object = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            customMessage: ' Use object instead.',
+            name: '{}',
+          },
+          line: 1,
+          messageId: 'bannedTypeMessage',
+        },
+      ],
       options: [
         {
           types: {
             '{}': {
-              message: 'Use object instead.',
               fixWith: 'object',
+              message: 'Use object instead.',
             },
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'bannedTypeMessage',
-          data: {
-            name: '{}',
-            customMessage: ' Use object instead.',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      output: 'let value: object = {};',
     },
     {
       code: 'let value: NS.Banned;',
-      output: 'let value: NS.Ok;',
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 12,
           data: {
-            name: 'NS.Banned',
             customMessage: ' Use NS.Ok instead.',
+            name: 'NS.Banned',
           },
           line: 1,
-          column: 12,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
         {
           types: {
             '  NS.Banned  ': {
-              message: 'Use NS.Ok instead.',
               fixWith: 'NS.Ok',
+              message: 'Use NS.Ok instead.',
             },
           },
         },
       ],
+      output: 'let value: NS.Ok;',
     },
     {
       code: noFormat`let value: Type<   Banned   >;`,
-      output: `let value: Type<   Ok   >;`,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 20,
           data: {
-            name: 'Banned',
             customMessage: ' Use Ok instead.',
+            name: 'Banned',
           },
           line: 1,
-          column: 20,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
         {
           types: {
             '       Banned      ': {
-              message: 'Use Ok instead.',
               fixWith: 'Ok',
+              message: 'Use Ok instead.',
             },
           },
         },
       ],
+      output: `let value: Type<   Ok   >;`,
     },
     {
       code: 'type Intersection = Banned<any>;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 21,
           data: {
-            name: 'Banned<any>',
             customMessage: " Don't use `any` as a type parameter to `Banned`",
+            name: 'Banned<any>',
           },
           line: 1,
-          column: 21,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
@@ -599,19 +570,19 @@ ruleTester.run('no-restricted-types', rule, {
           },
         },
       ],
+      output: null,
     },
     {
       code: noFormat`type Intersection = Banned<A,B>;`,
-      output: null,
       errors: [
         {
-          messageId: 'bannedTypeMessage',
+          column: 21,
           data: {
-            name: 'Banned<A,B>',
             customMessage: " Don't pass `A, B` as parameters to `Banned`",
+            name: 'Banned<A,B>',
           },
           line: 1,
-          column: 21,
+          messageId: 'bannedTypeMessage',
         },
       ],
       options: [
@@ -621,6 +592,35 @@ ruleTester.run('no-restricted-types', rule, {
           },
         },
       ],
+      output: null,
+    },
+  ],
+  valid: [
+    'let f = Object();',
+    'let f: { x: number; y: number } = { x: 1, y: 1 };',
+    {
+      code: 'let f = Object();',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let f = Object(false);',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let g = Object.create(null);',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let e: namespace.Object;',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let value: _.NS.Banned;',
+      options: [{ types: { 'NS.Banned': true } }],
+    },
+    {
+      code: 'let value: NS.Banned._;',
+      options: [{ types: { 'NS.Banned': true } }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-shadow/no-shadow-eslint.test.ts b/packages/eslint-plugin/tests/rules/no-shadow/no-shadow-eslint.test.ts
index a7194566e267..c7c8fcbab3c5 100644
--- a/packages/eslint-plugin/tests/rules/no-shadow/no-shadow-eslint.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-shadow/no-shadow-eslint.test.ts
@@ -10,119 +10,218 @@ import rule from '../../../src/rules/no-shadow';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-shadow', rule, {
-  valid: [
-    `
-var a = 3;
-function b(x) {
-  a++;
-  return x + a;
-}
-setTimeout(function () {
-  b(a);
-}, 0);
-    `,
-    `
-(function () {
-  var doSomething = function doSomething() {};
-  doSomething();
-})();
-    `,
-    `
-var arguments;
-function bar() {}
-    `,
+  invalid: [
     {
       code: `
-var a = 3;
-var b = x => {
-  a++;
-  return x + a;
-};
-setTimeout(() => {
-  b(a);
-}, 0);
+function a(x) {
+  var b = function c() {
+    var x = 'foo';
+  };
+}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 12,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
-      code: 'class A {}',
+      code: `
+var a = x => {
+  var b = () => {
+    var x = 'foo';
+  };
+};
+      `,
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 9,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-class A {
-  constructor() {
-    var a;
-  }
+function a(x) {
+  var b = function () {
+    var x = 'foo';
+  };
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 12,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-(function () {
-  var A = class A {};
-})();
+var x = 1;
+function a(x) {
+  return ++x;
+}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-{
-  var a;
+var a = 3;
+function b() {
+  var a = 10;
 }
-var a;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    }, // this case reports `no-redeclare`, not shadowing.
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
     {
       code: `
-{
-  let a;
+var a = 3;
+function b() {
+  var a = 10;
 }
-let a;
+setTimeout(function () {
+  b();
+}, 0);
       `,
-      options: [{ hoist: 'never' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-{
-  let a;
+var a = 3;
+function b() {
+  var a = 10;
+  var b = 0;
 }
-var a;
+setTimeout(function () {
+  b();
+}, 0);
       `,
-      options: [{ hoist: 'never' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+        {
+          data: {
+            name: 'b',
+            shadowedColumn: 10,
+            shadowedLine: 3,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
+var x = 1;
 {
-  let a;
+  let x = 2;
 }
-function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
+let x = 1;
 {
-  const a = 0;
+  const x = 2;
 }
-const a = 1;
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 5,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 {
-  const a = 0;
+  let a;
 }
-var a;
+function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
@@ -132,7 +231,17 @@ var a;
 }
 function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
@@ -140,138 +249,247 @@ function a() {}
 function foo() {
   let a;
 }
-let a;
+function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
-  let a;
+  var a;
 }
-var a;
+function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo() {
-  let a;
-}
+function foo(a) {}
 function a() {}
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 3,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo() {
-  var a;
+{
+  let a;
 }
 let a;
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-function foo() {
-  var a;
+{
+  let a;
 }
 var a;
       `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-function foo() {
-  var a;
+{
+  let a;
 }
 function a() {}
       `,
-      options: [{ hoist: 'never' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-function foo(a) {}
-let a;
-      `,
-      options: [{ hoist: 'never' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-function foo(a) {}
-var a;
-      `,
-      options: [{ hoist: 'never' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-function foo(a) {}
-function a() {}
-      `,
-      options: [{ hoist: 'never' }],
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 {
-  let a;
+  const a = 0;
 }
-let a;
+const a = 1;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 7,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 {
-  let a;
+  const a = 0;
 }
 var a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 {
   const a = 0;
 }
-const a = 1;
+function a() {}
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-{
-  const a = 0;
+function foo() {
+  let a;
 }
-var a;
+let a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 function foo() {
   let a;
 }
-let a;
+var a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 function foo() {
   let a;
 }
-var a;
+function a() {}
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
@@ -280,7 +498,19 @@ function foo() {
 }
 let a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
@@ -289,997 +519,777 @@ function foo() {
 }
 var a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-function foo(a) {}
-let a;
+function foo() {
+  var a;
+}
+function a() {}
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 5,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
 function foo(a) {}
-var a;
+let a;
       `,
+      errors: [
+        {
+          data: {
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 3,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
-    `
-function foo() {
-  var Object = 0;
-}
-    `,
     {
       code: `
-function foo() {
-  var top = 0;
-}
-      `,
-    },
-    {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: true }],
-    },
-    {
-      code: `
-function foo(cb) {
-  (function (cb) {
-    cb(42);
-  })(cb);
-}
-      `,
-      options: [{ allow: ['cb'] }],
-    },
-  ],
-  invalid: [
-    {
-      code: `
-function a(x) {
-  var b = function c() {
-    var x = 'foo';
-  };
-}
+function foo(a) {}
+var a;
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 12,
+            name: 'a',
+            shadowedColumn: 5,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-var a = x => {
-  var b = () => {
-    var x = 'foo';
-  };
-};
+function foo(a) {}
+function a() {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 9,
+            name: 'a',
+            shadowedColumn: 10,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-function a(x) {
-  var b = function () {
-    var x = 'foo';
-  };
-}
+(function a() {
+  function a() {}
+})();
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
+            name: 'a',
+            shadowedColumn: 11,
             shadowedLine: 2,
-            shadowedColumn: 12,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-var x = 1;
-function a(x) {
-  return ++x;
-}
+(function a() {
+  class a {}
+})();
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
+            name: 'a',
+            shadowedColumn: 11,
             shadowedLine: 2,
-            shadowedColumn: 5,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 3;
-function b() {
-  var a = 10;
-}
+(function a() {
+  (function a() {});
+})();
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
+            shadowedColumn: 11,
             shadowedLine: 2,
-            shadowedColumn: 5,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-var a = 3;
-function b() {
-  var a = 10;
-}
-setTimeout(function () {
-  b();
-}, 0);
+(function a() {
+  (class a {});
+})();
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
+            shadowedColumn: 11,
             shadowedLine: 2,
-            shadowedColumn: 5,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 3;
-function b() {
-  var a = 10;
-  var b = 0;
-}
-setTimeout(function () {
-  b();
-}, 0);
+(function () {
+  var a = function (a) {};
+})();
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'b',
+            shadowedColumn: 7,
             shadowedLine: 3,
-            shadowedColumn: 10,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-var x = 1;
-{
-  let x = 2;
-}
+(function () {
+  var a = function () {
+    function a() {}
+  };
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 5,
+            name: 'a',
+            shadowedColumn: 7,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-let x = 1;
-{
-  const x = 2;
-}
+(function () {
+  var a = function () {
+    class a {}
+  };
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 5,
+            name: 'a',
+            shadowedColumn: 7,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-{
-  let a;
-}
-function a() {}
+(function () {
+  var a = function () {
+    (function a() {});
+  };
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            shadowedColumn: 7,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-{
-  const a = 0;
-}
-function a() {}
+(function () {
+  var a = function () {
+    (class a {});
+  };
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            shadowedColumn: 7,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo() {
-  let a;
-}
-function a() {}
+(function () {
+  var a = class {
+    constructor() {
+      class a {}
+    }
+  };
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            shadowedColumn: 7,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo() {
-  var a;
+class A {
+  constructor() {
+    var A;
+  }
 }
-function a() {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            name: 'A',
+            shadowedColumn: 7,
+            shadowedLine: 2,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(a) {}
-function a() {}
+(function a() {
+  function a() {
+    function a() {}
+  }
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 10,
+            shadowedColumn: 11,
+            shadowedLine: 2,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
-      ],
-    },
-    {
-      code: `
-{
-  let a;
-}
-let a;
-      `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
         {
-          messageId: 'noShadow',
           data: {
             name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
+            shadowedColumn: 12,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-{
-  let a;
+function foo() {
+  var Object = 0;
 }
-var a;
       `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
+            name: 'Object',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
-{
-  let a;
+function foo() {
+  var top = 0;
 }
-function a() {}
       `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            name: 'top',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { globals: { top: 'readonly' } },
+      options: [{ builtinGlobals: true }],
     },
     {
-      code: `
-{
-  const a = 0;
-}
-const a = 1;
-      `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'var Object = 0;',
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 7,
+            name: 'Object',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
-      code: `
-{
-  const a = 0;
-}
-var a;
-      `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'var top = 0;',
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
+            name: 'top',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        globals: { top: 'readonly' },
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
-      code: `
-{
-  const a = 0;
-}
-function a() {}
-      `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'var Object = 0;',
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
+            name: 'Object',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
-      code: `
-function foo() {
-  let a;
-}
-let a;
-      `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'var top = 0;',
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
+            name: 'top',
           },
+          messageId: 'noShadowGlobal',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: {
+        globals: { top: 'readonly' },
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
     },
     {
       code: `
-function foo() {
-  let a;
+function foo(cb) {
+  (function (cb) {
+    cb(42);
+  })(cb);
 }
-var a;
       `,
-      options: [{ hoist: 'all' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
+            name: 'cb',
+            shadowedColumn: 14,
+            shadowedLine: 2,
           },
+          messageId: 'noShadow',
           type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
+  ],
+  valid: [
+    `
+var a = 3;
+function b(x) {
+  a++;
+  return x + a;
+}
+setTimeout(function () {
+  b(a);
+}, 0);
+    `,
+    `
+(function () {
+  var doSomething = function doSomething() {};
+  doSomething();
+})();
+    `,
+    `
+var arguments;
+function bar() {}
+    `,
     {
       code: `
-function foo() {
-  let a;
-}
-function a() {}
+var a = 3;
+var b = x => {
+  a++;
+  return x + a;
+};
+setTimeout(() => {
+  b(a);
+}, 0);
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+    },
+    {
+      code: 'class A {}',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo() {
-  var a;
+class A {
+  constructor() {
+    var a;
+  }
 }
-let a;
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-function foo() {
-  var a;
-}
-var a;
+(function () {
+  var A = class A {};
+})();
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-function foo() {
+{
   var a;
 }
-function a() {}
+var a;
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 5,
-            shadowedColumn: 10,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
+    }, // this case reports `no-redeclare`, not shadowing.
     {
       code: `
-function foo(a) {}
+{
+  let a;
+}
 let a;
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-function foo(a) {}
+{
+  let a;
+}
 var a;
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-function foo(a) {}
+{
+  let a;
+}
 function a() {}
       `,
-      options: [{ hoist: 'all' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 10,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function a() {
-  function a() {}
-})();
+{
+  const a = 0;
+}
+const a = 1;
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function a() {
-  class a {}
-})();
+{
+  const a = 0;
+}
+var a;
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function a() {
-  (function a() {});
-})();
+{
+  const a = 0;
+}
+function a() {}
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function a() {
-  (class a {});
-})();
+function foo() {
+  let a;
+}
+let a;
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = function (a) {};
-})();
+function foo() {
+  let a;
+}
+var a;
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = function () {
-    function a() {}
-  };
-})();
+function foo() {
+  let a;
+}
+function a() {}
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = function () {
-    class a {}
-  };
-})();
+function foo() {
+  var a;
+}
+let a;
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = function () {
-    (function a() {});
-  };
-})();
+function foo() {
+  var a;
+}
+var a;
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = function () {
-    (class a {});
-  };
-})();
+function foo() {
+  var a;
+}
+function a() {}
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-(function () {
-  var a = class {
-    constructor() {
-      class a {}
-    }
-  };
-})();
+function foo(a) {}
+let a;
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ hoist: 'never' }],
     },
     {
       code: `
-class A {
-  constructor() {
-    var A;
-  }
+function foo(a) {}
+var a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
+    },
+    {
+      code: `
+function foo(a) {}
+function a() {}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'never' }],
+    },
+    {
+      code: `
+{
+  let a;
 }
+let a;
       `,
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'A',
-            shadowedLine: 2,
-            shadowedColumn: 7,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-(function a() {
-  function a() {
-    function a() {}
-  }
-})();
+{
+  let a;
+}
+var a;
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'a',
-            shadowedLine: 3,
-            shadowedColumn: 12,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+{
+  const a = 0;
+}
+const a = 1;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+{
+  const a = 0;
+}
+var a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
-  var Object = 0;
+  let a;
 }
+let a;
       `,
-      options: [{ builtinGlobals: true }],
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'Object',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo() {
-  var top = 0;
+  let a;
 }
+var a;
       `,
-      options: [{ builtinGlobals: true }],
-      languageOptions: { globals: { top: 'readonly' } },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'top',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'var Object = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'Object',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      code: `
+function foo() {
+  var a;
+}
+let a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        globals: { top: 'readonly' },
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'top',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      code: `
+function foo() {
+  var a;
+}
+var a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
-      code: 'var Object = 0;',
-      options: [{ builtinGlobals: true }],
-      languageOptions: {
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'Object',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      code: `
+function foo(a) {}
+let a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+function foo(a) {}
+var a;
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    `
+function foo() {
+  var Object = 0;
+}
+    `,
+    {
+      code: `
+function foo() {
+  var top = 0;
+}
+      `,
     },
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      languageOptions: {
-        globals: { top: 'readonly' },
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'top',
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
@@ -1289,17 +1299,7 @@ function foo(cb) {
   })(cb);
 }
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'cb',
-            shadowedLine: 2,
-            shadowedColumn: 14,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ allow: ['cb'] }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-shadow/no-shadow.test.ts b/packages/eslint-plugin/tests/rules/no-shadow/no-shadow.test.ts
index 571beefd4804..8b68d4dd08f4 100644
--- a/packages/eslint-plugin/tests/rules/no-shadow/no-shadow.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-shadow/no-shadow.test.ts
@@ -6,107 +6,103 @@ import rule from '../../../src/rules/no-shadow';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-shadow TS tests', rule, {
-  valid: [
-    'function foo<T = (arg: any) => any>(arg: T) {}',
-    'function foo<T = ([arg]: [any]) => any>(arg: T) {}',
-    'function foo<T = ({ args }: { args: any }) => any>(arg: T) {}',
-    'function foo<T = (...args: any[]) => any>(fn: T, args: any[]) {}',
-    'function foo<T extends (...args: any[]) => any>(fn: T, args: any[]) {}',
-    'function foo<T extends (...args: any[]) => any>(fn: T, ...args: any[]) {}',
-    'function foo<T extends ([args]: any[]) => any>(fn: T, args: any[]) {}',
-    'function foo<T extends ([...args]: any[]) => any>(fn: T, args: any[]) {}',
-    'function foo<T extends ({ args }: { args: any }) => any>(fn: T, args: any) {}',
-    `
-function foo<T extends (id: string, ...args: any[]) => any>(
-  fn: T,
-  ...args: any[]
-) {}
-    `,
-    `
-type Args = 1;
-function foo<T extends (Args: any) => void>(arg: T) {}
-    `,
-    // nested conditional types
-    `
-export type ArrayInput<Func> = Func extends (arg0: Array<infer T>) => any
-  ? T[]
-  : Func extends (...args: infer T) => any
-    ? T
-    : never;
-    `,
-    `
-function foo() {
-  var Object = 0;
-}
-    `,
-    // this params
-    `
-function test(this: Foo) {
-  function test2(this: Bar) {}
-}
-    `,
-    // declaration merging
-    `
-class Foo {
-  prop = 1;
-}
-namespace Foo {
-  export const v = 2;
-}
-    `,
-    `
-function Foo() {}
-namespace Foo {
-  export const v = 2;
-}
-    `,
-    `
-class Foo {
-  prop = 1;
-}
-interface Foo {
-  prop2: string;
+  invalid: [
+    {
+      code: `
+type T = 1;
+{
+  type T = 2;
 }
-    `,
-    `
-import type { Foo } from 'bar';
-
-declare module 'bar' {
-  export interface Foo {
-    x: string;
-  }
+      `,
+      errors: [
+        {
+          data: {
+            name: 'T',
+            shadowedColumn: 6,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+    },
+    {
+      code: `
+type T = 1;
+function foo<T>(arg: T) {}
+      `,
+      errors: [
+        {
+          data: {
+            name: 'T',
+            shadowedColumn: 6,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+    },
+    {
+      code: `
+function foo<T>() {
+  return function <T>() {};
 }
-    `,
-    // type value shadowing
-    `
-const x = 1;
-type x = string;
-    `,
-    `
+      `,
+      errors: [
+        {
+          data: {
+            name: 'T',
+            shadowedColumn: 14,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+    },
+    {
+      code: `
+type T = string;
+function foo<T extends (arg: any) => void>(arg: T) {}
+      `,
+      errors: [
+        {
+          data: {
+            name: 'T',
+            shadowedColumn: 6,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+    },
+    {
+      code: `
 const x = 1;
 {
   type x = string;
 }
-    `,
-    {
-      code: `
-type Foo = 1;
       `,
-      options: [{ ignoreTypeValueShadow: true }],
-      languageOptions: {
-        globals: {
-          Foo: 'writable',
+      errors: [
+        {
+          data: {
+            name: 'x',
+            shadowedColumn: 7,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
         },
-      },
+      ],
+      options: [{ ignoreTypeValueShadow: false }],
     },
     {
       code: `
 type Foo = 1;
       `,
-      options: [
+      errors: [
         {
-          ignoreTypeValueShadow: false,
-          builtinGlobals: false,
+          data: {
+            name: 'Foo',
+          },
+          messageId: 'noShadowGlobal',
         },
       ],
       languageOptions: {
@@ -114,30 +110,41 @@ type Foo = 1;
           Foo: 'writable',
         },
       },
+      options: [
+        {
+          builtinGlobals: true,
+          ignoreTypeValueShadow: false,
+        },
+      ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2360
-    `
-enum Direction {
-  left = 'left',
-  right = 'right',
-}
-    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/2447
     {
       code: `
 const test = 1;
 type Fn = (test: string) => typeof test;
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
+      errors: [
+        {
+          data: {
+            name: 'test',
+            shadowedColumn: 7,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
     },
     {
       code: `
 type Fn = (Foo: string) => typeof Foo;
       `,
-      options: [
+      errors: [
         {
-          ignoreFunctionTypeParameterNameValueShadow: true,
-          builtinGlobals: false,
+          data: {
+            name: 'Foo',
+          },
+          messageId: 'noShadowGlobal',
         },
       ],
       languageOptions: {
@@ -145,7 +152,14 @@ type Fn = (Foo: string) => typeof Foo;
           Foo: 'writable',
         },
       },
+      options: [
+        {
+          builtinGlobals: true,
+          ignoreFunctionTypeParameterNameValueShadow: false,
+        },
+      ],
     },
+
     // https://github.com/typescript-eslint/typescript-eslint/issues/6098
     {
       code: `
@@ -155,7 +169,17 @@ interface Test {
   (arg: string): typeof arg;
 }
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
+      errors: [
+        {
+          data: {
+            name: 'arg',
+            shadowedColumn: 7,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
     },
     {
       code: `
@@ -165,401 +189,417 @@ interface Test {
   p1(arg: string): typeof arg;
 }
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
+      errors: [
+        {
+          data: {
+            name: 'arg',
+            shadowedColumn: 7,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+        },
+      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2724
     {
       code: `
-        declare global {
-          interface ArrayConstructor {}
-        }
-        export {};
+import type { foo } from './foo';
+function doThing(foo: number) {}
       `,
-      options: [{ builtinGlobals: true }],
+      errors: [
+        {
+          data: {
+            name: 'foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeValueShadow: false }],
     },
-    `
-      declare global {
-        const a: string;
-
-        namespace Foo {
-          const a: number;
-        }
-      }
-      export {};
-    `,
     {
       code: `
-        declare global {
-          type A = 'foo';
-
-          namespace Foo {
-            type A = 'bar';
-          }
-        }
-        export {};
+import { type foo } from './foo';
+function doThing(foo: number) {}
       `,
+      errors: [
+        {
+          data: {
+            name: 'foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       options: [{ ignoreTypeValueShadow: false }],
     },
     {
       code: `
-        declare global {
-          const foo: string;
-          type Fn = (foo: number) => void;
-        }
-        export {};
+import { foo } from './foo';
+function doThing(foo: number, bar: number) {}
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
+      errors: [
+        {
+          data: {
+            name: 'foo',
+            shadowedColumn: 10,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeValueShadow: true }],
     },
-    `
-export class Wrapper<Wrapped> {
-  private constructor(private readonly wrapped: Wrapped) {}
-
-  unwrap(): Wrapped {
-    return this.wrapped;
-  }
+    {
+      code: `
+interface Foo {}
 
-  static create<Wrapped>(wrapped: Wrapped) {
-    return new Wrapper<Wrapped>(wrapped);
+declare module 'bar' {
+  export interface Foo {
+    x: string;
   }
 }
-    `,
-    `
-function makeA() {
-  return class A<T> {
-    constructor(public value: T) {}
-
-    static make<T>(value: T) {
-      return new A<T>(value);
-    }
-  };
-}
-    `,
+      `,
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 11,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/3862
       code: `
-import type { foo } from './foo';
-type bar = number;
+import type { Foo } from 'bar';
 
-// 'foo' is already declared in the upper scope
-// 'bar' is fine
-function doThing(foo: number, bar: number) {}
+declare module 'baz' {
+  export interface Foo {
+    x: string;
+  }
+}
       `,
-      options: [{ ignoreTypeValueShadow: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-import { type foo } from './foo';
+import type { Foo } from 'bar';
 
-// 'foo' is already declared in the upper scope
-function doThing(foo: number) {}
+declare module 'bar' {
+  export type Foo = string;
+}
       `,
-      options: [{ ignoreTypeValueShadow: true }],
-    },
-    {
-      code: 'const a = [].find(a => a);',
-      options: [{ ignoreOnInitialization: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-const a = [].find(function (a) {
-  return a;
-});
+import type { Foo } from 'bar';
+
+declare module 'bar' {
+  interface Foo {
+    x: string;
+  }
+}
       `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const [a = [].find(a => true)] = dummy;',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const { a = [].find(a => true) } = dummy;',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'function func(a = [].find(a => true)) {}',
-      options: [{ ignoreOnInitialization: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-for (const a in [].find(a => true)) {
+import { type Foo } from 'bar';
+
+declare module 'baz' {
+  export interface Foo {
+    x: string;
+  }
 }
       `,
-      options: [{ ignoreOnInitialization: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-for (const a of [].find(a => true)) {
+import { type Foo } from 'bar';
+
+declare module 'bar' {
+  export type Foo = string;
 }
       `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: "const a = [].map(a => true).filter(a => a === 'b');",
-      options: [{ ignoreOnInitialization: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-const a = []
-  .map(a => true)
-  .filter(a => a === 'b')
-  .find(a => a === 'c');
+import { type Foo } from 'bar';
+
+declare module 'bar' {
+  interface Foo {
+    x: string;
+  }
+}
       `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const { a } = (({ a }) => ({ a }))();',
-      options: [{ ignoreOnInitialization: true }],
+      errors: [
+        {
+          data: {
+            name: 'Foo',
+            shadowedColumn: 15,
+            shadowedLine: 2,
+          },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-const person = people.find(item => {
-  const person = item.name;
-  return person === 'foo';
-});
-      `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var y = bar || foo(y => y);',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var y = bar && foo(y => y);',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var z = bar(foo(z => z));',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var z = boo(bar(foo(z => z)));',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: `
-var match = function (person) {
-  return person.name === 'foo';
-};
-const person = [].find(match);
-      `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const a = foo(x || (a => {}));',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const { a = 1 } = foo(a => {});',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: "const person = { ...people.find(person => person.firstName.startsWith('s')) };",
-      options: [{ ignoreOnInitialization: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
-    },
-    {
-      code: `
-const person = {
-  firstName: people
-    .filter(person => person.firstName.startsWith('s'))
-    .map(person => person.firstName)[0],
-};
-      `,
-      options: [{ ignoreOnInitialization: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
-    },
-    {
-      code: `
-() => {
-  const y = foo(y => y);
-};
-      `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const x = (x => x)();',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var y = bar || (y => y)();',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var y = bar && (y => y)();',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'var x = (x => x)((y => y)());',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: 'const { a = 1 } = (a => {})();',
-      options: [{ ignoreOnInitialization: true }],
-    },
-    {
-      code: `
-() => {
-  const y = (y => y)();
-};
-      `,
-      options: [{ ignoreOnInitialization: true }],
-    },
-    { code: 'const [x = y => y] = [].map(y => y);' },
-  ],
-  invalid: [
-    {
-      code: `
-type T = 1;
-{
-  type T = 2;
-}
+let x = foo((x, y) => {});
+let y;
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'T',
+            name: 'x',
+            shadowedColumn: 5,
             shadowedLine: 2,
-            shadowedColumn: 6,
           },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
         },
-      ],
-    },
-    {
-      code: `
-type T = 1;
-function foo<T>(arg: T) {}
-      `,
-      errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'T',
-            shadowedLine: 2,
-            shadowedColumn: 6,
+            name: 'y',
+            shadowedColumn: 5,
+            shadowedLine: 3,
           },
+          messageId: 'noShadow',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ hoist: 'all' }],
     },
     {
       code: `
-function foo<T>() {
-  return function <T>() {};
-}
+function foo<T extends (...args: any[]) => any>(fn: T, args: any[]) {}
       `,
       errors: [
         {
-          messageId: 'noShadow',
           data: {
-            name: 'T',
+            name: 'args',
+            shadowedColumn: 5,
             shadowedLine: 2,
-            shadowedColumn: 14,
           },
+          messageId: 'noShadowGlobal',
         },
       ],
-    },
-    {
-      code: `
-type T = string;
-function foo<T extends (arg: any) => void>(arg: T) {}
-      `,
-      errors: [
+      languageOptions: {
+        globals: {
+          args: 'writable',
+        },
+      },
+      options: [
         {
-          messageId: 'noShadow',
-          data: {
-            name: 'T',
-            shadowedLine: 2,
-            shadowedColumn: 6,
-          },
+          builtinGlobals: true,
+          ignoreTypeValueShadow: false,
         },
       ],
     },
-    {
-      code: `
+  ],
+  valid: [
+    'function foo<T = (arg: any) => any>(arg: T) {}',
+    'function foo<T = ([arg]: [any]) => any>(arg: T) {}',
+    'function foo<T = ({ args }: { args: any }) => any>(arg: T) {}',
+    'function foo<T = (...args: any[]) => any>(fn: T, args: any[]) {}',
+    'function foo<T extends (...args: any[]) => any>(fn: T, args: any[]) {}',
+    'function foo<T extends (...args: any[]) => any>(fn: T, ...args: any[]) {}',
+    'function foo<T extends ([args]: any[]) => any>(fn: T, args: any[]) {}',
+    'function foo<T extends ([...args]: any[]) => any>(fn: T, args: any[]) {}',
+    'function foo<T extends ({ args }: { args: any }) => any>(fn: T, args: any) {}',
+    `
+function foo<T extends (id: string, ...args: any[]) => any>(
+  fn: T,
+  ...args: any[]
+) {}
+    `,
+    `
+type Args = 1;
+function foo<T extends (Args: any) => void>(arg: T) {}
+    `,
+    // nested conditional types
+    `
+export type ArrayInput<Func> = Func extends (arg0: Array<infer T>) => any
+  ? T[]
+  : Func extends (...args: infer T) => any
+    ? T
+    : never;
+    `,
+    `
+function foo() {
+  var Object = 0;
+}
+    `,
+    // this params
+    `
+function test(this: Foo) {
+  function test2(this: Bar) {}
+}
+    `,
+    // declaration merging
+    `
+class Foo {
+  prop = 1;
+}
+namespace Foo {
+  export const v = 2;
+}
+    `,
+    `
+function Foo() {}
+namespace Foo {
+  export const v = 2;
+}
+    `,
+    `
+class Foo {
+  prop = 1;
+}
+interface Foo {
+  prop2: string;
+}
+    `,
+    `
+import type { Foo } from 'bar';
+
+declare module 'bar' {
+  export interface Foo {
+    x: string;
+  }
+}
+    `,
+    // type value shadowing
+    `
+const x = 1;
+type x = string;
+    `,
+    `
 const x = 1;
 {
   type x = string;
 }
+    `,
+    {
+      code: `
+type Foo = 1;
       `,
-      options: [{ ignoreTypeValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 7,
-          },
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
         },
-      ],
+      },
+      options: [{ ignoreTypeValueShadow: true }],
     },
     {
       code: `
 type Foo = 1;
       `,
-      options: [
-        {
-          ignoreTypeValueShadow: false,
-          builtinGlobals: true,
-        },
-      ],
       languageOptions: {
         globals: {
           Foo: 'writable',
         },
       },
-      errors: [
+      options: [
         {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'Foo',
-          },
+          builtinGlobals: false,
+          ignoreTypeValueShadow: false,
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2447
-    {
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2360
+    `
+enum Direction {
+  left = 'left',
+  right = 'right',
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2447
+    {
       code: `
 const test = 1;
 type Fn = (test: string) => typeof test;
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'test',
-            shadowedLine: 2,
-            shadowedColumn: 7,
-          },
-        },
-      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
     },
     {
       code: `
 type Fn = (Foo: string) => typeof Foo;
       `,
-      options: [
-        {
-          ignoreFunctionTypeParameterNameValueShadow: false,
-          builtinGlobals: true,
-        },
-      ],
       languageOptions: {
         globals: {
           Foo: 'writable',
         },
       },
-      errors: [
+      options: [
         {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'Foo',
-          },
+          builtinGlobals: false,
+          ignoreFunctionTypeParameterNameValueShadow: true,
         },
       ],
     },
-
     // https://github.com/typescript-eslint/typescript-eslint/issues/6098
     {
       code: `
@@ -569,17 +609,7 @@ interface Test {
   (arg: string): typeof arg;
 }
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'arg',
-            shadowedLine: 2,
-            shadowedColumn: 7,
-          },
-        },
-      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
     },
     {
       code: `
@@ -589,275 +619,245 @@ interface Test {
   p1(arg: string): typeof arg;
 }
       `,
-      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'arg',
-            shadowedLine: 2,
-            shadowedColumn: 7,
-          },
-        },
-      ],
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2724
     {
       code: `
-import type { foo } from './foo';
-function doThing(foo: number) {}
+        declare global {
+          interface ArrayConstructor {}
+        }
+        export {};
       `,
-      options: [{ ignoreTypeValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ builtinGlobals: true }],
     },
+    `
+      declare global {
+        const a: string;
+
+        namespace Foo {
+          const a: number;
+        }
+      }
+      export {};
+    `,
     {
       code: `
-import { type foo } from './foo';
-function doThing(foo: number) {}
+        declare global {
+          type A = 'foo';
+
+          namespace Foo {
+            type A = 'bar';
+          }
+        }
+        export {};
       `,
       options: [{ ignoreTypeValueShadow: false }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-import { foo } from './foo';
+        declare global {
+          const foo: string;
+          type Fn = (foo: number) => void;
+        }
+        export {};
+      `,
+      options: [{ ignoreFunctionTypeParameterNameValueShadow: false }],
+    },
+    `
+export class Wrapper<Wrapped> {
+  private constructor(private readonly wrapped: Wrapped) {}
+
+  unwrap(): Wrapped {
+    return this.wrapped;
+  }
+
+  static create<Wrapped>(wrapped: Wrapped) {
+    return new Wrapper<Wrapped>(wrapped);
+  }
+}
+    `,
+    `
+function makeA() {
+  return class A<T> {
+    constructor(public value: T) {}
+
+    static make<T>(value: T) {
+      return new A<T>(value);
+    }
+  };
+}
+    `,
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/3862
+      code: `
+import type { foo } from './foo';
+type bar = number;
+
+// 'foo' is already declared in the upper scope
+// 'bar' is fine
 function doThing(foo: number, bar: number) {}
       `,
       options: [{ ignoreTypeValueShadow: true }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'foo',
-            shadowedLine: 2,
-            shadowedColumn: 10,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-interface Foo {}
+import { type foo } from './foo';
 
-declare module 'bar' {
-  export interface Foo {
-    x: string;
-  }
-}
+// 'foo' is already declared in the upper scope
+function doThing(foo: number) {}
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 11,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreTypeValueShadow: true }],
+    },
+    {
+      code: 'const a = [].find(a => a);',
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import type { Foo } from 'bar';
-
-declare module 'baz' {
-  export interface Foo {
-    x: string;
-  }
-}
+const a = [].find(function (a) {
+  return a;
+});
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const [a = [].find(a => true)] = dummy;',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const { a = [].find(a => true) } = dummy;',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'function func(a = [].find(a => true)) {}',
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import type { Foo } from 'bar';
-
-declare module 'bar' {
-  export type Foo = string;
+for (const a in [].find(a => true)) {
 }
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import type { Foo } from 'bar';
-
-declare module 'bar' {
-  interface Foo {
-    x: string;
-  }
+for (const a of [].find(a => true)) {
 }
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: "const a = [].map(a => true).filter(a => a === 'b');",
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import { type Foo } from 'bar';
-
-declare module 'baz' {
-  export interface Foo {
-    x: string;
-  }
-}
+const a = []
+  .map(a => true)
+  .filter(a => a === 'b')
+  .find(a => a === 'c');
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const { a } = (({ a }) => ({ a }))();',
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import { type Foo } from 'bar';
-
-declare module 'bar' {
-  export type Foo = string;
-}
+const person = people.find(item => {
+  const person = item.name;
+  return person === 'foo';
+});
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var y = bar || foo(y => y);',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var y = bar && foo(y => y);',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var z = bar(foo(z => z));',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var z = boo(bar(foo(z => z)));',
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-import { type Foo } from 'bar';
-
-declare module 'bar' {
-  interface Foo {
-    x: string;
-  }
-}
+var match = function (person) {
+  return person.name === 'foo';
+};
+const person = [].find(match);
       `,
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'Foo',
-            shadowedLine: 2,
-            shadowedColumn: 15,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const a = foo(x || (a => {}));',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const { a = 1 } = foo(a => {});',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: "const person = { ...people.find(person => person.firstName.startsWith('s')) };",
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-let x = foo((x, y) => {});
-let y;
+const person = {
+  firstName: people
+    .filter(person => person.firstName.startsWith('s'))
+    .map(person => person.firstName)[0],
+};
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: [{ hoist: 'all' }],
-      errors: [
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'x',
-            shadowedLine: 2,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-        {
-          messageId: 'noShadow',
-          data: {
-            name: 'y',
-            shadowedLine: 3,
-            shadowedColumn: 5,
-          },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
+      options: [{ ignoreOnInitialization: true }],
     },
     {
       code: `
-function foo<T extends (...args: any[]) => any>(fn: T, args: any[]) {}
+() => {
+  const y = foo(y => y);
+};
       `,
-      options: [
-        {
-          ignoreTypeValueShadow: false,
-          builtinGlobals: true,
-        },
-      ],
-      languageOptions: {
-        globals: {
-          args: 'writable',
-        },
-      },
-      errors: [
-        {
-          messageId: 'noShadowGlobal',
-          data: {
-            name: 'args',
-            shadowedLine: 2,
-            shadowedColumn: 5,
-          },
-        },
-      ],
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const x = (x => x)();',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var y = bar || (y => y)();',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var y = bar && (y => y)();',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'var x = (x => x)((y => y)());',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: 'const { a = 1 } = (a => {})();',
+      options: [{ ignoreOnInitialization: true }],
+    },
+    {
+      code: `
+() => {
+  const y = (y => y)();
+};
+      `,
+      options: [{ ignoreOnInitialization: true }],
     },
+    { code: 'const [x = y => y] = [].map(y => y);' },
   ],
 });
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 6de32ec853f8..4d0a3ef4951c 100644
--- a/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
@@ -19,47 +19,15 @@ const arrayDestructureError = {
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-this-alias', rule, {
-  valid: [
-    'const self = foo(this);',
-    {
-      code: `
-const { props, state } = this;
-const { length } = this;
-const { length, toString } = this;
-const [foo] = this;
-const [foo, bar] = this;
-      `,
-      options: [
-        {
-          allowDestructuring: true,
-        },
-      ],
-    },
-    {
-      code: 'const self = this;',
-      options: [
-        {
-          allowedNames: ['self'],
-        },
-      ],
-    },
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/281
-    `
-declare module 'foo' {
-  declare const aVar: string;
-}
-    `,
-  ],
-
   invalid: [
     {
       code: 'const self = this;',
+      errors: [idError],
       options: [
         {
           allowDestructuring: true,
         },
       ],
-      errors: [idError],
     },
     {
       code: 'const self = this;',
@@ -74,12 +42,12 @@ that = this;
     },
     {
       code: 'const { props, state } = this;',
+      errors: [destructureError],
       options: [
         {
           allowDestructuring: false,
         },
       ],
-      errors: [destructureError],
     },
     {
       code: `
@@ -115,11 +83,6 @@ class TestClass {
   }
 }
       `,
-      options: [
-        {
-          allowDestructuring: false,
-        },
-      ],
       errors: [
         idError,
         idError,
@@ -129,6 +92,43 @@ class TestClass {
         arrayDestructureError,
         arrayDestructureError,
       ],
+      options: [
+        {
+          allowDestructuring: false,
+        },
+      ],
     },
   ],
+
+  valid: [
+    'const self = foo(this);',
+    {
+      code: `
+const { props, state } = this;
+const { length } = this;
+const { length, toString } = this;
+const [foo] = this;
+const [foo, bar] = this;
+      `,
+      options: [
+        {
+          allowDestructuring: true,
+        },
+      ],
+    },
+    {
+      code: 'const self = this;',
+      options: [
+        {
+          allowedNames: ['self'],
+        },
+      ],
+    },
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/281
+    `
+declare module 'foo' {
+  declare const aVar: string;
+}
+    `,
+  ],
 });
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 500b9b30d7bc..a7d7de86c692 100644
--- a/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
@@ -5,2925 +5,3279 @@ import rule from '../../src/rules/no-type-alias';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-type-alias', rule, {
-  valid: [
-    {
-      code: "type A = 'a' & ('b' | 'c');",
-      options: [{ allowAliases: 'always' }],
-    },
+  invalid: [
     {
       code: "type Foo = 'a';",
-      options: [{ allowAliases: 'always' }],
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'always' }],
+      code: "type Foo = 'a';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: "type Foo = typeof import('foo');",
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
       code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'in-unions' }],
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'always' }],
+      code: "type Foo = 'a' | typeof import('foo');",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: "type Foo = 'a' | 'b';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'in-unions' }],
+      code: "type Foo = 'a' | 'b';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'always' }],
+      code: "type Foo = 'a' | 'b';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: "type Foo = 'a' | 'b';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'in-intersections' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'always' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | (2 & 3);',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | (2 & 3);',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = true;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = true | false;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = true | false;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = true | false;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = true & false;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = true & false;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = true & false;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      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' }],
-    },
-    {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = string | readonly string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = () => void;',
-      options: [{ allowCallbacks: 'always' }],
-    },
-    {
-      code: 'type Foo = () => void | string;',
-      options: [{ allowCallbacks: 'always' }],
-    },
-    {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'always' }],
-    },
-    {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'always' }],
-    },
-    {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'always' }],
-    },
-    {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'in-intersections' }],
-    },
-    {
-      code: `
-type Foo<T> = {
-  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];
-    };
-      `,
-      options: [{ allowMappedTypes: 'always' }],
-    },
-    {
-      code: `
-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];
-    };
-      `,
-      options: [{ allowMappedTypes: 'in-unions' }],
-    },
-    {
-      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];
-};
-      `,
-      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
-    },
-    {
-      code: `
-type Foo<T> = {
-  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;
-      `,
-      options: [
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
         {
-          allowAliases: 'in-unions-and-intersections',
-          allowCallbacks: 'always',
-          allowLiterals: 'in-unions-and-intersections',
-          allowMappedTypes: 'in-unions-and-intersections',
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = typeof bar;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = typeof import('foo');",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: `
-const WithAKey = { AKey: true };
-type KeyNames = keyof typeof SCALARS;
-      `,
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = typeof bar | typeof baz;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: "type Foo = typeof bar | typeof import('foo');",
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = keyof [string];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = [string] | [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = [string] & [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = ([string] & [number, number]) | [number, number, number];',
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = readonly [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = readonly [string] | readonly [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = readonly [string] | [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = [string] & readonly [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = ([string] & [number, number]) | readonly [number, number, number];',
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = keyof [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = keyof [string] | keyof [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
-    },
-    {
-      code: 'type Foo = keyof [string] | [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = [string] & keyof [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = ([string] & [number, number]) | keyof [number, number, number];',
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type MyType<T> = T extends number ? number : null;',
-      options: [{ allowConditionalTypes: 'always' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = new (bar: number) => string | null;',
-      options: [{ allowConstructors: 'always' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = Record<string, number>;',
-      options: [{ allowGenerics: 'always' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
-  ],
-  invalid: [
     {
-      code: "type Foo = 'a';",
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a';",
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: "type Foo = typeof import('foo');",
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b';",
+      errors: [
+        {
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
           column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | typeof import('foo');",
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
+        },
+      ],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      errors: [
+        {
           column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
         {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
+          column: 24,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      errors: [
+        {
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
           column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
+          column: 24,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      errors: [
+        {
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
           column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 24,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 24,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
-    },
-    {
-      code: "type Foo = 'a' | 'b';",
       options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
         },
       ],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
+          column: 19,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 19,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 19,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 19,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 19,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      errors: [
         {
+          column: 19,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 25,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'in-intersections' }],
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
+      ],
+      options: [
         {
-          messageId: 'noCompositionAlias',
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-intersections',
+        },
+      ],
+    },
+    {
+      code: 'type Foo = string;',
+      errors: [
+        {
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'aliases',
           },
           line: 1,
-          column: 24,
+          messageId: 'noTypeAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [
+      code: 'type Foo = string;',
+      errors: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
+    },
+    {
+      code: 'type Foo = string;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = string;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'aliases',
           },
           line: 1,
-          column: 18,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'aliases',
           },
           line: 1,
-          column: 24,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
         },
       ],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 21,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 32,
           data: {
+            compositionType: 'union',
             typeName: 'Aliases',
-            compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 19,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 33,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 25,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
+      code: 'type Foo = string | (string[] & number);',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
       options: [
         {
           allowAliases: 'in-intersections',
-          allowLiterals: 'in-intersections',
+          allowLiterals: 'in-unions',
         },
       ],
+    },
+    {
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noTypeAlias',
         },
       ],
     },
     {
-      code: 'type Foo = string;',
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
             alias: 'aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'never' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
             alias: 'aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'in-unions' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
             alias: 'aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
             alias: 'aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 1,
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+    },
+    {
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
           column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | string[];',
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 21,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 12,
-        },
-        {
+          line: 3,
           messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 21,
         },
       ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'never' }],
+      code: `
+interface Bar {}
+type Foo = Bar & {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 21,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: `
+interface Bar {}
+type Foo = Bar & {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 21,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar & {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
+            compositionType: 'intersection',
             typeName: 'Aliases',
-            compositionType: 'union',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 21,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
-        },
-      ],
+      code: `
+interface Bar {}
+type Foo = Bar & {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 12,
-        },
-        {
+          line: 3,
           messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 21,
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: `
+interface Bar {}
+type Foo = Bar & {};
+      `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
-          line: 1,
-          column: 12,
+          line: 3,
+          messageId: 'noCompositionAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = () => void;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'callbacks',
           },
           line: 1,
-          column: 21,
+          messageId: 'noTypeAlias',
         },
+      ],
+    },
+    {
+      code: 'type Foo = () => void;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'callbacks',
           },
           line: 1,
-          column: 32,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowCallbacks: 'never' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: 'type Foo = {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 21,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowLiterals: 'never' }],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 32,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 21,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 32,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: 'type Foo = {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-intersections', allowLiterals: 'never' }],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 21,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 32,
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+      options: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 21,
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-intersections',
         },
+      ],
+    },
+    {
+      code: 'type Foo = {};',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            alias: 'literals',
           },
           line: 1,
-          column: 32,
+          messageId: 'noTypeAlias',
         },
       ],
-    },
-    {
-      code: 'type Foo = string | string[] | number;',
       options: [
         {
           allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          allowLiterals: 'in-unions-and-intersections',
         },
       ],
+    },
+    {
+      code: 'type Foo = {} | {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
           column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 21,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 32,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
+      code: 'type Foo = {} | {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 12,
-        },
-        {
           messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 22,
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
+            compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: 'type Foo = {} | {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 12,
-        },
-        {
           messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 22,
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
+            compositionType: 'union',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = {} & {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
           column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 22,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: 'type Foo = {} & {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
           column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 22,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = {} & {};',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 22,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 17,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
+      code: "type Foo = (string & {}) | 'a' | 1;",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 13,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 22,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 33,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: "type Foo = (string & {}) | 'a' | 1;",
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 22,
           data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Literals',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = string | (string[] & number);',
-      options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          column: 28,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 34,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
         },
       ],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar;
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
       `,
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 15,
           data: {
-            alias: 'aliases',
+            alias: 'mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noTypeAlias',
         },
       ],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar;
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'never' }],
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 15,
           data: {
-            alias: 'aliases',
+            alias: 'mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar;
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 15,
           data: {
-            alias: 'aliases',
+            alias: 'mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar;
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 15,
           data: {
-            alias: 'aliases',
+            alias: 'mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar;
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 15,
           data: {
-            alias: 'aliases',
+            alias: 'mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar | {};
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
       `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
           line: 3,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Literals',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 6,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar | {};
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
       `,
-      options: [{ allowAliases: 'never' }],
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
           line: 3,
-          column: 12,
-        },
-        {
           messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Literals',
-            compositionType: 'union',
-          },
-          line: 3,
-          column: 18,
         },
-      ],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
-      options: [{ allowAliases: 'in-unions' }],
-      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Literals',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 6,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar | {};
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
       `,
-      options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Aliases',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
           line: 3,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Literals',
             compositionType: 'union',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 6,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar | {};
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+} & {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
       errors: [
         {
+          column: 15,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 2,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
           data: {
-            typeName: 'Literals',
-            compositionType: 'union',
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 4,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar & {};
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+} & {
+  readonly [P in keyof T]: T[P];
+};
       `,
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 15,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Literals',
             compositionType: 'intersection',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 4,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
       code: `
-interface Bar {}
-type Foo = Bar & {};
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+} & {
+  readonly [P in keyof T]: T[P];
+};
       `,
-      options: [{ allowAliases: 'never' }],
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 15,
           data: {
-            typeName: 'Aliases',
             compositionType: 'intersection',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 12,
+          line: 2,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 5,
           data: {
-            typeName: 'Literals',
             compositionType: 'intersection',
+            typeName: 'Mapped types',
           },
-          line: 3,
-          column: 18,
+          line: 4,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
-      options: [{ allowAliases: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 3,
-          column: 12,
-        },
+      // https://github.com/typescript-eslint/typescript-eslint/issues/270
+      code: "export type ButtonProps = JSX.IntrinsicElements['button'];",
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 27,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            alias: 'aliases',
           },
-          line: 3,
-          column: 18,
+          line: 1,
+          messageId: 'noTypeAlias',
         },
       ],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = [number] | [number, number];',
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
-          line: 3,
-          column: 18,
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'never' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = [number] & [number, number];',
       errors: [
         {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
           messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
           data: {
-            typeName: 'Literals',
             compositionType: 'intersection',
+            typeName: 'Tuple Types',
           },
-          line: 3,
-          column: 18,
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = () => void;',
+      code: 'type Foo = [number] | [number, number];',
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'callbacks',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = () => void;',
-      options: [{ allowCallbacks: 'never' }],
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 23,
           data: {
-            alias: 'callbacks',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
+      code: 'type Foo = [number];',
       errors: [
         {
           messageId: 'noTypeAlias',
-          data: {
-            alias: 'literals',
-          },
-          line: 1,
-          column: 12,
         },
       ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'never' }],
+      code: 'type Foo = [number];',
       errors: [
         {
           messageId: 'noTypeAlias',
-          data: {
-            alias: 'literals',
-          },
-          line: 1,
-          column: 12,
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: 'type Foo = [number];',
       errors: [
         {
           messageId: 'noTypeAlias',
-          data: {
-            alias: 'literals',
-          },
-          line: 1,
-          column: 12,
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = readonly [number] | keyof [number, number];',
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 32,
           data: {
-            alias: 'literals',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'never' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = keyof [number] & [number, number];',
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'never', allowAliases: 'in-intersections' }],
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 29,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [
+      code: 'type Foo = [number] | readonly [number, number];',
+      errors: [
         {
-          allowLiterals: 'in-unions',
-          allowAliases: 'in-intersections',
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 23,
           data: {
-            alias: 'literals',
+            compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [
-        {
-          allowLiterals: 'in-intersections',
-          allowAliases: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = readonly [number];',
       errors: [
         {
           messageId: 'noTypeAlias',
-          data: {
-            alias: 'literals',
-          },
-          line: 1,
-          column: 12,
         },
       ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [
+      code: 'type Foo = keyof [number];',
+      errors: [
         {
-          allowLiterals: 'in-unions-and-intersections',
-          allowAliases: 'in-intersections',
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = readonly [number];',
       errors: [
         {
           messageId: 'noTypeAlias',
-          data: {
-            alias: 'literals',
-          },
-          line: 1,
-          column: 12,
         },
       ],
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = {} | {};',
+      code: 'type Foo = new (bar: number) => string | null;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Literals',
-            compositionType: 'union',
-          },
-          line: 1,
           column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
           data: {
-            typeName: 'Literals',
-            compositionType: 'union',
+            alias: 'constructors',
           },
           line: 1,
-          column: 17,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowConstructors: 'never' }],
     },
     {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'never' }],
+      code: 'type MyType<T> = T extends number ? number : null;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Literals',
-            compositionType: 'union',
+            alias: 'conditional types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+    },
+    {
+      code: 'type MyType<T> = T extends number ? number : null;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 18,
           data: {
-            typeName: 'Literals',
-            compositionType: 'union',
+            alias: 'conditional types',
           },
           line: 1,
-          column: 17,
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowConditionalTypes: 'never' }],
     },
     {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'in-intersections' }],
+      // unique symbol is not allowed in this context
+      code: 'type Foo = keyof [string] | unique symbol;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Literals',
             compositionType: 'union',
+            typeName: 'Tuple Types',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 29,
           data: {
-            typeName: 'Literals',
             compositionType: 'union',
+            typeName: 'Unhandled',
           },
           line: 1,
-          column: 17,
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: 'type Foo = {} & {};',
+      code: 'type Foo = Record<string, number>;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            alias: 'generics',
           },
           line: 1,
-          column: 12,
+          messageId: 'noTypeAlias',
         },
+      ],
+    },
+    {
+      code: 'type Foo = `foo-${number}`;',
+      errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            alias: 'aliases',
           },
           line: 1,
-          column: 17,
+          messageId: 'noTypeAlias',
         },
       ],
     },
     {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'never' }],
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 28,
           data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 17,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
       errors: [
         {
-          messageId: 'noCompositionAlias',
+          column: 12,
           data: {
-            typeName: 'Literals',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 12,
+          messageId: 'noCompositionAlias',
         },
         {
-          messageId: 'noCompositionAlias',
+          column: 28,
           data: {
-            typeName: 'Literals',
             compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          column: 17,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
+    },
+  ],
+  valid: [
+    {
+      code: "type A = 'a' & ('b' | 'c');",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a';",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b';",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b';",
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' & 'b' & 'c';",
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = 1;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 | 2;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 | 2;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 | 2;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = 1 | (2 & 3);',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = 1 | (2 & 3);',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = true;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = (string & {}) | 'a' | 1;",
-      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 13,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 22,
-        },
-      ],
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = (string & {}) | 'a' | 1;",
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
-        },
-      ],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Literals',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 22,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 28,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 34,
-        },
-      ],
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
       code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
+interface Bar {}
+type Foo = Bar | string;
       `,
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'mapped types',
-          },
-          line: 2,
-          column: 15,
-        },
-      ],
+      options: [{ allowAliases: 'always' }],
     },
     {
       code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
+interface Bar {}
+type Foo = Bar | string;
       `,
-      options: [{ allowMappedTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'mapped types',
-          },
-          line: 2,
-          column: 15,
-        },
-      ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
       code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
+interface Bar {}
+type Foo = Bar | string;
       `,
-      options: [{ allowMappedTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'mapped types',
-          },
-          line: 2,
-          column: 15,
-        },
-      ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
       code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
+interface Bar {}
+type Foo = Bar & string;
       `,
-      options: [{ allowMappedTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'mapped types',
-          },
-          line: 2,
-          column: 15,
-        },
-      ],
+      options: [{ allowAliases: 'always' }],
     },
     {
       code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
+interface Bar {}
+type Foo = Bar & string;
       `,
-      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'mapped types',
-          },
-          line: 2,
-          column: 15,
-        },
-      ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: `
+interface Bar {}
+type Foo = Bar & string;
+      `,
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | readonly string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = () => void;',
+      options: [{ allowCallbacks: 'always' }],
+    },
+    {
+      code: 'type Foo = () => void | string;',
+      options: [{ allowCallbacks: 'always' }],
+    },
+    {
+      code: 'type Foo = {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
@@ -2935,26 +3289,7 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 3,
-          column: 5,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 6,
-          column: 5,
-        },
-      ],
+      options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
@@ -2966,27 +3301,7 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      options: [{ allowMappedTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 3,
-          column: 5,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 6,
-          column: 5,
-        },
-      ],
+      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
@@ -2998,27 +3313,7 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      options: [{ allowMappedTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 3,
-          column: 5,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'union',
-          },
-          line: 6,
-          column: 5,
-        },
-      ],
+      options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
       code: `
@@ -3028,26 +3323,7 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 2,
-          column: 15,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 4,
-          column: 5,
-        },
-      ],
+      options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
@@ -3057,27 +3333,7 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 2,
-          column: 15,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 4,
-          column: 5,
-        },
-      ],
+      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
@@ -3087,378 +3343,122 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 2,
-          column: 15,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Mapped types',
-            compositionType: 'intersection',
-          },
-          line: 4,
-          column: 5,
-        },
-      ],
-    },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/270
-      code: "export type ButtonProps = JSX.IntrinsicElements['button'];",
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          column: 27,
-        },
-      ],
+      options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = [number] | [number, number];',
-      options: [{ allowTupleTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
+      code: `
+export type ClassValue =
+  | string
+  | number
+  | ClassDictionary
+  | ClassArray
+  | undefined
+  | null
+  | false;
+      `,
+      options: [
         {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 23,
+          allowAliases: 'in-unions-and-intersections',
+          allowCallbacks: 'always',
+          allowLiterals: 'in-unions-and-intersections',
+          allowMappedTypes: 'in-unions-and-intersections',
         },
       ],
     },
     {
-      code: 'type Foo = [number] & [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 23,
-        },
-      ],
+      code: 'type Foo = typeof bar;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = [number] | [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 23,
-        },
-      ],
+      code: "type Foo = typeof import('foo');",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = [number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: `
+const WithAKey = { AKey: true };
+type KeyNames = keyof typeof SCALARS;
+      `,
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = [number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: 'type Foo = typeof bar | typeof baz;',
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = [number];',
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: "type Foo = typeof bar | typeof import('foo');",
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = readonly [number] | keyof [number, number];',
-      options: [{ allowTupleTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 32,
-        },
-      ],
+      code: 'type Foo = keyof [string];',
+      options: [{ allowTupleTypes: 'always' }],
     },
     {
-      code: 'type Foo = keyof [number] & [number, number];',
+      code: 'type Foo = [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = [string] | [number, number];',
       options: [{ allowTupleTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 29,
-        },
-      ],
     },
     {
-      code: 'type Foo = [number] | readonly [number, number];',
+      code: 'type Foo = [string] & [number, number];',
       options: [{ allowTupleTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 23,
-        },
-      ],
     },
     {
-      code: 'type Foo = readonly [number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: 'type Foo = ([string] & [number, number]) | [number, number, number];',
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = keyof [number];',
+      code: 'type Foo = readonly [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = readonly [string] | readonly [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = readonly [string] | [number, number];',
       options: [{ allowTupleTypes: 'in-unions' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
     },
     {
-      code: 'type Foo = readonly [number];',
+      code: 'type Foo = [string] & readonly [number, number];',
+      options: [{ allowTupleTypes: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = ([string] & [number, number]) | readonly [number, number, number];',
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
     },
     {
-      code: 'type Foo = new (bar: number) => string | null;',
-      options: [{ allowConstructors: 'never' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'constructors',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      code: 'type Foo = keyof [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
     },
     {
-      code: 'type MyType<T> = T extends number ? number : null;',
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'conditional types',
-          },
-          line: 1,
-          column: 18,
-        },
-      ],
+      code: 'type Foo = keyof [string] | keyof [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
     },
     {
-      code: 'type MyType<T> = T extends number ? number : null;',
-      options: [{ allowConditionalTypes: 'never' }],
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'conditional types',
-          },
-          line: 1,
-          column: 18,
-        },
-      ],
+      code: 'type Foo = keyof [string] | [number, number];',
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      // unique symbol is not allowed in this context
-      code: 'type Foo = keyof [string] | unique symbol;',
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            compositionType: 'union',
-            typeName: 'Unhandled',
-          },
-          line: 1,
-          column: 29,
-        },
-      ],
+      code: 'type Foo = [string] & keyof [number, number];',
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = Record<string, number>;',
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'generics',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      code: 'type Foo = ([string] & [number, number]) | keyof [number, number, number];',
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = `foo-${number}`;',
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          column: 12,
-        },
-      ],
+      code: 'type MyType<T> = T extends number ? number : null;',
+      options: [{ allowConditionalTypes: 'always' }],
     },
     {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'union',
-          },
-          line: 1,
-          column: 28,
-        },
-      ],
+      code: 'type Foo = new (bar: number) => string | null;',
+      options: [{ allowConstructors: 'always' }],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'never' }],
-      errors: [
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 12,
-        },
-        {
-          messageId: 'noCompositionAlias',
-          data: {
-            typeName: 'Aliases',
-            compositionType: 'intersection',
-          },
-          line: 1,
-          column: 28,
-        },
-      ],
+      code: 'type Foo = Record<string, number>;',
+      options: [{ allowGenerics: 'always' }],
     },
   ],
 });
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 dbac9d751fe9..a2526457b44f 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
@@ -7,76 +7,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
-  valid: [
-    `
-      declare const varAny: any;
-      varAny === true;
-    `,
-    `
-      declare const varAny: any;
-      varAny == false;
-    `,
-    `
-      declare const varString: string;
-      varString === false;
-    `,
-    `
-      declare const varString: string;
-      varString === true;
-    `,
-    `
-      declare const varObject: {};
-      varObject === true;
-    `,
-    `
-      declare const varObject: {};
-      varObject == false;
-    `,
-    `
-      declare const varNullOrUndefined: null | undefined;
-      varNullOrUndefined === false;
-    `,
-    `
-      declare const varBooleanOrString: boolean | string;
-      varBooleanOrString === false;
-    `,
-    `
-      declare const varBooleanOrString: boolean | string;
-      varBooleanOrString == true;
-    `,
-    `
-      declare const varTrueOrStringOrUndefined: true | string | undefined;
-      varTrueOrStringOrUndefined == true;
-    `,
-    `
-      declare const varBooleanOrUndefined: boolean | undefined;
-      varBooleanOrUndefined === true;
-    `,
-    {
-      code: `
-        declare const varBooleanOrUndefined: boolean | undefined;
-        varBooleanOrUndefined === true;
-      `,
-      options: [{ allowComparingNullableBooleansToFalse: false }],
-    },
-    {
-      code: `
-        declare const varBooleanOrUndefined: boolean | undefined;
-        varBooleanOrUndefined === false;
-      `,
-      options: [{ allowComparingNullableBooleansToTrue: false }],
-    },
-    "'false' === true;",
-    "'true' === false;",
-  ],
-
   invalid: [
     {
       code: 'true === true;',
@@ -136,12 +73,12 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         if (varTrueOrUndefined === true) {
         }
       `,
-      options: [{ allowComparingNullableBooleansToTrue: false }],
       errors: [
         {
           messageId: 'comparingNullableToTrueDirect',
         },
       ],
+      options: [{ allowComparingNullableBooleansToTrue: false }],
       output: `
         declare const varTrueOrUndefined: true | undefined;
         if (varTrueOrUndefined) {
@@ -154,12 +91,12 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         if (varFalseOrNull !== true) {
         }
       `,
-      options: [{ allowComparingNullableBooleansToTrue: false }],
       errors: [
         {
           messageId: 'comparingNullableToTrueNegated',
         },
       ],
+      options: [{ allowComparingNullableBooleansToTrue: false }],
       output: `
         declare const varFalseOrNull: false | null;
         if (!varFalseOrNull) {
@@ -173,12 +110,12 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         if (varBooleanOrNull === false && otherBoolean) {
         }
       `,
-      options: [{ allowComparingNullableBooleansToFalse: false }],
       errors: [
         {
           messageId: 'comparingNullableToFalse',
         },
       ],
+      options: [{ allowComparingNullableBooleansToFalse: false }],
       output: `
         declare const varBooleanOrNull: boolean | null;
         declare const otherBoolean: boolean;
@@ -193,12 +130,12 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         if (!(varBooleanOrNull === false) || otherBoolean) {
         }
       `,
-      options: [{ allowComparingNullableBooleansToFalse: false }],
       errors: [
         {
           messageId: 'comparingNullableToFalse',
         },
       ],
+      options: [{ allowComparingNullableBooleansToFalse: false }],
       output: `
         declare const varBooleanOrNull: boolean | null;
         declare const otherBoolean: boolean;
@@ -213,12 +150,12 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
         if (varTrueOrFalseOrUndefined !== false && !otherBoolean) {
         }
       `,
-      options: [{ allowComparingNullableBooleansToFalse: false }],
       errors: [
         {
           messageId: 'comparingNullableToFalse',
         },
       ],
+      options: [{ allowComparingNullableBooleansToFalse: false }],
       output: `
         declare const varTrueOrFalseOrUndefined: true | false | undefined;
         declare const otherBoolean: boolean;
@@ -482,4 +419,67 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
       `,
     },
   ],
+
+  valid: [
+    `
+      declare const varAny: any;
+      varAny === true;
+    `,
+    `
+      declare const varAny: any;
+      varAny == false;
+    `,
+    `
+      declare const varString: string;
+      varString === false;
+    `,
+    `
+      declare const varString: string;
+      varString === true;
+    `,
+    `
+      declare const varObject: {};
+      varObject === true;
+    `,
+    `
+      declare const varObject: {};
+      varObject == false;
+    `,
+    `
+      declare const varNullOrUndefined: null | undefined;
+      varNullOrUndefined === false;
+    `,
+    `
+      declare const varBooleanOrString: boolean | string;
+      varBooleanOrString === false;
+    `,
+    `
+      declare const varBooleanOrString: boolean | string;
+      varBooleanOrString == true;
+    `,
+    `
+      declare const varTrueOrStringOrUndefined: true | string | undefined;
+      varTrueOrStringOrUndefined == true;
+    `,
+    `
+      declare const varBooleanOrUndefined: boolean | undefined;
+      varBooleanOrUndefined === true;
+    `,
+    {
+      code: `
+        declare const varBooleanOrUndefined: boolean | undefined;
+        varBooleanOrUndefined === true;
+      `,
+      options: [{ allowComparingNullableBooleansToFalse: false }],
+    },
+    {
+      code: `
+        declare const varBooleanOrUndefined: boolean | undefined;
+        varBooleanOrUndefined === false;
+      `,
+      options: [{ allowComparingNullableBooleansToTrue: false }],
+    },
+    "'false' === true;",
+    "'true' === false;",
+  ],
 });
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 18d254917311..dcfc5865be4d 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
@@ -1,15 +1,16 @@
-import * as path from 'node:path';
-
 import type {
   InvalidTestCase,
   TestCaseError,
 } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
+import * as path from 'node:path';
 
 import type {
   MessageId,
   Options,
 } from '../../src/rules/no-unnecessary-condition';
+
 import rule from '../../src/rules/no-unnecessary-condition';
 import { getFixturesRootDir } from '../RuleTester';
 
@@ -18,15 +19,15 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 const optionsWithExactOptionalPropertyTypes = {
-  tsconfigRootDir: rootPath,
   project: './tsconfig.exactOptionalPropertyTypes.json',
+  tsconfigRootDir: rootPath,
 };
 
 const ruleError = (
@@ -34,9 +35,9 @@ const ruleError = (
   column: number,
   messageId: MessageId,
 ): TestCaseError<MessageId> => ({
-  messageId,
-  line,
   column,
+  line,
+  messageId,
 });
 
 const necessaryConditionTest = (condition: string): string => `
@@ -54,194 +55,203 @@ const unnecessaryConditionTest = (
 });
 
 ruleTester.run('no-unnecessary-condition', rule, {
-  valid: [
-    `
-declare const b1: boolean;
+  invalid: [
+    // Ensure that it's checking in all the right places
+    {
+      code: `
+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) {
+if (b2 && b1) {
 }
 while (b1 && b2) {}
+while (b2 && b1) {}
 for (let i = 0; b1 && b2; i++) {
   break;
 }
 const t1 = b1 && b2 ? 'yes' : 'no';
-for (;;) {}
-    `,
-    `
-declare function foo(): number | void;
-const result1 = foo() === undefined;
-const result2 = foo() == null;
-    `,
-    necessaryConditionTest('false | 5'), // Truthy literal and falsy literal
-    necessaryConditionTest('boolean | "foo"'), // boolean and truthy literal
-    necessaryConditionTest('0 | boolean'), // boolean and falsy literal
-    necessaryConditionTest('boolean | object'), // boolean and always-truthy type
-    necessaryConditionTest('false | object'), // always truthy type and falsy literal
-    // always falsy type and always truthy type
-    necessaryConditionTest('null | object'),
-    necessaryConditionTest('undefined | true'),
-    necessaryConditionTest('void | true'),
-    // "branded" type
-    necessaryConditionTest('string & {}'),
-    necessaryConditionTest('string & { __brand: string }'),
-    necessaryConditionTest('number & { __brand: string }'),
-    necessaryConditionTest('boolean & { __brand: string }'),
-    necessaryConditionTest('bigint & { __brand: string }'),
-    necessaryConditionTest('string & {} & { __brand: string }'),
-    necessaryConditionTest(
-      'string & { __brandA: string } & { __brandB: string }',
-    ),
-    necessaryConditionTest('string & { __brand: string } | number'),
-    necessaryConditionTest('(string | number) & { __brand: string }'),
-    necessaryConditionTest('string & ({ __brand: string } | number)'),
-    necessaryConditionTest('("" | "foo") & { __brand: string }'),
-    necessaryConditionTest(
-      '(string & { __brandA: string }) | (number & { __brandB: string })',
-    ),
-    necessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string }) & ("" | "foo"))',
-    ),
-    necessaryConditionTest(
-      '{ __brandA: string} & (({ __brandB: string } & string) | ({ __brandC: string } & number))',
-    ),
-    necessaryConditionTest(
-      '(string | number) & ("foo" | 123 | { __brandA: string })',
-    ),
-
-    necessaryConditionTest('string & string'),
+const t1 = b2 && b1 ? 'yes' : 'no';
+      `,
+      errors: [
+        ruleError(4, 12, 'alwaysTruthy'),
+        ruleError(5, 12, 'alwaysTruthy'),
+        ruleError(6, 5, 'alwaysTruthy'),
+        ruleError(8, 11, 'alwaysTruthy'),
+        ruleError(10, 8, 'alwaysTruthy'),
+        ruleError(11, 14, 'alwaysTruthy'),
+        ruleError(12, 17, 'alwaysTruthy'),
+        ruleError(15, 12, 'alwaysTruthy'),
+        ruleError(16, 18, 'alwaysTruthy'),
+      ],
+      output: null,
+    },
+    // Ensure that it's complaining about the right things
+    unnecessaryConditionTest('object', 'alwaysTruthy'),
+    unnecessaryConditionTest('object | true', 'alwaysTruthy'),
+    unnecessaryConditionTest('"" | false', 'alwaysFalsy'), // Two falsy literals
+    unnecessaryConditionTest('"always truthy"', 'alwaysTruthy'),
+    unnecessaryConditionTest(`undefined`, 'alwaysFalsy'),
+    unnecessaryConditionTest('null', 'alwaysFalsy'),
+    unnecessaryConditionTest('void', 'alwaysFalsy'),
+    unnecessaryConditionTest('never', 'never'),
+    unnecessaryConditionTest('string & number', 'never'),
 
-    necessaryConditionTest('any'), // any
-    necessaryConditionTest('unknown'), // unknown
+    // More complex logical expressions
+    {
+      code: `
+declare const b1: boolean;
+declare const b2: boolean;
+if (true && b1 && b2) {
+}
+if (b1 && false && b2) {
+}
+if (b1 || b2 || true) {
+}
+      `,
+      errors: [
+        ruleError(4, 5, 'alwaysTruthy'),
+        ruleError(6, 11, 'alwaysFalsy'),
+        ruleError(8, 17, 'alwaysTruthy'),
+      ],
+      output: null,
+    },
 
     // Generic type params
-    `
-function test<T extends string>(t: T) {
+    {
+      code: `
+function test<T extends object>(t: T) {
   return t ? 'yes' : 'no';
 }
-    `,
-    `
-// Naked type param
-function test<T>(t: T) {
+      `,
+      errors: [ruleError(3, 10, 'alwaysTruthy')],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends false>(t: T) {
   return t ? 'yes' : 'no';
 }
-    `,
-    `
-// Naked type param in union
-function test<T>(t: T | []) {
+      `,
+      errors: [ruleError(3, 10, 'alwaysFalsy')],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends 'a' | 'b'>(t: T) {
   return t ? 'yes' : 'no';
 }
-    `,
+      `,
+      errors: [ruleError(3, 10, 'alwaysTruthy')],
+      output: null,
+    },
 
     // Boolean expressions
-    `
+    {
+      code: `
+function test(a: 'a') {
+  return a === 'a';
+}
+      `,
+      errors: [ruleError(3, 10, 'literalBooleanExpression')],
+      output: null,
+    },
+    {
+      code: `
+const y = 1;
+if (y === 0) {
+}
+      `,
+      errors: [ruleError(3, 5, 'literalBooleanExpression')],
+      output: null,
+    },
+    {
+      code: `
+enum Foo {
+  a = 1,
+  b = 2,
+}
+
+const x = Foo.a;
+if (x === Foo.a) {
+}
+      `,
+      errors: [ruleError(8, 5, 'literalBooleanExpression')],
+      output: null,
+    },
+    // Workaround https://github.com/microsoft/TypeScript/issues/37160
+    {
+      code: `
 function test(a: string) {
-  const t1 = a === 'a';
-  const t2 = 'a' === a;
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
-    `,
-    `
+      `,
+      errors: [
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
+      ],
+      output: null,
+    },
+    {
+      code: `
 function test(a?: string) {
   const t1 = a === undefined;
   const t2 = undefined === a;
-  const t1 = a !== undefined;
-  const t2 = undefined !== a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
-    `,
-    `
+      `,
+      errors: [
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
+      ],
+      output: null,
+    },
+    {
+      code: `
 function test(a: null | string) {
-  const t1 = a === null;
-  const t2 = null === a;
-  const t1 = a !== null;
-  const t2 = null !== a;
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
-    `,
-    `
-function test(a?: null | string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a?: string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a: null | string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a: any) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
-}
-    `,
-    `
-function test(a: unknown) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
-}
-    `,
-    `
-function test<T>(a: T) {
+      `,
+      errors: [
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
+      ],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends object>(a: T) {
   const t1 = a == null;
   const t2 = null == a;
   const t3 = a != null;
@@ -259,2055 +269,2046 @@ function test<T>(a: T) {
   const t15 = a !== undefined;
   const t16 = undefined !== a;
 }
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] == null;
-}
-    `,
-
-    // Predicate functions
-    `
-// with literal arrow function
-[0, 1, 2].filter(x => x);
-
-// filter with named function
-function length(x: string) {
-  return x.length;
-}
-['a', 'b', ''].filter(length);
-
-// with non-literal array
-function nonEmptyStrings(x: string[]) {
-  return x.filter(length);
-}
-
-// filter-like predicate
-function count(
-  list: string[],
-  predicate: (value: string, index: number, array: string[]) => unknown,
-) {
-  return list.filter(predicate).length;
-}
-    `,
-    // Ignores non-array methods of the same name
-    `
-const notArray = {
-  filter: (func: () => boolean) => func(),
-  find: (func: () => boolean) => func(),
-};
-notArray.filter(() => true);
-notArray.find(() => true);
-    `,
-
+      `,
+      errors: [
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
+        ruleError(11, 14, 'noOverlapBooleanExpression'),
+        ruleError(12, 15, 'noOverlapBooleanExpression'),
+        ruleError(13, 15, 'noOverlapBooleanExpression'),
+        ruleError(14, 15, 'noOverlapBooleanExpression'),
+        ruleError(15, 15, 'noOverlapBooleanExpression'),
+        ruleError(16, 15, 'noOverlapBooleanExpression'),
+        ruleError(17, 15, 'noOverlapBooleanExpression'),
+        ruleError(18, 15, 'noOverlapBooleanExpression'),
+      ],
+      output: null,
+    },
     // Nullish coalescing operator
-    `
-function test(a: string | null) {
+    {
+      code: `
+function test(a: string) {
   return a ?? 'default';
 }
-    `,
-    `
-function test(a: string | undefined) {
+      `,
+      errors: [ruleError(3, 10, 'neverNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test(a: string | false) {
   return a ?? 'default';
 }
-    `,
-    `
-function test(a: string | null | undefined) {
+      `,
+      errors: [ruleError(3, 10, 'neverNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends string>(a: T) {
   return a ?? 'default';
 }
-    `,
-    `
-function test(a: unknown) {
+      `,
+      errors: [ruleError(3, 10, 'neverNullish')],
+      output: null,
+    },
+    // nullish + array index without optional chaining
+    {
+      code: `
+function test(a: { foo: string }[]) {
+  return a[0].foo ?? 'default';
+}
+      `,
+      errors: [ruleError(3, 10, 'neverNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test(a: null) {
   return a ?? 'default';
 }
-    `,
-    `
-function test<T>(a: T) {
+      `,
+      errors: [ruleError(3, 10, 'alwaysNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test(a: null[]) {
+  return a[0] ?? 'default';
+}
+      `,
+      errors: [ruleError(3, 10, 'alwaysNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends null>(a: T) {
   return a ?? 'default';
 }
-    `,
-    `
-function test<T extends string | null>(a: T) {
+      `,
+      errors: [ruleError(3, 10, 'alwaysNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test(a: never) {
   return a ?? 'default';
 }
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] ?? 'default';
+      `,
+      errors: [ruleError(3, 10, 'never')],
+      output: null,
+    },
+    {
+      code: `
+function test<T extends { foo: number }, K extends 'foo'>(num: T[K]) {
+  num ?? 'default';
 }
-    `,
-    // Indexing cases
-    `
-declare const arr: object[];
-if (arr[42]) {
-} // looks unnecessary from the types, but isn't
+      `,
+      errors: [ruleError(3, 3, 'neverNullish')],
+      output: null,
+    },
+    // Predicate functions
+    {
+      code: `
+[1, 3, 5].filter(() => true);
+[1, 2, 3].find(() => {
+  return false;
+});
 
-const tuple = [{}] as [object];
-declare const n: number;
-if (tuple[n]) {
+// with non-literal array
+function nothing(x: string[]) {
+  return x.filter(() => false);
 }
-    `,
-    // Optional-chaining indexing
-    `
-declare const arr: Array<{ value: string } & (() => void)>;
-if (arr[42]?.value) {
+// with readonly array
+function nothing2(x: readonly string[]) {
+  return x.filter(() => false);
 }
-arr[41]?.();
-
-// An array access can "infect" deeper into the chain
-declare const arr2: Array<{ x: { y: { z: object } } }>;
-arr2[42]?.x?.y?.z;
-
-const tuple = ['foo'] as const;
-declare const n: number;
-tuple[n]?.toUpperCase();
-    `,
-    `
-if (arr?.[42]) {
+// with tuple
+function nothing3(x: [string, string]) {
+  return x.filter(() => false);
 }
-    `,
-    `
-type ItemA = { bar: string; baz: string };
-type ItemB = { bar: string; qux: string };
-declare const foo: ItemA[] | ItemB[];
-foo[0]?.bar;
-    `,
-    `
-type TupleA = [string, number];
-type TupleB = [string, number];
-
-declare const foo: TupleA | TupleB;
-declare const index: number;
-foo[index]?.toString();
-    `,
-    `
-declare const returnsArr: undefined | (() => string[]);
-if (returnsArr?.()[42]) {
+      `,
+      errors: [
+        ruleError(2, 24, 'alwaysTruthy'),
+        ruleError(4, 10, 'alwaysFalsy'),
+        ruleError(9, 25, 'alwaysFalsy'),
+        ruleError(13, 25, 'alwaysFalsy'),
+        ruleError(17, 25, 'alwaysFalsy'),
+      ],
+      output: null,
+    },
+    // Indexing cases
+    {
+      // This is an error because 'dict' doesn't represent
+      //  the potential for undefined in its types
+      code: `
+declare const dict: Record<string, object>;
+if (dict['mightNotExist']) {
 }
-returnsArr?.()[42]?.toUpperCase();
-    `,
-    // nullish + array index
-    `
-declare const arr: string[][];
-arr[x] ?? [];
-    `,
-    // nullish + optional array index
-    `
-declare const arr: { foo: number }[];
-const bar = arr[42]?.foo ?? 0;
-    `,
-    // Doesn't check the right-hand side of a logical expression
-    //  in a non-conditional context
+      `,
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
+      output: null,
+    },
     {
+      // Should still check tuples when accessed with literal numbers, since they don't have
+      //   unsound index signatures
       code: `
-declare const b1: boolean;
-declare const b2: true;
-const x = b1 && b2;
+const x = [{}] as [{ foo: string }];
+if (x[0]) {
+}
+if (x[0]?.foo) {
+}
+      `,
+      errors: [
+        ruleError(3, 5, 'alwaysTruthy'),
+        ruleError(5, 9, 'neverOptionalChain'),
+      ],
+      output: `
+const x = [{}] as [{ foo: string }];
+if (x[0]) {
+}
+if (x[0].foo) {
+}
+      `,
+    },
+    {
+      // Shouldn't mistake this for an array indexing case
+      code: `
+declare const arr: object[];
+if (arr.filter) {
+}
+      `,
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
+      output: null,
+    },
+    {
+      code: `
+function truthy() {
+  return [];
+}
+function falsy() {}
+[1, 3, 5].filter(truthy);
+[1, 2, 3].find(falsy);
       `,
+      errors: [
+        ruleError(6, 18, 'alwaysTruthyFunc'),
+        ruleError(7, 16, 'alwaysFalsyFunc'),
+      ],
+      output: null,
     },
+    // Supports generics
+    // TODO: fix this
+    //     {
+    //       code: `
+    // const isTruthy = <T>(t: T) => T;
+    // // Valid: numbers can be truthy or falsy (0).
+    // [0,1,2,3].filter(isTruthy);
+    // // Invalid: arrays are always falsy.
+    // [[1,2], [3,4]].filter(isTruthy);
+    // `,
+    //       errors: [ruleError(6, 23, 'alwaysTruthyFunc')],
+    //     },
     {
       code: `
 while (true) {}
 for (; true; ) {}
 do {} while (true);
       `,
-      options: [{ allowConstantLoopConditions: true }],
+      errors: [
+        ruleError(2, 8, 'alwaysTruthy'),
+        ruleError(3, 8, 'alwaysTruthy'),
+        ruleError(4, 14, 'alwaysTruthy'),
+      ],
+      options: [{ allowConstantLoopConditions: false }],
+      output: null,
     },
-    `
-let variable = 'abc' as string | void;
-variable?.[0];
-    `,
-    `
-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;
+    {
+      code: noFormat`
+let foo = { bar: true };
 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 ?. bar;
+foo ?.
+  bar;
+foo
+  ?. bar;
+      `,
+      errors: [
+        {
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+let foo = { bar: true };
+foo.bar;
+foo . bar;
+foo .
+  bar;
+foo
+  . bar;
+      `,
+    },
+    {
+      code: noFormat`
+let foo = () => {};
 foo?.();
-    `,
-    `
-let anyValue: any;
-anyValue?.();
-    `,
-    `
-let unknownValue: unknown;
-unknownValue?.();
-    `,
-    'const foo = [1, 2, 3][0];',
-    `
-declare const foo: { bar?: { baz: { c: string } } } | null;
-foo?.bar?.baz;
-    `,
-    `
-foo?.bar?.baz?.qux;
-    `,
-    `
-declare const foo: { bar: { baz: string } };
-foo.bar.qux?.();
-    `,
-    `
-type Foo = { baz: number } | null;
-type Bar = { baz: null | string | { qux: string } };
-declare const foo: { fooOrBar: Foo | Bar } | null;
-foo?.fooOrBar?.baz?.qux;
-    `,
-    `
-type Foo = { [key: string]: string } | null;
-declare const foo: Foo;
-
-const key = '1';
-foo?.[key]?.trim();
-    `,
-    `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo';
-declare const foo: Foo;
-declare const key: Key;
-
-foo?.[key].trim();
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-  };
-}
-
-function Foo(outer: Outer, key: string): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Foo = 'foo';
-
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo' | 'baz';
-declare const foo: Foo;
-declare const key: Key;
-
-foo?.[key]?.trim();
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/7700
-    `
-type BrandedKey = string & { __brand: string };
-type Foo = { [key: BrandedKey]: string } | null;
-declare const foo: Foo;
-const key = '1' as BrandedKey;
-foo?.[key]?.trim();
-    `,
-    `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key].trim();
-    `,
-    `
-type BrandedKey = string & { __brand: string };
-interface Outer {
-  inner?: {
-    [key: BrandedKey]: string | undefined;
-  };
-}
-function Foo(outer: Outer, key: BrandedKey): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string & { __brand: string }]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Foo = 'foo' & { __brand: string };
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key]?.trim();
-    `,
-    {
-      code: `
-type BrandedKey = string & { __brand: string };
-type Foo = { [key: BrandedKey]: string } | null;
-declare const foo: Foo;
-const key = '1' as BrandedKey;
-foo?.[key]?.trim();
+foo ?. ();
+foo ?.
+  ();
+foo
+  ?. ();
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
-      },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+let foo = () => {};
+foo();
+foo  ();
+foo${' '}
+  ();
+foo
+   ();
+      `,
     },
     {
-      code: `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key].trim();
+      code: noFormat`
+let foo = () => {};
+foo?.(bar);
+foo ?. (bar);
+foo ?.
+  (bar);
+foo
+  ?. (bar);
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
-      },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+let foo = () => {};
+foo(bar);
+foo  (bar);
+foo${' '}
+  (bar);
+foo
+   (bar);
+      `,
     },
     {
-      code: `
-type BrandedKey = string & { __brand: string };
-interface Outer {
-  inner?: {
-    [key: BrandedKey]: string | undefined;
-  };
-}
-function Foo(outer: Outer, key: BrandedKey): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-      `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      code: 'const foo = [1, 2, 3]?.[0];',
+      errors: [
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 1,
+          line: 1,
+          messageId: 'neverOptionalChain',
         },
-      },
+      ],
+      output: 'const foo = [1, 2, 3][0];',
     },
     {
       code: `
-interface Outer {
-  inner?: {
-    [key: string & { __brand: string }]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Foo = 'foo' & { __brand: string };
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
+declare const x: { a?: { b: string } };
+x?.a?.b;
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 2,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
-      },
+      ],
+      output: `
+declare const x: { a?: { b: string } };
+x.a?.b;
+      `,
     },
     {
       code: `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key]?.trim();
+declare const x: { a: { b?: { c: string } } };
+x.a?.b?.c;
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
-      },
+      ],
+      output: `
+declare const x: { a: { b?: { c: string } } };
+x.a.b?.c;
+      `,
     },
-    `
-let latencies: number[][] = [];
-
-function recordData(): void {
-  if (!latencies[0]) latencies[0] = [];
-  latencies[0].push(4);
-}
-
-recordData();
-    `,
-    `
-let latencies: number[][] = [];
-
-function recordData(): void {
-  if (latencies[0]) latencies[0] = [];
-  latencies[0].push(4);
-}
-
-recordData();
-    `,
-    `
-function test(testVal?: boolean) {
-  if (testVal ?? true) {
-    console.log('test');
-  }
-}
-    `,
-    `
-declare const x: string[];
-if (!x[0]) {
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2421
-    `
-const isEven = (val: number) => val % 2 === 0;
-if (!isEven(1)) {
-}
-    `,
-    `
-declare const booleanTyped: boolean;
-declare const unknownTyped: unknown;
-
-if (!(booleanTyped || unknownTyped)) {
-}
-    `,
     {
       code: `
-declare const x: string[] | null;
-// eslint-disable-next-line
-if (x) {
-}
+let x: { a?: string };
+x?.a;
       `,
-      options: [
+      errors: [
         {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
+          column: 2,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
       ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
+      output: `
+let x: { a?: string };
+x.a;
+      `,
     },
-    `
-interface Foo {
-  [key: string]: [string] | undefined;
-}
-
-type OptionalFoo = Foo | undefined;
-declare const foo: OptionalFoo;
-foo?.test?.length;
-    `,
-    `
-interface Foo {
-  [key: number]: [string] | undefined;
-}
-
-type OptionalFoo = Foo | undefined;
-declare const foo: OptionalFoo;
-foo?.[1]?.length;
-    `,
-    `
-declare let foo: number | null;
-foo ??= 1;
-    `,
-    `
-declare let foo: number;
-foo ||= 1;
-    `,
-    `
-declare const foo: { bar: { baz?: number; qux: number } };
-type Key = 'baz' | 'qux';
-declare const key: Key;
-foo.bar[key] ??= 1;
-    `,
-    `
-enum Keys {
-  A = 'A',
-  B = 'B',
-}
-type Foo = {
-  [Keys.A]: number | null;
-  [Keys.B]: number;
-};
-declare const foo: Foo;
-declare const key: Keys;
-foo[key] ??= 1;
-    `,
     {
       code: `
-declare const foo: { bar?: number };
-foo.bar ??= 1;
+declare const foo: { bar: { baz: { c: string } } } | null;
+foo?.bar?.baz;
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { c: string } } } | null;
+foo?.bar.baz;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare const foo: { bar: { baz?: number } };
-foo['bar'].baz ??= 1;
+declare const foo: { bar?: { baz: { qux: string } } } | null;
+foo?.bar?.baz?.qux;
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar?: { baz: { qux: string } } } | null;
+foo?.bar?.baz.qux;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare const foo: { bar: { baz?: number; qux: number } };
-type Key = 'baz' | 'qux';
-declare const key: Key;
-foo.bar[key] ??= 1;
+declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
+foo?.bar?.baz?.qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
+foo?.bar.baz.qux?.();
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
-    `
-declare let foo: number;
-foo &&= 1;
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] ??= 'default';
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6264
-    `
-function get<Obj, Key extends keyof Obj>(obj: Obj, key: Key) {
-  const value = obj[key];
-  if (value) {
-    return value;
-  }
-  throw new Error('BOOM!');
-}
-
-get({ foo: null }, 'foo');
-    `,
     {
       code: `
-function getElem(dict: Record<string, { foo: string }>, key: string) {
-  if (dict[key]) {
-    return dict[key].foo;
-  } else {
-    return '';
-  }
-}
+declare const foo: { bar: { baz: { qux: () => {} } } } | null;
+foo?.bar?.baz?.qux?.();
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
         },
-      },
-    },
-    `
-type Foo = { bar: () => number | undefined } | null;
-declare const foo: Foo;
-foo?.bar()?.toExponential();
-    `,
-    `
-type Foo = (() => number | undefined) | null;
-declare const foo: Foo;
-foo?.()?.toExponential();
-    `,
-    `
-type FooUndef = () => undefined;
-type FooNum = () => number;
-type Foo = FooUndef | FooNum | null;
-declare const foo: Foo;
-foo?.()?.toExponential();
-    `,
-    `
-type Foo = { [key: string]: () => number | undefined } | null;
-declare const foo: Foo;
-foo?.['bar']()?.toExponential();
-    `,
-    {
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-      code: `
-class ConsistentRand {
-  #rand?: number;
-
-  getCachedRand() {
-    this.#rand ??= Math.random();
-    return this.#rand;
-  }
-}
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 19,
+          endColumn: 21,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { qux: () => {} } } } | null;
+foo?.bar.baz.qux();
       `,
     },
-  ],
-  invalid: [
-    // Ensure that it's checking in all the right places
     {
       code: `
-const b1 = true;
-declare const b2: boolean;
-const t1 = b1 && b2;
-const t2 = b1 || b2;
-if (b1 && b2) {
-}
-if (b2 && b1) {
-}
-while (b1 && b2) {}
-while (b2 && b1) {}
-for (let i = 0; b1 && b2; i++) {
-  break;
-}
-const t1 = b1 && b2 ? 'yes' : 'no';
-const t1 = b2 && b1 ? 'yes' : 'no';
+type baz = () => { qux: () => {} };
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.().qux?.();
       `,
-      output: null,
       errors: [
-        ruleError(4, 12, 'alwaysTruthy'),
-        ruleError(5, 12, 'alwaysTruthy'),
-        ruleError(6, 5, 'alwaysTruthy'),
-        ruleError(8, 11, 'alwaysTruthy'),
-        ruleError(10, 8, 'alwaysTruthy'),
-        ruleError(11, 14, 'alwaysTruthy'),
-        ruleError(12, 17, 'alwaysTruthy'),
-        ruleError(15, 12, 'alwaysTruthy'),
-        ruleError(16, 18, 'alwaysTruthy'),
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
       ],
+      output: `
+type baz = () => { qux: () => {} };
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz().qux();
+      `,
     },
-    // Ensure that it's complaining about the right things
-    unnecessaryConditionTest('object', 'alwaysTruthy'),
-    unnecessaryConditionTest('object | true', 'alwaysTruthy'),
-    unnecessaryConditionTest('"" | false', 'alwaysFalsy'), // Two falsy literals
-    unnecessaryConditionTest('"always truthy"', 'alwaysTruthy'),
-    unnecessaryConditionTest(`undefined`, 'alwaysFalsy'),
-    unnecessaryConditionTest('null', 'alwaysFalsy'),
-    unnecessaryConditionTest('void', 'alwaysFalsy'),
-    unnecessaryConditionTest('never', 'never'),
-    unnecessaryConditionTest('string & number', 'never'),
-
-    // More complex logical expressions
     {
       code: `
-declare const b1: boolean;
-declare const b2: boolean;
-if (true && b1 && b2) {
-}
-if (b1 && false && b2) {
-}
-if (b1 || b2 || true) {
-}
+type baz = null | (() => { qux: () => {} });
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.().qux?.();
       `,
-      output: null,
       errors: [
-        ruleError(4, 5, 'alwaysTruthy'),
-        ruleError(6, 11, 'alwaysFalsy'),
-        ruleError(8, 17, 'alwaysTruthy'),
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
       ],
-    },
-
-    // Generic type params
-    {
-      code: `
-function test<T extends object>(t: T) {
-  return t ? 'yes' : 'no';
-}
+      output: `
+type baz = null | (() => { qux: () => {} });
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz?.().qux();
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'alwaysTruthy')],
     },
     {
       code: `
-function test<T extends false>(t: T) {
-  return t ? 'yes' : 'no';
-}
+type baz = null | (() => { qux: () => {} } | null);
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.()?.qux?.();
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'alwaysFalsy')],
-    },
-    {
-      code: `
-function test<T extends 'a' | 'b'>(t: T) {
-  return t ? 'yes' : 'no';
-}
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 23,
+          endColumn: 25,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type baz = null | (() => { qux: () => {} } | null);
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz?.()?.qux();
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'alwaysTruthy')],
     },
-
-    // Boolean expressions
     {
       code: `
-function test(a: 'a') {
-  return a === 'a';
-}
+type Foo = { baz: number };
+type Bar = { baz: null | string | { qux: string } };
+declare const foo: { fooOrBar: Foo | Bar } | null;
+foo?.fooOrBar?.baz?.qux;
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type Foo = { baz: number };
+type Bar = { baz: null | string | { qux: string } };
+declare const foo: { fooOrBar: Foo | Bar } | null;
+foo?.fooOrBar.baz?.qux;
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'literalBooleanExpression')],
     },
     {
       code: `
-const y = 1;
-if (y === 0) {
-}
+declare const x: { a: { b: number } }[];
+x[0].a?.b;
+      `,
+      errors: [ruleError(3, 7, 'neverOptionalChain')],
+      output: `
+declare const x: { a: { b: number } }[];
+x[0].a.b;
       `,
-      output: null,
-      errors: [ruleError(3, 5, 'literalBooleanExpression')],
     },
     {
       code: `
-enum Foo {
-  a = 1,
-  b = 2,
-}
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = 'bar' | 'foo';
+declare const foo: Foo;
+declare const key: Key;
 
-const x = Foo.a;
-if (x === Foo.a) {
-}
-      `,
-      output: null,
-      errors: [ruleError(8, 5, 'literalBooleanExpression')],
-    },
-    // Workaround https://github.com/microsoft/TypeScript/issues/37160
-    {
-      code: `
-function test(a: string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
-}
+foo?.[key]?.trim();
       `,
-      output: null,
       errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
+        {
+          column: 11,
+          endColumn: 13,
+          endLine: 7,
+          line: 7,
+          messageId: 'neverOptionalChain',
+        },
       ],
+      output: `
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = 'bar' | 'foo';
+declare const foo: Foo;
+declare const key: Key;
+
+foo?.[key].trim();
+      `,
     },
     {
       code: `
-function test(a?: string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
-}
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+declare const foo: Foo;
+const key = 'bar';
+foo?.[key]?.trim();
       `,
-      output: null,
       errors: [
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
+        {
+          column: 11,
+          endColumn: 13,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
       ],
+      output: `
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+declare const foo: Foo;
+const key = 'bar';
+foo?.[key].trim();
+      `,
     },
     {
       code: `
-function test(a: null | string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+
+export function test(outer: Outer): number | undefined {
+  const key = 'bar';
+  return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      output: null,
       errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
+        {
+          column: 28,
+          endColumn: 30,
+          endLine: 11,
+          line: 11,
+          messageId: 'neverOptionalChain',
+        },
       ],
+      output: `
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+
+export function test(outer: Outer): number | undefined {
+  const key = 'bar';
+  return outer.inner?.[key].charCodeAt(0);
+}
+      `,
     },
     {
       code: `
-function test<T extends object>(a: T) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Bar = 'bar';
+
+function Foo(outer: Outer, key: Bar): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      output: null,
       errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
-        ruleError(11, 14, 'noOverlapBooleanExpression'),
-        ruleError(12, 15, 'noOverlapBooleanExpression'),
-        ruleError(13, 15, 'noOverlapBooleanExpression'),
-        ruleError(14, 15, 'noOverlapBooleanExpression'),
-        ruleError(15, 15, 'noOverlapBooleanExpression'),
-        ruleError(16, 15, 'noOverlapBooleanExpression'),
-        ruleError(17, 15, 'noOverlapBooleanExpression'),
-        ruleError(18, 15, 'noOverlapBooleanExpression'),
+        {
+          column: 28,
+          endColumn: 30,
+          endLine: 11,
+          line: 11,
+          messageId: 'neverOptionalChain',
+        },
       ],
-    },
-    // Nullish coalescing operator
-    {
-      code: `
-function test(a: string) {
-  return a ?? 'default';
+      output: `
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Bar = 'bar';
+
+function Foo(outer: Outer, key: Bar): number | undefined {
+  return outer.inner?.[key].charCodeAt(0);
 }
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'neverNullish')],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2384
     {
       code: `
-function test(a: string | false) {
-  return a ?? 'default';
+function test(testVal?: true) {
+  if (testVal ?? true) {
+    console.log('test');
+  }
 }
       `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 22,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
       output: null,
-      errors: [ruleError(3, 10, 'neverNullish')],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2255
     {
       code: `
-function test<T extends string>(a: T) {
-  return a ?? 'default';
+const a = null;
+if (!a) {
 }
       `,
+      errors: [ruleError(3, 6, 'alwaysTruthy')],
       output: null,
-      errors: [ruleError(3, 10, 'neverNullish')],
     },
-    // nullish + array index without optional chaining
     {
       code: `
-function test(a: { foo: string }[]) {
-  return a[0].foo ?? 'default';
+const a = true;
+if (!a) {
 }
       `,
+      errors: [ruleError(3, 6, 'alwaysFalsy')],
       output: null,
-      errors: [ruleError(3, 10, 'neverNullish')],
     },
     {
       code: `
-function test(a: null) {
-  return a ?? 'default';
+function sayHi(): void {
+  console.log('Hi!');
+}
+
+let speech: never = sayHi();
+if (!speech) {
 }
       `,
+      errors: [ruleError(7, 6, 'never')],
       output: null,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
     },
     {
       code: `
-function test(a: null[]) {
-  return a[0] ?? 'default';
+declare const x: string[] | null;
+if (x) {
 }
       `,
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
+        },
+        {
+          column: 5,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
       output: null,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
     },
     {
       code: `
-function test<T extends null>(a: T) {
-  return a ?? 'default';
+interface Foo {
+  test: string;
+  [key: string]: [string] | undefined;
 }
+
+type OptionalFoo = Foo | undefined;
+declare const foo: OptionalFoo;
+foo?.test?.length;
+      `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 12,
+          endLine: 9,
+          line: 9,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+interface Foo {
+  test: string;
+  [key: string]: [string] | undefined;
+}
+
+type OptionalFoo = Foo | undefined;
+declare const foo: OptionalFoo;
+foo?.test.length;
       `,
-      output: null,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
     },
     {
       code: `
-function test(a: never) {
-  return a ?? 'default';
+function pick<Obj extends Record<string, 1 | 2 | 3>, Key extends keyof Obj>(
+  obj: Obj,
+  key: Key,
+): Obj[Key] {
+  const k = obj[key];
+  if (obj[key]) {
+    return obj[key];
+  }
+  throw new Error('Boom!');
 }
+
+pick({ foo: 1, bar: 2 }, 'bar');
       `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 15,
+          endLine: 7,
+          line: 7,
+          messageId: 'alwaysTruthy',
+        },
+      ],
       output: null,
-      errors: [ruleError(3, 10, 'never')],
     },
     {
       code: `
-function test<T extends { foo: number }, K extends 'foo'>(num: T[K]) {
-  num ?? 'default';
+function getElem(dict: Record<string, { foo: string }>, key: string) {
+  if (dict[key]) {
+    return dict[key].foo;
+  } else {
+    return '';
+  }
 }
       `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
       output: null,
-      errors: [ruleError(3, 3, 'neverNullish')],
     },
-    // Predicate functions
     {
       code: `
-[1, 3, 5].filter(() => true);
-[1, 2, 3].find(() => {
-  return false;
-});
-
-// with non-literal array
-function nothing(x: string[]) {
-  return x.filter(() => false);
-}
-// with readonly array
-function nothing2(x: readonly string[]) {
-  return x.filter(() => false);
-}
-// with tuple
-function nothing3(x: [string, string]) {
-  return x.filter(() => false);
-}
+declare let foo: {};
+foo ??= 1;
       `,
-      output: null,
       errors: [
-        ruleError(2, 24, 'alwaysTruthy'),
-        ruleError(4, 10, 'alwaysFalsy'),
-        ruleError(9, 25, 'alwaysFalsy'),
-        ruleError(13, 25, 'alwaysFalsy'),
-        ruleError(17, 25, 'alwaysFalsy'),
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
+        },
       ],
+      output: null,
     },
-    // Indexing cases
     {
-      // This is an error because 'dict' doesn't represent
-      //  the potential for undefined in its types
       code: `
-declare const dict: Record<string, object>;
-if (dict['mightNotExist']) {
-}
+declare let foo: number;
+foo ??= 1;
       `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
+        },
+      ],
       output: null,
-      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) {
-}
-      `,
-      output: `
-const x = [{}] as [{ foo: string }];
-if (x[0]) {
-}
-if (x[0].foo) {
-}
+declare let foo: null;
+foo ??= null;
       `,
       errors: [
-        ruleError(3, 5, 'alwaysTruthy'),
-        ruleError(5, 9, 'neverOptionalChain'),
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysNullish',
+        },
       ],
+      output: null,
     },
     {
-      // Shouldn't mistake this for an array indexing case
       code: `
-declare const arr: object[];
-if (arr.filter) {
-}
+declare let foo: {};
+foo ||= 1;
       `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
       output: null,
-      errors: [ruleError(3, 5, 'alwaysTruthy')],
     },
     {
       code: `
-function truthy() {
-  return [];
-}
-function falsy() {}
-[1, 3, 5].filter(truthy);
-[1, 2, 3].find(falsy);
+declare let foo: null;
+foo ||= null;
       `,
-      output: null,
       errors: [
-        ruleError(6, 18, 'alwaysTruthyFunc'),
-        ruleError(7, 16, 'alwaysFalsyFunc'),
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysFalsy',
+        },
       ],
+      output: null,
     },
-    // Supports generics
-    // TODO: fix this
-    //     {
-    //       code: `
-    // const isTruthy = <T>(t: T) => T;
-    // // Valid: numbers can be truthy or falsy (0).
-    // [0,1,2,3].filter(isTruthy);
-    // // Invalid: arrays are always falsy.
-    // [[1,2], [3,4]].filter(isTruthy);
-    // `,
-    //       errors: [ruleError(6, 23, 'alwaysTruthyFunc')],
-    //     },
     {
       code: `
-while (true) {}
-for (; true; ) {}
-do {} while (true);
+declare let foo: {};
+foo &&= 1;
       `,
-      output: null,
-      options: [{ allowConstantLoopConditions: false }],
       errors: [
-        ruleError(2, 8, 'alwaysTruthy'),
-        ruleError(3, 8, 'alwaysTruthy'),
-        ruleError(4, 14, 'alwaysTruthy'),
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
       ],
+      output: null,
     },
     {
-      code: noFormat`
-let foo = { bar: true };
-foo?.bar;
-foo ?. bar;
-foo ?.
-  bar;
-foo
-  ?. bar;
-      `,
-      output: `
-let foo = { bar: true };
-foo.bar;
-foo . bar;
-foo .
-  bar;
-foo
-  . bar;
+      code: `
+declare let foo: null;
+foo &&= null;
       `,
       errors: [
         {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          column: 4,
+          column: 1,
+          endColumn: 4,
           endLine: 3,
-          endColumn: 6,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 5,
-          endLine: 4,
-          endColumn: 7,
+          line: 3,
+          messageId: 'alwaysFalsy',
         },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare const foo: { bar: number };
+foo.bar ??= 1;
+      `,
+      errors: [
         {
-          messageId: 'neverOptionalChain',
-          line: 5,
-          column: 5,
-          endLine: 5,
-          endColumn: 7,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 5,
+          column: 1,
+          endColumn: 8,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
         },
       ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      output: null,
     },
     {
       code: noFormat`
-let foo = () => {};
-foo?.();
-foo ?. ();
-foo ?.
-  ();
-foo
-  ?. ();
-      `,
-      output: noFormat`
-let foo = () => {};
-foo();
-foo  ();
-foo${' '}
-  ();
-foo
-   ();
+type Foo = { bar: () => number } | null;
+declare const foo: Foo;
+foo?.bar()?.toExponential();
       `,
       errors: [
         {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          column: 4,
-          endLine: 3,
-          endColumn: 6,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 5,
+          column: 11,
+          endColumn: 13,
           endLine: 4,
-          endColumn: 7,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 5,
-          column: 5,
-          endLine: 5,
-          endColumn: 7,
-        },
-        {
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 5,
         },
       ],
+      output: noFormat`
+type Foo = { bar: () => number } | null;
+declare const foo: Foo;
+foo?.bar().toExponential();
+      `,
     },
     {
       code: noFormat`
-let foo = () => {};
-foo?.(bar);
-foo ?. (bar);
-foo ?.
-  (bar);
-foo
-  ?. (bar);
-      `,
-      output: noFormat`
-let foo = () => {};
-foo(bar);
-foo  (bar);
-foo${' '}
-  (bar);
-foo
-   (bar);
+type Foo = { bar: null | { baz: () => { qux: number } } } | null;
+declare const foo: Foo;
+foo?.bar?.baz()?.qux?.toExponential();
       `,
       errors: [
         {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          column: 4,
-          endLine: 3,
-          endColumn: 6,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 5,
+          column: 16,
+          endColumn: 18,
           endLine: 4,
-          endColumn: 7,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 5,
-          column: 5,
-          endLine: 5,
-          endColumn: 7,
-        },
-        {
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 8,
-          column: 3,
-          endLine: 8,
-          endColumn: 5,
         },
-      ],
-    },
-    {
-      code: 'const foo = [1, 2, 3]?.[0];',
-      output: 'const foo = [1, 2, 3][0];',
-      errors: [
         {
+          column: 21,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 1,
-          endLine: 1,
-          column: 22,
-          endColumn: 24,
         },
       ],
-    },
-    {
-      code: `
-declare const x: { a?: { b: string } };
-x?.a?.b;
-      `,
-      output: `
-declare const x: { a?: { b: string } };
-x.a?.b;
+      output: noFormat`
+type Foo = { bar: null | { baz: () => { qux: number } } } | null;
+declare const foo: Foo;
+foo?.bar?.baz().qux.toExponential();
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 2,
-          endColumn: 4,
-        },
-      ],
     },
     {
-      code: `
-declare const x: { a: { b?: { c: string } } };
-x.a?.b?.c;
-      `,
-      output: `
-declare const x: { a: { b?: { c: string } } };
-x.a.b?.c;
+      code: noFormat`
+type Foo = (() => number) | null;
+declare const foo: Foo;
+foo?.()?.toExponential();
       `,
       errors: [
         {
+          column: 8,
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 4,
-          endColumn: 6,
         },
       ],
-    },
-    {
-      code: `
-let x: { a?: string };
-x?.a;
-      `,
-      output: `
-let x: { a?: string };
-x.a;
+      output: noFormat`
+type Foo = (() => number) | null;
+declare const foo: Foo;
+foo?.().toExponential();
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 2,
-          endColumn: 4,
-        },
-      ],
     },
     {
-      code: `
-declare const foo: { bar: { baz: { c: string } } } | null;
-foo?.bar?.baz;
-      `,
-      output: `
-declare const foo: { bar: { baz: { c: string } } } | null;
-foo?.bar.baz;
+      code: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']()?.toExponential();
       `,
       errors: [
         {
+          column: 15,
+          endColumn: 17,
+          endLine: 4,
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 9,
-          endColumn: 11,
         },
       ],
+      output: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']().toExponential();
+      `,
     },
     {
-      code: `
-declare const foo: { bar?: { baz: { qux: string } } } | null;
-foo?.bar?.baz?.qux;
-      `,
-      output: `
-declare const foo: { bar?: { baz: { qux: string } } } | null;
-foo?.bar?.baz.qux;
+      code: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']?.()?.toExponential();
       `,
       errors: [
         {
+          column: 17,
+          endColumn: 19,
+          endLine: 4,
+          line: 4,
           messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 14,
-          endColumn: 16,
         },
       ],
-    },
-    {
-      code: `
-declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
-foo?.bar?.baz?.qux?.();
-      `,
-      output: `
-declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
-foo?.bar.baz.qux?.();
+      output: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']?.().toExponential();
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 9,
-          endColumn: 11,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 14,
-          endColumn: 16,
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: { bar: { baz: { qux: () => {} } } } | null;
-foo?.bar?.baz?.qux?.();
-      `,
-      output: `
-declare const foo: { bar: { baz: { qux: () => {} } } } | null;
-foo?.bar.baz.qux();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 9,
-          endColumn: 11,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 14,
-          endColumn: 16,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 3,
-          endLine: 3,
-          column: 19,
-          endColumn: 21,
-        },
-      ],
-    },
-    {
-      code: `
-type baz = () => { qux: () => {} };
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.().qux?.();
-      `,
-      output: `
-type baz = () => { qux: () => {} };
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz().qux();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 9,
-          endColumn: 11,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 14,
-          endColumn: 16,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 22,
-          endColumn: 24,
-        },
-      ],
     },
+
+    // "branded" types
+    unnecessaryConditionTest('"" & {}', 'alwaysFalsy'),
+    unnecessaryConditionTest('"" & { __brand: string }', 'alwaysFalsy'),
+    unnecessaryConditionTest(
+      '("" | false) & { __brand: string }',
+      'alwaysFalsy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & ""',
+      'alwaysFalsy',
+    ),
+    unnecessaryConditionTest(
+      '("foo" | "bar") & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '(123 | true) & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '(string | number) & ("foo" | 123) & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & "foo"',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & ("foo" | 123)',
+      'alwaysTruthy',
+    ),
+  ],
+  valid: [
+    `
+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';
+for (;;) {}
+    `,
+    `
+declare function foo(): number | void;
+const result1 = foo() === undefined;
+const result2 = foo() == null;
+    `,
+    necessaryConditionTest('false | 5'), // Truthy literal and falsy literal
+    necessaryConditionTest('boolean | "foo"'), // boolean and truthy literal
+    necessaryConditionTest('0 | boolean'), // boolean and falsy literal
+    necessaryConditionTest('boolean | object'), // boolean and always-truthy type
+    necessaryConditionTest('false | object'), // always truthy type and falsy literal
+    // always falsy type and always truthy type
+    necessaryConditionTest('null | object'),
+    necessaryConditionTest('undefined | true'),
+    necessaryConditionTest('void | true'),
+    // "branded" type
+    necessaryConditionTest('string & {}'),
+    necessaryConditionTest('string & { __brand: string }'),
+    necessaryConditionTest('number & { __brand: string }'),
+    necessaryConditionTest('boolean & { __brand: string }'),
+    necessaryConditionTest('bigint & { __brand: string }'),
+    necessaryConditionTest('string & {} & { __brand: string }'),
+    necessaryConditionTest(
+      'string & { __brandA: string } & { __brandB: string }',
+    ),
+    necessaryConditionTest('string & { __brand: string } | number'),
+    necessaryConditionTest('(string | number) & { __brand: string }'),
+    necessaryConditionTest('string & ({ __brand: string } | number)'),
+    necessaryConditionTest('("" | "foo") & { __brand: string }'),
+    necessaryConditionTest(
+      '(string & { __brandA: string }) | (number & { __brandB: string })',
+    ),
+    necessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string }) & ("" | "foo"))',
+    ),
+    necessaryConditionTest(
+      '{ __brandA: string} & (({ __brandB: string } & string) | ({ __brandC: string } & number))',
+    ),
+    necessaryConditionTest(
+      '(string | number) & ("foo" | 123 | { __brandA: string })',
+    ),
+
+    necessaryConditionTest('string & string'),
+
+    necessaryConditionTest('any'), // any
+    necessaryConditionTest('unknown'), // unknown
+
+    // Generic type params
+    `
+function test<T extends string>(t: T) {
+  return t ? 'yes' : 'no';
+}
+    `,
+    `
+// Naked type param
+function test<T>(t: T) {
+  return t ? 'yes' : 'no';
+}
+    `,
+    `
+// Naked type param in union
+function test<T>(t: T | []) {
+  return t ? 'yes' : 'no';
+}
+    `,
+
+    // Boolean expressions
+    `
+function test(a: string) {
+  const t1 = a === 'a';
+  const t2 = 'a' === a;
+}
+    `,
+    `
+function test(a?: string) {
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t1 = a !== undefined;
+  const t2 = undefined !== a;
+}
+    `,
+    `
+function test(a: null | string) {
+  const t1 = a === null;
+  const t2 = null === a;
+  const t1 = a !== null;
+  const t2 = null !== a;
+}
+    `,
+    `
+function test(a?: null | string) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+}
+    `,
+    `
+function test(a?: string) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+}
+    `,
+    `
+function test(a: null | string) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+}
+    `,
+    `
+function test(a: any) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
+}
+    `,
+    `
+function test(a: unknown) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
+}
+    `,
+    `
+function test<T>(a: T) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
+}
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] == null;
+}
+    `,
+
+    // Predicate functions
+    `
+// with literal arrow function
+[0, 1, 2].filter(x => x);
+
+// filter with named function
+function length(x: string) {
+  return x.length;
+}
+['a', 'b', ''].filter(length);
+
+// with non-literal array
+function nonEmptyStrings(x: string[]) {
+  return x.filter(length);
+}
+
+// filter-like predicate
+function count(
+  list: string[],
+  predicate: (value: string, index: number, array: string[]) => unknown,
+) {
+  return list.filter(predicate).length;
+}
+    `,
+    // Ignores non-array methods of the same name
+    `
+const notArray = {
+  filter: (func: () => boolean) => func(),
+  find: (func: () => boolean) => func(),
+};
+notArray.filter(() => true);
+notArray.find(() => true);
+    `,
+
+    // Nullish coalescing operator
+    `
+function test(a: string | null) {
+  return a ?? 'default';
+}
+    `,
+    `
+function test(a: string | undefined) {
+  return a ?? 'default';
+}
+    `,
+    `
+function test(a: string | null | undefined) {
+  return a ?? 'default';
+}
+    `,
+    `
+function test(a: unknown) {
+  return a ?? 'default';
+}
+    `,
+    `
+function test<T>(a: T) {
+  return a ?? 'default';
+}
+    `,
+    `
+function test<T extends string | null>(a: T) {
+  return a ?? 'default';
+}
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] ?? 'default';
+}
+    `,
+    // Indexing cases
+    `
+declare const arr: object[];
+if (arr[42]) {
+} // looks unnecessary from the types, but isn't
+
+const tuple = [{}] as [object];
+declare const n: number;
+if (tuple[n]) {
+}
+    `,
+    // Optional-chaining indexing
+    `
+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 } } }>;
+arr2[42]?.x?.y?.z;
+
+const tuple = ['foo'] as const;
+declare const n: number;
+tuple[n]?.toUpperCase();
+    `,
+    `
+if (arr?.[42]) {
+}
+    `,
+    `
+type ItemA = { bar: string; baz: string };
+type ItemB = { bar: string; qux: string };
+declare const foo: ItemA[] | ItemB[];
+foo[0]?.bar;
+    `,
+    `
+type TupleA = [string, number];
+type TupleB = [string, number];
+
+declare const foo: TupleA | TupleB;
+declare const index: number;
+foo[index]?.toString();
+    `,
+    `
+declare const returnsArr: undefined | (() => string[]);
+if (returnsArr?.()[42]) {
+}
+returnsArr?.()[42]?.toUpperCase();
+    `,
+    // nullish + array index
+    `
+declare const arr: string[][];
+arr[x] ?? [];
+    `,
+    // nullish + optional array index
+    `
+declare const arr: { foo: number }[];
+const bar = arr[42]?.foo ?? 0;
+    `,
+    // Doesn't check the right-hand side of a logical expression
+    //  in a non-conditional context
     {
       code: `
-type baz = null | (() => { qux: () => {} });
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.().qux?.();
-      `,
-      output: `
-type baz = null | (() => { qux: () => {} });
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz?.().qux();
+declare const b1: boolean;
+declare const b2: true;
+const x = b1 && b2;
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 9,
-          endColumn: 11,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 22,
-          endColumn: 24,
-        },
-      ],
     },
     {
       code: `
-type baz = null | (() => { qux: () => {} } | null);
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.()?.qux?.();
-      `,
-      output: `
-type baz = null | (() => { qux: () => {} } | null);
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz?.()?.qux();
+while (true) {}
+for (; true; ) {}
+do {} while (true);
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 9,
-          endColumn: 11,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          endLine: 4,
-          column: 23,
-          endColumn: 25,
-        },
-      ],
+      options: [{ allowConstantLoopConditions: true }],
     },
-    {
-      code: `
-type Foo = { baz: number };
+    `
+let variable = 'abc' as string | void;
+variable?.[0];
+    `,
+    `
+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];',
+    `
+declare const foo: { bar?: { baz: { c: string } } } | null;
+foo?.bar?.baz;
+    `,
+    `
+foo?.bar?.baz?.qux;
+    `,
+    `
+declare const foo: { bar: { baz: string } };
+foo.bar.qux?.();
+    `,
+    `
+type Foo = { baz: number } | null;
 type Bar = { baz: null | string | { qux: string } };
 declare const foo: { fooOrBar: Foo | Bar } | null;
 foo?.fooOrBar?.baz?.qux;
-      `,
-      output: `
-type Foo = { baz: number };
-type Bar = { baz: null | string | { qux: string } };
-declare const foo: { fooOrBar: Foo | Bar } | null;
-foo?.fooOrBar.baz?.qux;
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 5,
-          endLine: 5,
-          column: 14,
-          endColumn: 16,
-        },
-      ],
-    },
-    {
-      code: `
-declare const x: { a: { b: number } }[];
-x[0].a?.b;
-      `,
-      output: `
-declare const x: { a: { b: number } }[];
-x[0].a.b;
-      `,
-      errors: [ruleError(3, 7, 'neverOptionalChain')],
-    },
-    {
-      code: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo';
+    `,
+    `
+type Foo = { [key: string]: string } | null;
 declare const foo: Foo;
-declare const key: Key;
 
+const key = '1';
 foo?.[key]?.trim();
-      `,
-      output: `
+    `,
+    `
 type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
 type Key = 'bar' | 'foo';
 declare const foo: Foo;
 declare const key: Key;
 
 foo?.[key].trim();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 7,
-          endLine: 7,
-          column: 11,
-          endColumn: 13,
-        },
-      ],
-    },
-    {
-      code: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-declare const foo: Foo;
-const key = 'bar';
-foo?.[key]?.trim();
-      `,
-      output: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-declare const foo: Foo;
-const key = 'bar';
-foo?.[key].trim();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 5,
-          endLine: 5,
-          column: 11,
-          endColumn: 13,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 interface Outer {
   inner?: {
     [key: string]: string | undefined;
-    bar: 'bar';
   };
 }
 
-export function test(outer: Outer): number | undefined {
-  const key = 'bar';
+function Foo(outer: Outer, key: string): number | undefined {
   return outer.inner?.[key]?.charCodeAt(0);
 }
-      `,
-      output: `
+    `,
+    `
 interface Outer {
   inner?: {
     [key: string]: string | undefined;
     bar: 'bar';
   };
 }
+type Foo = 'foo';
 
-export function test(outer: Outer): number | undefined {
-  const key = 'bar';
-  return outer.inner?.[key].charCodeAt(0);
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
 }
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 11,
-          endLine: 11,
-          column: 28,
-          endColumn: 30,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = 'bar' | 'foo' | 'baz';
+declare const foo: Foo;
+declare const key: Key;
+
+foo?.[key]?.trim();
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/7700
+    `
+type BrandedKey = string & { __brand: string };
+type Foo = { [key: BrandedKey]: string } | null;
+declare const foo: Foo;
+const key = '1' as BrandedKey;
+foo?.[key]?.trim();
+    `,
+    `
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key].trim();
+    `,
+    `
+type BrandedKey = string & { __brand: string };
 interface Outer {
   inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
+    [key: BrandedKey]: string | undefined;
   };
 }
-type Bar = 'bar';
-
-function Foo(outer: Outer, key: Bar): number | undefined {
+function Foo(outer: Outer, key: BrandedKey): number | undefined {
   return outer.inner?.[key]?.charCodeAt(0);
 }
-      `,
-      output: `
+    `,
+    `
 interface Outer {
   inner?: {
-    [key: string]: string | undefined;
+    [key: string & { __brand: string }]: string | undefined;
     bar: 'bar';
   };
 }
-type Bar = 'bar';
-
-function Foo(outer: Outer, key: Bar): number | undefined {
-  return outer.inner?.[key].charCodeAt(0);
+type Foo = 'foo' & { __brand: string };
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
 }
+    `,
+    `
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key]?.trim();
+    `,
+    {
+      code: `
+type BrandedKey = string & { __brand: string };
+type Foo = { [key: BrandedKey]: string } | null;
+declare const foo: Foo;
+const key = '1' as BrandedKey;
+foo?.[key]?.trim();
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 11,
-          endLine: 11,
-          column: 28,
-          endColumn: 30,
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
+      },
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2384
     {
       code: `
-function test(testVal?: true) {
-  if (testVal ?? true) {
-    console.log('test');
-  }
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key].trim();
+      `,
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
+      },
+    },
+    {
+      code: `
+type BrandedKey = string & { __brand: string };
+interface Outer {
+  inner?: {
+    [key: BrandedKey]: string | undefined;
+  };
+}
+function Foo(outer: Outer, key: BrandedKey): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysTruthy',
-          line: 3,
-          endLine: 3,
-          column: 7,
-          endColumn: 22,
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
+      },
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2255
     {
       code: `
-const a = null;
-if (!a) {
+interface Outer {
+  inner?: {
+    [key: string & { __brand: string }]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Foo = 'foo' & { __brand: string };
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      output: null,
-      errors: [ruleError(3, 6, 'alwaysTruthy')],
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
+      },
     },
     {
       code: `
-const a = true;
-if (!a) {
-}
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key]?.trim();
       `,
-      output: null,
-      errors: [ruleError(3, 6, 'alwaysFalsy')],
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
+      },
     },
-    {
-      code: `
-function sayHi(): void {
-  console.log('Hi!');
+    `
+let latencies: number[][] = [];
+
+function recordData(): void {
+  if (!latencies[0]) latencies[0] = [];
+  latencies[0].push(4);
 }
 
-let speech: never = sayHi();
-if (!speech) {
+recordData();
+    `,
+    `
+let latencies: number[][] = [];
+
+function recordData(): void {
+  if (latencies[0]) latencies[0] = [];
+  latencies[0].push(4);
 }
-      `,
-      output: null,
-      errors: [ruleError(7, 6, 'never')],
-    },
+
+recordData();
+    `,
+    `
+function test(testVal?: boolean) {
+  if (testVal ?? true) {
+    console.log('test');
+  }
+}
+    `,
+    `
+declare const x: string[];
+if (!x[0]) {
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2421
+    `
+const isEven = (val: number) => val % 2 === 0;
+if (!isEven(1)) {
+}
+    `,
+    `
+declare const booleanTyped: boolean;
+declare const unknownTyped: unknown;
+
+if (!(booleanTyped || unknownTyped)) {
+}
+    `,
     {
       code: `
 declare const x: string[] | null;
+// eslint-disable-next-line
 if (x) {
 }
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'noStrictNullCheck',
-          line: 0,
-          column: 1,
-        },
-        {
-          messageId: 'alwaysTruthy',
-          line: 3,
-          column: 5,
-        },
-      ],
       languageOptions: {
         parserOptions: {
           tsconfigRootDir: path.join(rootPath, 'unstrict'),
         },
       },
+      options: [
+        {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
+        },
+      ],
     },
-    {
-      code: `
+    `
 interface Foo {
-  test: string;
   [key: string]: [string] | undefined;
 }
 
 type OptionalFoo = Foo | undefined;
 declare const foo: OptionalFoo;
 foo?.test?.length;
-      `,
-      output: `
+    `,
+    `
 interface Foo {
-  test: string;
-  [key: string]: [string] | undefined;
+  [key: number]: [string] | undefined;
 }
 
 type OptionalFoo = Foo | undefined;
 declare const foo: OptionalFoo;
-foo?.test.length;
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 9,
-          endLine: 9,
-          column: 10,
-          endColumn: 12,
-        },
-      ],
-    },
-    {
-      code: `
-function pick<Obj extends Record<string, 1 | 2 | 3>, Key extends keyof Obj>(
-  obj: Obj,
-  key: Key,
-): Obj[Key] {
-  const k = obj[key];
-  if (obj[key]) {
-    return obj[key];
-  }
-  throw new Error('Boom!');
-}
-
-pick({ foo: 1, bar: 2 }, 'bar');
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysTruthy',
-          line: 7,
-          endLine: 7,
-          column: 7,
-          endColumn: 15,
-        },
-      ],
-    },
-    {
-      code: `
-function getElem(dict: Record<string, { foo: string }>, key: string) {
-  if (dict[key]) {
-    return dict[key].foo;
-  } else {
-    return '';
-  }
-}
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysTruthy',
-          line: 3,
-          endLine: 3,
-          column: 7,
-          endColumn: 16,
-        },
-      ],
-    },
-    {
-      code: `
-declare let foo: {};
+foo?.[1]?.length;
+    `,
+    `
+declare let foo: number | null;
 foo ??= 1;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'neverNullish',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 declare let foo: number;
-foo ??= 1;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'neverNullish',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
-    },
-    {
-      code: `
-declare let foo: null;
-foo ??= null;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysNullish',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
-    },
-    {
-      code: `
-declare let foo: {};
 foo ||= 1;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysTruthy',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
-    },
+    `,
+    `
+declare const foo: { bar: { baz?: number; qux: number } };
+type Key = 'baz' | 'qux';
+declare const key: Key;
+foo.bar[key] ??= 1;
+    `,
+    `
+enum Keys {
+  A = 'A',
+  B = 'B',
+}
+type Foo = {
+  [Keys.A]: number | null;
+  [Keys.B]: number;
+};
+declare const foo: Foo;
+declare const key: Keys;
+foo[key] ??= 1;
+    `,
     {
       code: `
-declare let foo: null;
-foo ||= null;
+declare const foo: { bar?: number };
+foo.bar ??= 1;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysFalsy',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare let foo: {};
-foo &&= 1;
+declare const foo: { bar: { baz?: number } };
+foo['bar'].baz ??= 1;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysTruthy',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare let foo: null;
-foo &&= null;
+declare const foo: { bar: { baz?: number; qux: number } };
+type Key = 'baz' | 'qux';
+declare const key: Key;
+foo.bar[key] ??= 1;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'alwaysFalsy',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 4,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
+    `
+declare let foo: number;
+foo &&= 1;
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] ??= 'default';
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6264
+    `
+function get<Obj, Key extends keyof Obj>(obj: Obj, key: Key) {
+  const value = obj[key];
+  if (value) {
+    return value;
+  }
+  throw new Error('BOOM!');
+}
+
+get({ foo: null }, 'foo');
+    `,
     {
       code: `
-declare const foo: { bar: number };
-foo.bar ??= 1;
+function getElem(dict: Record<string, { foo: string }>, key: string) {
+  if (dict[key]) {
+    return dict[key].foo;
+  } else {
+    return '';
+  }
+}
       `,
-      output: null,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-      errors: [
-        {
-          messageId: 'neverNullish',
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 8,
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
+      },
     },
-    {
-      code: noFormat`
-type Foo = { bar: () => number } | null;
+    `
+type Foo = { bar: () => number | undefined } | null;
 declare const foo: Foo;
 foo?.bar()?.toExponential();
-      `,
-      output: noFormat`
-type Foo = { bar: () => number } | null;
-declare const foo: Foo;
-foo?.bar().toExponential();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 11,
-          endLine: 4,
-          endColumn: 13,
-        },
-      ],
-    },
-    {
-      code: noFormat`
-type Foo = { bar: null | { baz: () => { qux: number } } } | null;
-declare const foo: Foo;
-foo?.bar?.baz()?.qux?.toExponential();
-      `,
-      output: noFormat`
-type Foo = { bar: null | { baz: () => { qux: number } } } | null;
-declare const foo: Foo;
-foo?.bar?.baz().qux.toExponential();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 16,
-          endLine: 4,
-          endColumn: 18,
-        },
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 21,
-          endLine: 4,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: noFormat`
-type Foo = (() => number) | null;
+    `,
+    `
+type Foo = (() => number | undefined) | null;
 declare const foo: Foo;
 foo?.()?.toExponential();
-      `,
-      output: noFormat`
-type Foo = (() => number) | null;
+    `,
+    `
+type FooUndef = () => undefined;
+type FooNum = () => number;
+type Foo = FooUndef | FooNum | null;
 declare const foo: Foo;
-foo?.().toExponential();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 8,
-          endLine: 4,
-          endColumn: 10,
-        },
-      ],
-    },
-    {
-      code: noFormat`
-type Foo = { [key: string]: () => number } | null;
+foo?.()?.toExponential();
+    `,
+    `
+type Foo = { [key: string]: () => number | undefined } | null;
 declare const foo: Foo;
 foo?.['bar']()?.toExponential();
-      `,
-      output: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']().toExponential();
-      `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 15,
-          endLine: 4,
-          endColumn: 17,
-        },
-      ],
-    },
+    `,
     {
-      code: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']?.()?.toExponential();
-      `,
-      output: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']?.().toExponential();
+      code: `
+class ConsistentRand {
+  #rand?: number;
+
+  getCachedRand() {
+    this.#rand ??= Math.random();
+    return this.#rand;
+  }
+}
       `,
-      errors: [
-        {
-          messageId: 'neverOptionalChain',
-          line: 4,
-          column: 17,
-          endLine: 4,
-          endColumn: 19,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
-
-    // "branded" types
-    unnecessaryConditionTest('"" & {}', 'alwaysFalsy'),
-    unnecessaryConditionTest('"" & { __brand: string }', 'alwaysFalsy'),
-    unnecessaryConditionTest(
-      '("" | false) & { __brand: string }',
-      'alwaysFalsy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & ""',
-      'alwaysFalsy',
-    ),
-    unnecessaryConditionTest(
-      '("foo" | "bar") & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '(123 | true) & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '(string | number) & ("foo" | 123) & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & "foo"',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & ("foo" | 123)',
-      'alwaysTruthy',
-    ),
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
index f24a08f9ff6a..419118e88a74 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
@@ -5,168 +5,6 @@ import rule from '../../src/rules/no-unnecessary-parameter-property-assignment';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-parameter-property-assignment', rule, {
-  valid: [
-    `
-class Foo {
-  constructor(foo: string) {}
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {}
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.foo = bar;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: any) {
-    this.foo = foo.bar;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.foo = this.bar;
-  }
-}
-    `,
-    `
-class Foo {
-  foo: string;
-  constructor(foo: string) {
-    this.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  bar: string;
-  constructor(private foo: string) {
-    this.bar = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.bar = () => {
-      this.foo = foo;
-    };
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this[\`\${foo}\`] = foo;
-  }
-}
-    `,
-    `
-function Foo(foo) {
-  this.foo = foo;
-}
-    `,
-    `
-const foo = 'foo';
-this.foo = foo;
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo += foo;
-    this.foo -= foo;
-    this.foo *= foo;
-    this.foo /= foo;
-    this.foo %= foo;
-    this.foo **= foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo += 1;
-    this.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public foo: number,
-    bar: boolean,
-  ) {
-    if (bar) {
-      this.foo += 1;
-    } else {
-      this.foo = foo;
-    }
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo = foo;
-  }
-  init = (this.foo += 1);
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    {
-      const foo = 1;
-      this.foo = foo;
-    }
-  }
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    this[name] = foo;
-  }
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    Foo.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo = foo;
-  }
-  init = (() => {
-    this.foo += 1;
-  })();
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    this[name] = foo;
-  }
-  init = (this[name] = 1);
-  init2 = (Foo.foo = 1);
-}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -178,8 +16,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -194,8 +32,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -210,8 +48,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -226,8 +64,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -243,8 +81,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -259,8 +97,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -275,8 +113,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -291,8 +129,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -307,8 +145,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -326,8 +164,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 7,
           column: 5,
+          line: 7,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -345,8 +183,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 7,
           column: 5,
+          line: 7,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -366,13 +204,13 @@ class Foo {
       `,
       errors: [
         {
-          line: 6,
           column: 9,
+          line: 6,
           messageId: 'unnecessaryAssign',
         },
         {
-          line: 9,
           column: 5,
+          line: 9,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -390,8 +228,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -409,8 +247,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -430,13 +268,13 @@ class Foo {
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryAssign',
         },
         {
-          line: 8,
           column: 7,
+          line: 8,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -453,8 +291,8 @@ class Foo {
       `,
       errors: [
         {
-          line: 5,
           column: 7,
+          line: 5,
           messageId: 'unnecessaryAssign',
         },
       ],
@@ -471,11 +309,173 @@ class Foo {
       `,
       errors: [
         {
-          line: 5,
           column: 7,
+          line: 5,
           messageId: 'unnecessaryAssign',
         },
       ],
     },
   ],
+  valid: [
+    `
+class Foo {
+  constructor(foo: string) {}
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {}
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.foo = bar;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: any) {
+    this.foo = foo.bar;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.foo = this.bar;
+  }
+}
+    `,
+    `
+class Foo {
+  foo: string;
+  constructor(foo: string) {
+    this.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  bar: string;
+  constructor(private foo: string) {
+    this.bar = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.bar = () => {
+      this.foo = foo;
+    };
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this[\`\${foo}\`] = foo;
+  }
+}
+    `,
+    `
+function Foo(foo) {
+  this.foo = foo;
+}
+    `,
+    `
+const foo = 'foo';
+this.foo = foo;
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo += foo;
+    this.foo -= foo;
+    this.foo *= foo;
+    this.foo /= foo;
+    this.foo %= foo;
+    this.foo **= foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo += 1;
+    this.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public foo: number,
+    bar: boolean,
+  ) {
+    if (bar) {
+      this.foo += 1;
+    } else {
+      this.foo = foo;
+    }
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo = foo;
+  }
+  init = (this.foo += 1);
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    {
+      const foo = 1;
+      this.foo = foo;
+    }
+  }
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    this[name] = foo;
+  }
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    Foo.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo = foo;
+  }
+  init = (() => {
+    this.foo += 1;
+  })();
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    this[name] = foo;
+  }
+  init = (this[name] = 1);
+  init2 = (Foo.foo = 1);
+}
+    `,
+  ],
 });
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 3bcded433ff4..fa38be088fd4 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
@@ -9,8 +9,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -18,73 +18,6 @@ const ruleTester = new RuleTester({
 const messageId = 'unnecessaryQualifier';
 
 ruleTester.run('no-unnecessary-qualifier', rule, {
-  valid: [
-    `
-namespace X {
-  export type T = number;
-}
-
-namespace Y {
-  export const x: X.T = 3;
-}
-    `,
-    `
-namespace A {}
-namespace A.B {
-  export type Z = 1;
-}
-    `,
-    `
-enum A {
-  X,
-  Y,
-}
-
-enum B {
-  Z = A.X,
-}
-    `,
-    `
-namespace X {
-  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;
-}
-    `,
-    `
-enum Foo {
-  One,
-}
-
-namespace Foo {
-  export function bar() {
-    return Foo.One;
-  }
-}
-    `,
-    `
-namespace Foo {
-  export enum Foo {
-    One,
-  }
-}
-
-namespace Foo {
-  export function bar() {
-    return Foo.One;
-  }
-}
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -287,4 +220,71 @@ declare module './foo' {
       `,
     },
   ],
+
+  valid: [
+    `
+namespace X {
+  export type T = number;
+}
+
+namespace Y {
+  export const x: X.T = 3;
+}
+    `,
+    `
+namespace A {}
+namespace A.B {
+  export type Z = 1;
+}
+    `,
+    `
+enum A {
+  X,
+  Y,
+}
+
+enum B {
+  Z = A.X,
+}
+    `,
+    `
+namespace X {
+  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;
+}
+    `,
+    `
+enum Foo {
+  One,
+}
+
+namespace Foo {
+  export function bar() {
+    return Foo.One;
+  }
+}
+    `,
+    `
+namespace Foo {
+  export enum Foo {
+    One,
+  }
+}
+
+namespace Foo {
+  export function bar() {
+    return Foo.One;
+  }
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
index 3902b404d9ec..44d077f485cf 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
@@ -1,4 +1,5 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-unnecessary-template-expression';
@@ -9,8 +10,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -21,252 +22,251 @@ const invalidCases: readonly InvalidTestCase<
 >[] = [
   {
     code: '`${1}`;',
-    output: '`1`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 5,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`1`;',
   },
   {
     code: '`${1n}`;',
-    output: '`1`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 6,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`1`;',
   },
   {
     code: '`${0o25}`;',
-    output: '`21`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 8,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`21`;',
   },
   {
     code: '`${0b1010} ${0b1111}`;',
-    output: '`10 15`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 10,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 14,
         endColumn: 20,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`10 15`;',
   },
   {
     code: '`${0x25}`;',
-    output: '`37`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 8,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`37`;',
   },
   {
     code: '`${/a/}`;',
-    output: '`/a/`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 7,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`/a/`;',
   },
   {
     code: '`${/a/gim}`;',
-    output: '`/a/gim`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 10,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`/a/gim`;',
   },
 
   {
     code: noFormat`\`\${    1    }\`;`,
-    output: '`1`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`1`;',
   },
 
   {
     code: noFormat`\`\${    'a'    }\`;`,
-    output: `'a';`,
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: `'a';`,
   },
 
   {
     code: noFormat`\`\${    "a"    }\`;`,
-    output: `"a";`,
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: `"a";`,
   },
 
   {
     code: noFormat`\`\${    'a' + 'b'    }\`;`,
-    output: `'a' + 'b';`,
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: `'a' + 'b';`,
   },
 
   {
     code: '`${true}`;',
-    output: '`true`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 8,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`true`;',
   },
 
   {
     code: noFormat`\`\${    true    }\`;`,
-    output: '`true`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`true`;',
   },
 
   {
     code: '`${null}`;',
-    output: '`null`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 8,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`null`;',
   },
 
   {
     code: noFormat`\`\${    null    }\`;`,
-    output: '`null`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`null`;',
   },
 
   {
     code: '`${undefined}`;',
-    output: '`undefined`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 13,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`undefined`;',
   },
 
   {
     code: noFormat`\`\${    undefined    }\`;`,
-    output: '`undefined`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`undefined`;',
   },
 
   {
     code: '`${Infinity}`;',
-    output: '`Infinity`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 12,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`Infinity`;',
   },
 
   {
     code: '`${NaN}`;',
-    output: '`NaN`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 7,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`NaN`;',
   },
 
   {
     code: "`${'a'} ${'b'}`;",
-    output: '`a b`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 7,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 11,
         endColumn: 14,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`a b`;',
   },
 
   {
     code: noFormat`\`\${   'a'   } \${   'b'   }\`;`,
-    output: '`a b`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
@@ -275,28 +275,29 @@ const invalidCases: readonly InvalidTestCase<
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`a b`;',
   },
 
   {
     code: "`use${'less'}`;",
-    output: '`useless`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
         line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`useless`;',
   },
 
   {
     code: '`use${`less`}`;',
-    output: '`useless`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
         line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`useless`;',
   },
   {
     code: noFormat`
@@ -308,34 +309,34 @@ const invalidCases: readonly InvalidTestCase<
   \`le\${  \`ss\`  }\`
 }\`;
       `,
-    output: [
-      `
-\`use\${
-  \`less\`
-}\`;
-      `,
-      `
-\`useless\`;
-      `,
-    ],
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
         line: 4,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 7,
         column: 3,
         endLine: 7,
+        line: 7,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 7,
         column: 10,
         endLine: 7,
+        line: 7,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: [
+      `
+\`use\${
+  \`less\`
+}\`;
+      `,
+      `
+\`useless\`;
+      `,
+    ],
   },
   {
     code: noFormat`
@@ -343,433 +344,428 @@ const invalidCases: readonly InvalidTestCase<
   \`less\`
 }\`;
       `,
-    output: `
-\`useless\`;
-      `,
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 3,
         column: 3,
         endColumn: 9,
+        line: 3,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: `
+\`useless\`;
+      `,
   },
 
   {
     code: "`${'1 + 1 ='} ${2}`;",
-    output: '`1 + 1 = 2`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 13,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 17,
         endColumn: 18,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`1 + 1 = 2`;',
   },
 
   {
     code: "`${'a'} ${true}`;",
-    output: '`a true`;',
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 7,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 11,
         endColumn: 15,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`a true`;',
   },
 
   {
     code: "`${String(Symbol.for('test'))}`;",
-    output: "String(Symbol.for('test'));",
     errors: [
       {
-        messageId: 'noUnnecessaryTemplateExpression',
-        line: 1,
         column: 4,
         endColumn: 30,
+        line: 1,
+        messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: "String(Symbol.for('test'));",
   },
 
   {
     code: "`${'`'}`;",
-    output: "'`';",
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: "'`';",
   },
 
   {
     code: "`back${'`'}tick`;",
-    output: '`back\\`tick`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`back\\`tick`;',
   },
 
   {
     code: "`dollar${'${`this is test`}'}sign`;",
-    output: '`dollar\\${\\`this is test\\`}sign`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`dollar\\${\\`this is test\\`}sign`;',
   },
 
   {
     code: '`complex${\'`${"`${test}`"}`\'}case`;',
-    output: '`complex\\`\\${"\\`\\${test}\\`"}\\`case`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`complex\\`\\${"\\`\\${test}\\`"}\\`case`;',
   },
 
   {
     code: "`some ${'\\\\${test}'} string`;",
-    output: '`some \\\\\\${test} string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some \\\\\\${test} string`;',
   },
 
   {
     code: "`some ${'\\\\`'} string`;",
-    output: '`some \\\\\\` string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some \\\\\\` string`;',
   },
 
   {
     code: '`some ${/`/} string`;',
-    output: '`some /\\`/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\`/ string`;',
   },
   {
     code: '`some ${/\\`/} string`;',
-    output: '`some /\\\\\\`/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\`/ string`;',
   },
   {
     code: '`some ${/\\\\`/} string`;',
-    output: '`some /\\\\\\\\\\`/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\\\\\`/ string`;',
   },
   {
     code: '`some ${/\\\\\\`/} string`;',
-    output: '`some /\\\\\\\\\\\\\\`/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\\\\\\\\\`/ string`;',
   },
   {
     code: '`some ${/${}/} string`;',
-    output: '`some /\\${}/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\${}/ string`;',
   },
   {
     code: '`some ${/$ {}/} string`;',
-    output: '`some /$ {}/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /$ {}/ string`;',
   },
   {
     code: '`some ${/\\\\/} string`;',
-    output: '`some /\\\\\\\\/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\\\/ string`;',
   },
   {
     code: '`some ${/\\\\\\b/} string`;',
-    output: '`some /\\\\\\\\\\\\b/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\\\\\\\b/ string`;',
   },
   {
     code: '`some ${/\\\\\\\\/} string`;',
-    output: '`some /\\\\\\\\\\\\\\\\/ string`;',
     errors: [
       {
         messageId: 'noUnnecessaryTemplateExpression',
       },
     ],
+    output: '`some /\\\\\\\\\\\\\\\\/ string`;',
   },
   {
     code: "` ${''} `;",
-    output: '`  `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '`  `;',
   },
   {
     code: noFormat`\` \${""} \`;`,
-    output: '`  `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '`  `;',
   },
   {
     code: '` ${``} `;',
-    output: '`  `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '`  `;',
   },
   {
     code: noFormat`\` \${'\\\`'} \`;`,
-    output: '` \\` `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\` `;',
   },
   {
     code: "` ${'\\\\`'} `;",
-    output: '` \\\\\\` `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\` `;',
   },
   {
     code: "` ${'$'}{} `;",
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: noFormat`\` \${'\\$'}{} \`;`,
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: "` ${'\\\\$'}{} `;",
-    output: '` \\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\${} `;',
   },
   {
     code: "` ${'\\\\$ '}{} `;",
-    output: '` \\\\$ {} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\$ {} `;',
   },
   {
     code: noFormat`\` \${'\\\\\\$'}{} \`;`,
-    output: '` \\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\${} `;',
   },
   {
     code: "` \\\\${'\\\\$'}{} `;",
-    output: '` \\\\\\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\\\\\${} `;',
   },
   {
     code: "` $${'{$'}{} `;",
-    output: '` \\${\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${\\${} `;',
   },
   {
     code: "` $${'${$'}{} `;",
-    output: '` $\\${\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` $\\${\\${} `;',
   },
   {
     code: "` ${'foo$'}{} `;",
-    output: '` foo\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` foo\\${} `;',
   },
   {
     code: '` ${`$`} `;',
-    output: '` $ `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` $ `;',
   },
   {
     code: '` ${`$`}{} `;',
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: '` ${`$`} {} `;',
-    output: '` $ {} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` $ {} `;',
   },
   {
     code: '` ${`$`}${undefined}{} `;',
-    output: ['` $${undefined}{} `;', '` $undefined{} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` $${undefined}{} `;', '` $undefined{} `;'],
   },
   {
     code: '` ${`foo$`}{} `;',
-    output: '` foo\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` foo\\${} `;',
   },
   {
     code: "` ${'$'}${''}{} `;",
-    output: ["` \\$${''}{} `;", '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\$${''}{} `;", '` \\${} `;'],
   },
   {
     code: "` ${'$'}${``}{} `;",
-    output: ['` \\$${``}{} `;', '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` \\$${``}{} `;', '` \\${} `;'],
   },
   {
     code: "` ${'foo$'}${''}${``}{} `;",
-    output: ["` foo\\$${''}{} `;", '` foo\\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` foo\\$${''}{} `;", '` foo\\${} `;'],
   },
   {
     code: "` $${'{}'} `;",
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: "` $${undefined}${'{}'} `;",
-    output: ["` $undefined${'{}'} `;", '` $undefined{} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` $undefined${'{}'} `;", '` $undefined{} `;'],
   },
   {
     code: "` $${''}${undefined}${'{}'} `;",
-    output: ['` $${undefined}{} `;', '` $undefined{} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` $${undefined}{} `;', '` $undefined{} `;'],
   },
   {
     code: "` \\$${'{}'} `;",
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: "` $${'foo'}${'{'} `;",
-    output: ["` $foo${'{'} `;", '` $foo{ `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` $foo${'{'} `;", '` $foo{ `;'],
   },
   {
     code: "` $${'{ foo'}${'{'} `;",
-    output: ["` \\${ foo${'{'} `;", '` \\${ foo{ `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\${ foo${'{'} `;", '` \\${ foo{ `;'],
   },
   {
     code: "` \\\\$${'{}'} `;",
-    output: '` \\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\${} `;',
   },
   {
     code: "` \\\\\\$${'{}'} `;",
-    output: '` \\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\\\\\${} `;',
   },
   {
     code: "` foo$${'{}'} `;",
-    output: '` foo\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` foo\\${} `;',
   },
   {
     code: "` $${''}${'{}'} `;",
-    output: ["` \\$${'{}'} `;", '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\$${'{}'} `;", '` \\${} `;'],
   },
   {
     code: "` $${''} `;",
-    output: '` $ `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` $ `;',
   },
   {
     code: '` $${`{}`} `;',
-    output: '` \\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\${} `;',
   },
   {
     code: '` $${``}${`{}`} `;',
-    output: ['` \\$${`{}`} `;', '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` \\$${`{}`} `;', '` \\${} `;'],
   },
   {
     code: '` $${``}${`foo{}`} `;',
-    output: ['` $${`foo{}`} `;', '` $foo{} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` $${`foo{}`} `;', '` $foo{} `;'],
   },
   {
     code: "` $${`${''}${`${``}`}`}${`{a}`} `;",
-    output: [
-      "` \\$${''}${`${``}`}${`{a}`} `;",
-      '` \\$${``}{a} `;',
-      '` \\${a} `;',
-    ],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
@@ -777,109 +773,114 @@ const invalidCases: readonly InvalidTestCase<
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: [
+      "` \\$${''}${`${``}`}${`{a}`} `;",
+      '` \\$${``}{a} `;',
+      '` \\${a} `;',
+    ],
   },
   {
     code: "` $${''}${`{}`} `;",
-    output: ['` \\$${`{}`} `;', '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` \\$${`{}`} `;', '` \\${} `;'],
   },
   {
     code: "` $${``}${'{}'} `;",
-    output: ["` \\$${'{}'} `;", '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\$${'{}'} `;", '` \\${} `;'],
   },
   {
     code: "` $${''}${``}${'{}'} `;",
-    output: ['` \\$${``}{} `;', '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ['` \\$${``}{} `;', '` \\${} `;'],
   },
   {
     code: "` ${'$'} `;",
-    output: '` $ `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` $ `;',
   },
   {
     code: "` ${'$'}${'{}'} `;",
-    output: ["` \\$${'{}'} `;", '` \\${} `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\$${'{}'} `;", '` \\${} `;'],
   },
   {
     code: "` ${'$'}${''}${'{'} `;",
-    output: ["` \\$${''}{ `;", '` \\${ `;'],
     errors: [
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
       { messageId: 'noUnnecessaryTemplateExpression' },
     ],
+    output: ["` \\$${''}{ `;", '` \\${ `;'],
   },
   {
     code: '` ${`\n\\$`}{} `;',
-    output: '` \n\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \n\\${} `;',
   },
   {
     code: '` ${`\n\\\\$`}{} `;',
-    output: '` \n\\\\\\${} `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \n\\\\\\${} `;',
   },
 
   {
     code: "`${'\\u00E5'}`;",
-    output: "'\\u00E5';",
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: "'\\u00E5';",
   },
   {
     code: "`${'\\n'}`;",
-    output: "'\\n';",
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: "'\\n';",
   },
   {
     code: "` ${'\\u00E5'} `;",
-    output: '` \\u00E5 `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\u00E5 `;',
   },
   {
     code: "` ${'\\n'} `;",
-    output: '` \\n `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\n `;',
   },
   {
     code: noFormat`\` \${"\\n"} \`;`,
-    output: '` \\n `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\n `;',
   },
   {
     code: '` ${`\\n`} `;',
-    output: '` \\n `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\n `;',
   },
   {
     code: noFormat`\` \${ 'A\\u0307\\u0323' } \`;`,
-    output: '` A\\u0307\\u0323 `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` A\\u0307\\u0323 `;',
   },
   {
     code: "` ${'👨‍👩‍👧‍👦'} `;",
-    output: '` 👨‍👩‍👧‍👦 `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` 👨‍👩‍👧‍👦 `;',
   },
   {
     code: "` ${'\\ud83d\\udc68'} `;",
-    output: '` \\ud83d\\udc68 `;',
     errors: [{ messageId: 'noUnnecessaryTemplateExpression' }],
+    output: '` \\ud83d\\udc68 `;',
   },
 ];
 
@@ -898,6 +899,123 @@ describe('fixer should not change runtime value', () => {
 });
 
 ruleTester.run('no-unnecessary-template-expression', rule, {
+  invalid: [
+    ...invalidCases,
+    {
+      code: `
+        function func<T extends string>(arg: T) {
+          \`\${arg}\`;
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 17,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        function func<T extends string>(arg: T) {
+          arg;
+        }
+      `,
+    },
+    {
+      code: `
+        declare const b: 'b';
+        \`a\${b}\${'c'}\`;
+      `,
+      errors: [
+        {
+          column: 17,
+          endColumn: 20,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const b: 'b';
+        \`a\${b}c\`;
+      `,
+    },
+    {
+      code: `
+declare const nested: string, interpolation: string;
+\`use\${\`less\${nested}\${interpolation}\`}\`;
+      `,
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+declare const nested: string, interpolation: string;
+\`useless\${nested}\${interpolation}\`;
+      `,
+    },
+    {
+      code: noFormat`
+        declare const string: 'a';
+        \`\${   string   }\`;
+      `,
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const string: 'a';
+        string;
+      `,
+    },
+    {
+      code: `
+        declare const string: 'a';
+        \`\${string}\`;
+      `,
+      errors: [
+        {
+          column: 12,
+          endColumn: 18,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const string: 'a';
+        string;
+      `,
+    },
+    {
+      code: `
+        declare const intersection: string & { _brand: 'test-brand' };
+        \`\${intersection}\`;
+      `,
+      errors: [
+        {
+          column: 12,
+          endColumn: 24,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const intersection: string & { _brand: 'test-brand' };
+        intersection;
+      `,
+    },
+    {
+      code: "true ? `${'test' || ''}`.trim() : undefined;",
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: "true ? ('test' || '').trim() : undefined;",
+    },
+  ],
+
   valid: [
     "const string = 'a';",
     'const string = `a`;',
@@ -1020,121 +1138,4 @@ ruleTester.run('no-unnecessary-template-expression', rule, {
 \`not a useless \${String.raw\`nested interpolation \${a}\`}\`;
     `,
   ],
-
-  invalid: [
-    ...invalidCases,
-    {
-      code: `
-        function func<T extends string>(arg: T) {
-          \`\${arg}\`;
-        }
-      `,
-      output: `
-        function func<T extends string>(arg: T) {
-          arg;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-          line: 3,
-          column: 14,
-          endColumn: 17,
-        },
-      ],
-    },
-    {
-      code: `
-        declare const b: 'b';
-        \`a\${b}\${'c'}\`;
-      `,
-      output: `
-        declare const b: 'b';
-        \`a\${b}c\`;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-          line: 3,
-          column: 17,
-          endColumn: 20,
-        },
-      ],
-    },
-    {
-      code: `
-declare const nested: string, interpolation: string;
-\`use\${\`less\${nested}\${interpolation}\`}\`;
-      `,
-      output: `
-declare const nested: string, interpolation: string;
-\`useless\${nested}\${interpolation}\`;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-    },
-    {
-      code: noFormat`
-        declare const string: 'a';
-        \`\${   string   }\`;
-      `,
-      output: `
-        declare const string: 'a';
-        string;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-    },
-    {
-      code: `
-        declare const string: 'a';
-        \`\${string}\`;
-      `,
-      output: `
-        declare const string: 'a';
-        string;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-          line: 3,
-          column: 12,
-          endColumn: 18,
-        },
-      ],
-    },
-    {
-      code: `
-        declare const intersection: string & { _brand: 'test-brand' };
-        \`\${intersection}\`;
-      `,
-      output: `
-        declare const intersection: string & { _brand: 'test-brand' };
-        intersection;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-          line: 3,
-          column: 12,
-          endColumn: 24,
-        },
-      ],
-    },
-    {
-      code: "true ? `${'test' || ''}`.trim() : undefined;",
-      output: "true ? ('test' || '').trim() : undefined;",
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-    },
-  ],
 });
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 81ecfd23060f..c41c65182492 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
@@ -8,154 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 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>();
-    `,
-    `
-declare const f: unknown;
-f<string>\`\`;
-    `,
-    `
-function f<T = number>(template: TemplateStringsArray) {}
-f<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>>();
-    `,
-    `
-type A<T = Element> = T;
-type B = A<HTMLInputElement>;
-    `,
-    `
-type A<T = Map<string, string>> = T;
-type B = A<Map<string, number>>;
-    `,
-    `
-type A = Map<string, string>;
-type B<T = A> = T;
-type C2 = B<Map<string, number>>;
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -318,8 +177,8 @@ bar<F<string>>();
       `,
       errors: [
         {
-          line: 4,
           column: 5,
+          line: 4,
           messageId: 'unnecessaryTypeParameter',
         },
       ],
@@ -341,8 +200,8 @@ declare module 'bar' {
       `,
       errors: [
         {
-          line: 4,
           column: 12,
+          line: 4,
           messageId: 'unnecessaryTypeParameter',
         },
       ],
@@ -453,4 +312,145 @@ type F = E;
       `,
     },
   ],
+  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>();
+    `,
+    `
+declare const f: unknown;
+f<string>\`\`;
+    `,
+    `
+function f<T = number>(template: TemplateStringsArray) {}
+f<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>>();
+    `,
+    `
+type A<T = Element> = T;
+type B = A<HTMLInputElement>;
+    `,
+    `
+type A<T = Map<string, string>> = T;
+type B = A<Map<string, number>>;
+    `,
+    `
+type A = Map<string, string>;
+type B<T = A> = T;
+type C2 = B<Map<string, number>>;
+    `,
+  ],
 });
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 434a12810a5d..59961451e4f5 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
@@ -1,6 +1,5 @@
-import path from 'node:path';
-
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
+import path from 'node:path';
 
 import rule from '../../src/rules/no-unnecessary-type-assertion';
 
@@ -16,616 +15,281 @@ const ruleTester = new RuleTester({
 });
 
 const optionsWithOnUncheckedIndexedAccess = {
-  tsconfigRootDir: rootDir,
   project: './tsconfig.noUncheckedIndexedAccess.json',
+  tsconfigRootDir: rootDir,
 };
 
 const optionsWithExactOptionalPropertyTypes = {
-  tsconfigRootDir: rootDir,
   project: './tsconfig.exactOptionalPropertyTypes.json',
+  tsconfigRootDir: rootDir,
 };
 
 ruleTester.run('no-unnecessary-type-assertion', rule, {
-  valid: [
-    `
-import { TSESTree } from '@typescript-eslint/utils';
-declare const member: TSESTree.TSEnumMember;
-if (
-  member.id.type === AST_NODE_TYPES.Literal &&
-  typeof member.id.value === 'string'
-) {
-  const name = member.id as TSESTree.StringLiteral;
-}
-    `,
-    `
-      const c = 1;
-      let z = c as number;
-    `,
-    `
-      const c = 1;
-      let z = c as const;
-    `,
-    `
-      const c = 1;
-      let z = c as 1;
-    `,
-    `
-      type Bar = 'bar';
-      const data = {
-        x: 'foo' as 'foo',
-        y: 'bar' as Bar,
-      };
-    `,
-    "[1, 2, 3, 4, 5].map(x => [x, 'A' + x] as [number, string]);",
-    `
-      let x: Array<[number, string]> = [1, 2, 3, 4, 5].map(
-        x => [x, 'A' + x] as [number, string],
-      );
-    `,
-    'let y = 1 as 1;',
-    'const foo = 3 as number;',
-    'const foo = <number>3;',
-    `
-type Tuple = [3, 'hi', 'bye'];
-const foo = [3, 'hi', 'bye'] as Tuple;
-    `,
-    `
-type PossibleTuple = {};
-const foo = {} 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;
-    `,
-    `
-let bar: number | undefined = x;
-let foo: number = bar!;
-    `,
-    `
-declare const a: { data?: unknown };
-
-const x = a.data!;
-    `,
-    `
-declare function foo(arg?: number): number | void;
-const bar: number = foo()!;
-    `,
+  invalid: [
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
     {
-      code: `
-type Foo = number;
-const foo = (3 + 5) as Foo;
-      `,
-      options: [{ typesToIgnore: ['Foo'] }],
+      code: 'const a = `a` as const;',
+      errors: [{ line: 1, messageId: 'unnecessaryAssertion' }],
+      output: 'const a = `a`;',
     },
     {
-      code: 'const foo = (3 + 5) as any;',
-      options: [{ typesToIgnore: ['any'] }],
+      code: "const a = 'a' as const;",
+      errors: [{ line: 1, messageId: 'unnecessaryAssertion' }],
+      output: "const a = 'a';",
     },
     {
-      code: "(Syntax as any).ArrayExpression = 'foo';",
-      options: [{ typesToIgnore: ['any'] }],
+      code: "const a = <const>'a';",
+      errors: [{ line: 1, messageId: 'unnecessaryAssertion' }],
+      output: "const a = 'a';",
     },
     {
-      code: 'const foo = (3 + 5) as string;',
-      options: [{ typesToIgnore: ['string'] }],
+      code: 'const foo = <3>3;',
+      errors: [{ column: 13, line: 1, messageId: 'unnecessaryAssertion' }],
+      output: 'const foo = 3;',
     },
     {
-      code: `
-type Foo = number;
-const foo = <Foo>(3 + 5);
-      `,
-      options: [{ typesToIgnore: ['Foo'] }],
+      code: 'const foo = 3 as 3;',
+      errors: [{ column: 13, line: 1, messageId: 'unnecessaryAssertion' }],
+      output: 'const foo = 3;',
     },
-    // 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: undefined | number;
-bar! + 1;
-    `,
-    `
-let bar: number, baz: number;
-bar! + 1;
-    `,
-    `
-function foo<T extends string | undefined>(bar: T) {
-  return bar!;
-}
-    `,
-    `
-declare function nonNull(s: string);
-let s: string | null = null;
-nonNull(s!);
-    `,
-    `
-const x: number | null = null;
-const y: number = x!;
-    `,
-    `
-const x: number | null = null;
-class Foo {
-  prop: number = x!;
-}
-    `,
-    `
-      declare const y: number | null;
-      console.log(y!);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/529
-    `
-declare function foo(str?: string): void;
-declare const str: string | null;
-
-foo(str!);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/532
-    `
-declare function a(a: string): any;
-declare const b: string | null;
-class Mx {
-  @a(b!)
-  private prop = 1;
-}
-    `,
-    // 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 | 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 };
-  }
-}
-
-function Test(props: { id?: null | string | number }) {
-  return <div key={props.id!} />;
-}
+        type Foo = 3;
+        const foo = <Foo>3;
+      `,
+      errors: [{ column: 21, line: 3, messageId: 'unnecessaryAssertion' }],
+      output: `
+        type Foo = 3;
+        const foo = 3;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
     },
     {
       code: `
-const a = [1, 2];
-const b = [3, 4];
-const c = [...a, ...b] as const;
+        type Foo = 3;
+        const foo = 3 as Foo;
+      `,
+      errors: [{ column: 21, line: 3, messageId: 'unnecessaryAssertion' }],
+      output: `
+        type Foo = 3;
+        const foo = 3;
       `,
-    },
-    {
-      code: 'const a = [1, 2] as const;',
-    },
-    {
-      code: "const a = { foo: 'foo' } as const;",
     },
     {
       code: `
-const a = [1, 2];
-const b = [3, 4];
-const c = <const>[...a, ...b];
+const foo = 3;
+const bar = foo!;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 3,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = 3;
+const bar = foo;
       `,
-    },
-    {
-      code: 'const a = <const>[1, 2];',
-    },
-    {
-      code: "const a = <const>{ foo: 'foo' };",
     },
     {
       code: `
-let a: number | undefined;
-let b: number | undefined;
-let c: number;
-a = b;
-c = b!;
-a! -= 1;
+const foo = (3 + 5) as number;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + 5);
       `,
     },
     {
       code: `
-let a: { b?: string } | undefined;
-a!.b = '';
-      `,
-    },
-    `
-let value: number | undefined;
-let values: number[] = [];
-
-value = values.pop()!;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = foo()!;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = foo() as number;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = <number>foo();
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = arr[0]!;
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = arr[0] as object;
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = <object>arr[0];
-    `,
-    {
-      code: `
-function foo(item: string) {}
-function bar(items: string[]) {
-  for (let i = 0; i < items.length; i++) {
-    foo(items[i]!);
-  }
-}
-      `,
-      languageOptions: { parserOptions: optionsWithOnUncheckedIndexedAccess },
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
-    `
-let myString = 'foo';
-const templateLiteral = \`\${myString}-somethingElse\` as const;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
-    `
-let myString = 'foo';
-const templateLiteral = <const>\`\${myString}-somethingElse\`;
-    `,
-    'let a = `a` as const;',
-    {
-      code: `
-declare const foo: {
-  a?: string;
-};
-const bar = foo.a as string;
-      `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
-declare const foo: {
-  a?: string | undefined;
-};
-const bar = foo.a as string;
-      `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
-declare const foo: {
-  a: string;
-};
-const bar = foo.a as string | undefined;
-      `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
-declare const foo: {
-  a?: string | null | number;
-};
-const bar = foo.a as string | undefined;
-      `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
-declare const foo: {
-  a?: string | number;
-};
-const bar = foo.a as string | undefined | bigint;
-      `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
-if (Math.random()) {
-  {
-    var x = 1;
-  }
-}
-x!;
-      `,
-    },
-  ],
-
-  invalid: [
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
-    {
-      code: 'const a = `a` as const;',
-      output: 'const a = `a`;',
-      errors: [{ messageId: 'unnecessaryAssertion', line: 1 }],
-    },
-    {
-      code: "const a = 'a' as const;",
-      output: "const a = 'a';",
-      errors: [{ messageId: 'unnecessaryAssertion', line: 1 }],
-    },
-    {
-      code: "const a = <const>'a';",
-      output: "const a = 'a';",
-      errors: [{ messageId: 'unnecessaryAssertion', line: 1 }],
-    },
-    {
-      code: 'const foo = <3>3;',
-      output: 'const foo = 3;',
-      errors: [{ messageId: 'unnecessaryAssertion', line: 1, column: 13 }],
-    },
-    {
-      code: 'const foo = 3 as 3;',
-      output: 'const foo = 3;',
-      errors: [{ messageId: 'unnecessaryAssertion', line: 1, column: 13 }],
-    },
-    {
-      code: `
-        type Foo = 3;
-        const foo = <Foo>3;
-      `,
-      output: `
-        type Foo = 3;
-        const foo = 3;
-      `,
-      errors: [{ messageId: 'unnecessaryAssertion', line: 3, column: 21 }],
-    },
-    {
-      code: `
-        type Foo = 3;
-        const foo = 3 as Foo;
-      `,
-      output: `
-        type Foo = 3;
-        const foo = 3;
-      `,
-      errors: [{ messageId: 'unnecessaryAssertion', line: 3, column: 21 }],
-    },
-    {
-      code: `
-const foo = 3;
-const bar = foo!;
-      `,
-      output: `
-const foo = 3;
-const bar = foo;
+const foo = <number>(3 + 5);
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
           column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
-    },
-    {
-      code: `
-const foo = (3 + 5) as number;
-      `,
       output: `
 const foo = (3 + 5);
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
     },
     {
       code: `
-const foo = <number>(3 + 5);
-      `,
-      output: `
-const foo = (3 + 5);
+type Foo = number;
+const foo = (3 + 5) as Foo;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
           column: 13,
+          line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
-    },
-    {
-      code: `
-type Foo = number;
-const foo = (3 + 5) as Foo;
-      `,
       output: `
 type Foo = number;
 const foo = (3 + 5);
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
-          column: 13,
-        },
-      ],
     },
     {
       code: `
 type Foo = number;
 const foo = <Foo>(3 + 5);
-      `,
-      output: `
-type Foo = number;
-const foo = (3 + 5);
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
           column: 13,
+          line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+type Foo = number;
+const foo = (3 + 5);
+      `,
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/453
     {
       code: `
 let bar: number = 1;
 bar! + 1;
-      `,
-      output: `
-let bar: number = 1;
-bar + 1;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+let bar: number = 1;
+bar + 1;
+      `,
     },
     {
       // definite declaration operator
       code: `
 let bar!: number;
 bar! + 1;
-      `,
-      output: `
-let bar!: number;
-bar + 1;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+let bar!: number;
+bar + 1;
+      `,
     },
     {
       code: `
 let bar: number | undefined;
 bar = 1;
 bar! + 1;
-      `,
-      output: `
-let bar: number | undefined;
-bar = 1;
-bar + 1;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 4,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+let bar: number | undefined;
+bar = 1;
+bar + 1;
+      `,
     },
     {
       code: `
         declare const y: number;
         console.log(y!);
       `,
+      errors: [{ messageId: 'unnecessaryAssertion' }],
       output: `
         declare const y: number;
         console.log(y);
       `,
-      errors: [{ messageId: 'unnecessaryAssertion' }],
     },
     {
       code: 'Proxy!;',
-      output: 'Proxy;',
       errors: [{ messageId: 'unnecessaryAssertion' }],
+      output: 'Proxy;',
     },
     {
       code: `
 function foo<T extends string>(bar: T) {
   return bar!;
-}
-      `,
-      output: `
-function foo<T extends string>(bar: T) {
-  return bar;
 }
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+function foo<T extends string>(bar: T) {
+  return bar;
+}
+      `,
     },
     {
       code: `
 declare const foo: Foo;
 const bar = <Foo>foo;
-      `,
-      output: `
-declare const foo: Foo;
-const bar = foo;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+declare const foo: Foo;
+const bar = foo;
+      `,
     },
     {
       code: `
 declare function nonNull(s: string | null);
 let s: string | null = null;
 nonNull(s!);
-      `,
-      output: `
-declare function nonNull(s: string | null);
-let s: string | null = null;
-nonNull(s);
       `,
       errors: [
         {
-          messageId: 'contextuallyUnnecessary',
           line: 4,
+          messageId: 'contextuallyUnnecessary',
         },
       ],
+      output: `
+declare function nonNull(s: string | null);
+let s: string | null = null;
+nonNull(s);
+      `,
     },
     {
       code: `
 const x: number | null = null;
 const y: number | null = x!;
-      `,
-      output: `
-const x: number | null = null;
-const y: number | null = x;
       `,
       errors: [
         {
-          messageId: 'contextuallyUnnecessary',
           line: 3,
+          messageId: 'contextuallyUnnecessary',
         },
       ],
+      output: `
+const x: number | null = null;
+const y: number | null = x;
+      `,
     },
     {
       code: `
@@ -634,18 +298,18 @@ class Foo {
   prop: number | null = x!;
 }
       `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'contextuallyUnnecessary',
+        },
+      ],
       output: `
 const x: number | null = null;
 class Foo {
   prop: number | null = x;
 }
       `,
-      errors: [
-        {
-          messageId: 'contextuallyUnnecessary',
-          line: 4,
-        },
-      ],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/532
     {
@@ -657,6 +321,12 @@ class Mx {
   private prop = 1;
 }
       `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
       output: `
 declare function a(a: string): any;
 const b = 'asdf';
@@ -665,12 +335,6 @@ class Mx {
   private prop = 1;
 }
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 5,
-        },
-      ],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/982
     {
@@ -683,23 +347,12 @@ declare namespace JSX {
 
 function Test(props: { id?: string | number }) {
   return <div key={props.id!} />;
-}
-      `,
-      output: `
-declare namespace JSX {
-  interface IntrinsicElements {
-    div: { key?: string | number };
-  }
-}
-
-function Test(props: { id?: string | number }) {
-  return <div key={props.id} />;
 }
       `,
       errors: [
         {
-          messageId: 'contextuallyUnnecessary',
           line: 9,
+          messageId: 'contextuallyUnnecessary',
         },
       ],
       languageOptions: {
@@ -709,6 +362,17 @@ function Test(props: { id?: string | number }) {
           },
         },
       },
+      output: `
+declare namespace JSX {
+  interface IntrinsicElements {
+    div: { key?: string | number };
+  }
+}
+
+function Test(props: { id?: string | number }) {
+  return <div key={props.id} />;
+}
+      `,
     },
     {
       code: `
@@ -717,179 +381,179 @@ let y: number | undefined;
 y = x!;
 y! = 0;
       `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'contextuallyUnnecessary',
+        },
+      ],
       output: `
 let x: number | undefined;
 let y: number | undefined;
 y = x!;
 y = 0;
       `,
-      errors: [
-        {
-          messageId: 'contextuallyUnnecessary',
-          line: 5,
-        },
-      ],
     },
     {
       code: `
 declare function foo(arg?: number): number | void;
 const bar: number | void = foo()!;
-      `,
-      output: `
-declare function foo(arg?: number): number | void;
-const bar: number | void = foo();
       `,
       errors: [
         {
-          messageId: 'contextuallyUnnecessary',
-          line: 3,
           column: 28,
           endColumn: 34,
+          line: 3,
+          messageId: 'contextuallyUnnecessary',
         },
       ],
+      output: `
+declare function foo(arg?: number): number | void;
+const bar: number | void = foo();
+      `,
     },
     {
       code: `
 declare function foo(): number;
 const a = foo()!;
-      `,
-      output: `
-declare function foo(): number;
-const a = foo();
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
           column: 11,
           endColumn: 17,
+          line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+declare function foo(): number;
+const a = foo();
+      `,
     },
     {
       code: `
 const b = new Date()!;
-      `,
-      output: `
-const b = new Date();
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+const b = new Date();
+      `,
     },
     {
       code: `
 const b = (1 + 1)!;
-      `,
-      output: `
-const b = (1 + 1);
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
           column: 11,
           endColumn: 19,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+const b = (1 + 1);
+      `,
     },
     {
       code: `
 declare function foo(): number;
 const a = foo() as number;
-      `,
-      output: `
-declare function foo(): number;
-const a = foo();
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+declare function foo(): number;
+const a = foo();
+      `,
     },
     {
       code: `
 declare function foo(): number;
 const a = <number>foo();
-      `,
-      output: `
-declare function foo(): number;
-const a = foo();
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
           line: 3,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+declare function foo(): number;
+const a = foo();
+      `,
     },
     {
       code: `
 type RT = { log: () => void };
 declare function foo(): RT;
 (foo() as RT).log;
-      `,
-      output: `
-type RT = { log: () => void };
-declare function foo(): RT;
-(foo()).log;
       `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+type RT = { log: () => void };
+declare function foo(): RT;
+(foo()).log;
+      `,
     },
     {
       code: `
 declare const arr: object[];
 const item = arr[0]!;
-      `,
-      output: `
-declare const arr: object[];
-const item = arr[0];
       `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+declare const arr: object[];
+const item = arr[0];
+      `,
     },
     {
       code: noFormat`
 const foo = (  3 + 5  ) as number;
-      `,
-      output: `
-const foo = (  3 + 5  );
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
           column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+const foo = (  3 + 5  );
+      `,
     },
     {
       code: noFormat`
 const foo = (  3 + 5  ) /*as*/ as number;
-      `,
-      output: `
-const foo = (  3 + 5  ) /*as*/;
       `,
       errors: [
         {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
           column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+const foo = (  3 + 5  ) /*as*/;
+      `,
     },
     {
       code: noFormat`
@@ -899,124 +563,502 @@ const foo = (  3 + 5
     number
   );
       `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
       output: `
 const foo = (  3 + 5
   ) /*as*/;
       `,
+    },
+    {
+      code: noFormat`
+const foo = (3 + (5 as number) ) as number;
+      `,
       errors: [
         {
+          column: 13,
+          line: 2,
           messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + (5 as number) );
+      `,
+    },
+    {
+      code: noFormat`
+const foo = 3 + 5/*as*/ as number;
+      `,
+      errors: [
+        {
+          column: 13,
           line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = 3 + 5/*as*/;
+      `,
+    },
+    {
+      code: noFormat`
+const foo = 3 + 5/*a*/ /*b*/ as number;
+      `,
+      errors: [
+        {
           column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
         },
       ],
+      output: `
+const foo = 3 + 5/*a*/ /*b*/;
+      `,
     },
     {
       code: noFormat`
-const foo = (3 + (5 as number) ) as number;
+const foo = <(number)>(3 + 5);
       `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
       output: `
-const foo = (3 + (5 as number) );
+const foo = (3 + 5);
+      `,
+    },
+    {
+      code: noFormat`
+const foo = < ( number ) >( 3 + 5 );
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = ( 3 + 5 );
+      `,
+    },
+    {
+      code: noFormat`
+const foo = <number> /* a */ (3 + 5);
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo =  /* a */ (3 + 5);
+      `,
+    },
+    {
+      code: noFormat`
+const foo = <number /* a */>(3 + 5);
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + 5);
+      `,
+    },
+    // onUncheckedIndexedAccess = false
+    {
+      code: `
+function foo(item: string) {}
+function bar(items: string[]) {
+  for (let i = 0; i < items.length; i++) {
+    foo(items[i]!);
+  }
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+function foo(item: string) {}
+function bar(items: string[]) {
+  for (let i = 0; i < items.length; i++) {
+    foo(items[i]);
+  }
+}
+      `,
+    },
+    // exactOptionalPropertyTypes = true
+    {
+      code: `
+declare const foo: {
+  a?: string;
+};
+const bar = foo.a as string | undefined;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      output: `
+declare const foo: {
+  a?: string;
+};
+const bar = foo.a;
+      `,
+    },
+    {
+      code: `
+declare const foo: {
+  a?: string | undefined;
+};
+const bar = foo.a as string | undefined;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      output: `
+declare const foo: {
+  a?: string | undefined;
+};
+const bar = foo.a;
+      `,
+    },
+    {
+      code: `
+varDeclarationFromFixture!;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+varDeclarationFromFixture;
+      `,
+    },
+    {
+      code: `
+var x = 1;
+x!;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+var x = 1;
+x;
+      `,
+    },
+    {
+      code: `
+var x = 1;
+{
+  x!;
+}
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+var x = 1;
+{
+  x;
+}
+      `,
+    },
+  ],
+
+  valid: [
+    `
+import { TSESTree } from '@typescript-eslint/utils';
+declare const member: TSESTree.TSEnumMember;
+if (
+  member.id.type === AST_NODE_TYPES.Literal &&
+  typeof member.id.value === 'string'
+) {
+  const name = member.id as TSESTree.StringLiteral;
+}
+    `,
+    `
+      const c = 1;
+      let z = c as number;
+    `,
+    `
+      const c = 1;
+      let z = c as const;
+    `,
+    `
+      const c = 1;
+      let z = c as 1;
+    `,
+    `
+      type Bar = 'bar';
+      const data = {
+        x: 'foo' as 'foo',
+        y: 'bar' as Bar,
+      };
+    `,
+    "[1, 2, 3, 4, 5].map(x => [x, 'A' + x] as [number, string]);",
+    `
+      let x: Array<[number, string]> = [1, 2, 3, 4, 5].map(
+        x => [x, 'A' + x] as [number, string],
+      );
+    `,
+    'let y = 1 as 1;',
+    'const foo = 3 as number;',
+    'const foo = <number>3;',
+    `
+type Tuple = [3, 'hi', 'bye'];
+const foo = [3, 'hi', 'bye'] as Tuple;
+    `,
+    `
+type PossibleTuple = {};
+const foo = {} 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;
+    `,
+    `
+let bar: number | undefined = x;
+let foo: number = bar!;
+    `,
+    `
+declare const a: { data?: unknown };
+
+const x = a.data!;
+    `,
+    `
+declare function foo(arg?: number): number | void;
+const bar: number = foo()!;
+    `,
+    {
+      code: `
+type Foo = number;
+const foo = (3 + 5) as Foo;
+      `,
+      options: [{ typesToIgnore: ['Foo'] }],
+    },
+    {
+      code: 'const foo = (3 + 5) as any;',
+      options: [{ typesToIgnore: ['any'] }],
+    },
+    {
+      code: "(Syntax as any).ArrayExpression = 'foo';",
+      options: [{ typesToIgnore: ['any'] }],
+    },
+    {
+      code: 'const foo = (3 + 5) as string;',
+      options: [{ typesToIgnore: ['string'] }],
+    },
+    {
+      code: `
+type Foo = number;
+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: undefined | number;
+bar! + 1;
+    `,
+    `
+let bar: number, baz: number;
+bar! + 1;
+    `,
+    `
+function foo<T extends string | undefined>(bar: T) {
+  return bar!;
+}
+    `,
+    `
+declare function nonNull(s: string);
+let s: string | null = null;
+nonNull(s!);
+    `,
+    `
+const x: number | null = null;
+const y: number = x!;
+    `,
+    `
+const x: number | null = null;
+class Foo {
+  prop: number = x!;
+}
+    `,
+    `
+      declare const y: number | null;
+      console.log(y!);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/529
+    `
+declare function foo(str?: string): void;
+declare const str: string | null;
+
+foo(str!);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/532
+    `
+declare function a(a: string): any;
+declare const b: string | null;
+class Mx {
+  @a(b!)
+  private prop = 1;
+}
+    `,
+    // 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 | 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 };
+  }
+}
+
+function Test(props: { id?: null | string | number }) {
+  return <div key={props.id!} />;
+}
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
+      },
     },
     {
-      code: noFormat`
-const foo = 3 + 5/*as*/ as number;
-      `,
-      output: `
-const foo = 3 + 5/*as*/;
+      code: `
+const a = [1, 2];
+const b = [3, 4];
+const c = [...a, ...b] as const;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
     },
     {
-      code: noFormat`
-const foo = 3 + 5/*a*/ /*b*/ as number;
-      `,
-      output: `
-const foo = 3 + 5/*a*/ /*b*/;
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
+      code: 'const a = [1, 2] as const;',
     },
     {
-      code: noFormat`
-const foo = <(number)>(3 + 5);
-      `,
-      output: `
-const foo = (3 + 5);
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
+      code: "const a = { foo: 'foo' } as const;",
     },
     {
-      code: noFormat`
-const foo = < ( number ) >( 3 + 5 );
-      `,
-      output: `
-const foo = ( 3 + 5 );
+      code: `
+const a = [1, 2];
+const b = [3, 4];
+const c = <const>[...a, ...b];
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
     },
     {
-      code: noFormat`
-const foo = <number> /* a */ (3 + 5);
-      `,
-      output: `
-const foo =  /* a */ (3 + 5);
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
+      code: 'const a = <const>[1, 2];',
     },
     {
-      code: noFormat`
-const foo = <number /* a */>(3 + 5);
+      code: "const a = <const>{ foo: 'foo' };",
+    },
+    {
+      code: `
+let a: number | undefined;
+let b: number | undefined;
+let c: number;
+a = b;
+c = b!;
+a! -= 1;
       `,
-      output: `
-const foo = (3 + 5);
+    },
+    {
+      code: `
+let a: { b?: string } | undefined;
+a!.b = '';
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-          column: 13,
-        },
-      ],
     },
-    // onUncheckedIndexedAccess = false
+    `
+let value: number | undefined;
+let values: number[] = [];
+
+value = values.pop()!;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = foo()!;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = foo() as number;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = <number>foo();
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = arr[0]!;
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = arr[0] as object;
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = <object>arr[0];
+    `,
     {
       code: `
 function foo(item: string) {}
@@ -1026,43 +1068,26 @@ function bar(items: string[]) {
   }
 }
       `,
-      output: `
-function foo(item: string) {}
-function bar(items: string[]) {
-  for (let i = 0; i < items.length; i++) {
-    foo(items[i]);
-  }
-}
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 5,
-          column: 9,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithOnUncheckedIndexedAccess },
     },
-    // exactOptionalPropertyTypes = true
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
+    `
+let myString = 'foo';
+const templateLiteral = \`\${myString}-somethingElse\` as const;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
+    `
+let myString = 'foo';
+const templateLiteral = <const>\`\${myString}-somethingElse\`;
+    `,
+    'let a = `a` as const;',
     {
       code: `
 declare const foo: {
   a?: string;
 };
-const bar = foo.a as string | undefined;
-      `,
-      output: `
-declare const foo: {
-  a?: string;
-};
-const bar = foo.a;
+const bar = foo.a as string;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 5,
-          column: 13,
-        },
-      ],
       languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
@@ -1070,72 +1095,46 @@ const bar = foo.a;
 declare const foo: {
   a?: string | undefined;
 };
-const bar = foo.a as string | undefined;
+const bar = foo.a as string;
       `,
-      output: `
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
 declare const foo: {
-  a?: string | undefined;
+  a: string;
 };
-const bar = foo.a;
+const bar = foo.a as string | undefined;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 5,
-          column: 13,
-        },
-      ],
       languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-varDeclarationFromFixture!;
-      `,
-      output: `
-varDeclarationFromFixture;
+declare const foo: {
+  a?: string | null | number;
+};
+const bar = foo.a as string | undefined;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 2,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-var x = 1;
-x!;
-      `,
-      output: `
-var x = 1;
-x;
+declare const foo: {
+  a?: string | number;
+};
+const bar = foo.a as string | undefined | bigint;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 3,
-        },
-      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-var x = 1;
-{
-  x!;
-}
-      `,
-      output: `
-var x = 1;
-{
-  x;
+if (Math.random()) {
+  {
+    var x = 1;
+  }
 }
+x!;
       `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-          line: 4,
-        },
-      ],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
index 3ad032bed2ce..1c9fedf5c08a 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
@@ -5,37 +5,20 @@ import rule from '../../src/rules/no-unnecessary-type-constraint';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-type-constraint', rule, {
-  valid: [
-    'function data() {}',
-    'function data<T>() {}',
-    'function data<T, U>() {}',
-    'function data<T extends number>() {}',
-    'function data<T extends number | string>() {}',
-    'function data<T extends any | number>() {}',
-    `
-type TODO = any;
-function data<T extends TODO>() {}
-    `,
-    'const data = () => {};',
-    'const data = <T,>() => {};',
-    'const data = <T, U>() => {};',
-    'const data = <T extends number>() => {};',
-    'const data = <T extends number | string>() => {};',
-  ],
   invalid: [
     {
       code: 'function data<T extends any>() {}',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'function data<T>() {}',
             },
           ],
@@ -46,15 +29,15 @@ function data<T extends TODO>() {}
       code: 'function data<T extends any, U>() {}',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'function data<T, U>() {}',
             },
           ],
@@ -65,15 +48,15 @@ function data<T extends TODO>() {}
       code: 'function data<T, U extends any>() {}',
       errors: [
         {
+          column: 18,
           data: { constraint: 'any', name: 'U' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 31,
-          column: 18,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'function data<T, U>() {}',
             },
           ],
@@ -84,15 +67,15 @@ function data<T extends TODO>() {}
       code: 'function data<T extends any, U extends T>() {}',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'function data<T, U extends T>() {}',
             },
           ],
@@ -103,15 +86,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T,>() => {};`,
             },
           ],
@@ -129,15 +112,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T,>() => {};`,
             },
           ],
@@ -149,15 +132,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T,>() => {};`,
             },
           ],
@@ -169,15 +152,15 @@ function data<T extends TODO>() {}
       code: noFormat`const data = <T extends any,>() => {};`,
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T,>() => {};`,
             },
           ],
@@ -195,15 +178,15 @@ function data<T extends TODO>() {}
       code: noFormat`const data = <T extends any, >() => {};`,
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T, >() => {};`,
             },
           ],
@@ -221,15 +204,15 @@ function data<T extends TODO>() {}
       code: noFormat`const data = <T extends any ,>() => {};`,
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T ,>() => {};`,
             },
           ],
@@ -247,15 +230,15 @@ function data<T extends TODO>() {}
       code: noFormat`const data = <T extends any , >() => {};`,
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T , >() => {};`,
             },
           ],
@@ -273,15 +256,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any = unknown>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 38,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'const data = <T = unknown>() => {};',
             },
           ],
@@ -299,29 +282,29 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any, U extends any>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T, U extends any>() => {};`,
             },
           ],
         },
         {
+          column: 30,
           data: { constraint: 'any', name: 'U' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 43,
-          column: 30,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `const data = <T extends any, U>() => {};`,
             },
           ],
@@ -339,15 +322,15 @@ function data<T extends TODO>() {}
       code: 'function data<T extends unknown>() {}',
       errors: [
         {
+          column: 15,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 32,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'function data<T>() {}',
             },
           ],
@@ -358,15 +341,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends any>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'any', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'any' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'const data = <T>() => {};',
             },
           ],
@@ -377,15 +360,15 @@ function data<T extends TODO>() {}
       code: 'const data = <T extends unknown>() => {};',
       errors: [
         {
+          column: 15,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 32,
-          column: 15,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'const data = <T>() => {};',
             },
           ],
@@ -396,15 +379,15 @@ function data<T extends TODO>() {}
       code: 'class Data<T extends unknown> {}',
       errors: [
         {
+          column: 12,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 29,
-          column: 12,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'class Data<T> {}',
             },
           ],
@@ -415,15 +398,15 @@ function data<T extends TODO>() {}
       code: 'const Data = class<T extends unknown> {};',
       errors: [
         {
+          column: 20,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 37,
-          column: 20,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'const Data = class<T> {};',
             },
           ],
@@ -438,15 +421,15 @@ class Data {
       `,
       errors: [
         {
+          column: 10,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 27,
-          column: 10,
           line: 3,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `
 class Data {
   member<T>() {}
@@ -465,15 +448,15 @@ const Data = class {
       `,
       errors: [
         {
+          column: 10,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 27,
-          column: 10,
           line: 3,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: `
 const Data = class {
   member<T>() {}
@@ -488,15 +471,15 @@ const Data = class {
       code: 'interface Data<T extends unknown> {}',
       errors: [
         {
+          column: 16,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 33,
-          column: 16,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'interface Data<T> {}',
             },
           ],
@@ -507,15 +490,15 @@ const Data = class {
       code: 'type Data<T extends unknown> = {};',
       errors: [
         {
+          column: 11,
           data: { constraint: 'unknown', name: 'T' },
-          messageId: 'unnecessaryConstraint',
           endColumn: 28,
-          column: 11,
           line: 1,
+          messageId: 'unnecessaryConstraint',
           suggestions: [
             {
-              messageId: 'removeUnnecessaryConstraint',
               data: { constraint: 'unknown' },
+              messageId: 'removeUnnecessaryConstraint',
               output: 'type Data<T> = {};',
             },
           ],
@@ -523,4 +506,21 @@ const Data = class {
       ],
     },
   ],
+  valid: [
+    'function data() {}',
+    'function data<T>() {}',
+    'function data<T, U>() {}',
+    'function data<T extends number>() {}',
+    'function data<T extends number | string>() {}',
+    'function data<T extends any | number>() {}',
+    `
+type TODO = any;
+function data<T extends TODO>() {}
+    `,
+    'const data = () => {};',
+    'const data = <T,>() => {};',
+    'const data = <T, U>() => {};',
+    'const data = <T extends number>() => {};',
+    'const data = <T extends number | string>() => {};',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
index 8199b0b1abf1..5811ae0f57f8 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
@@ -8,547 +8,167 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('no-unnecessary-type-parameters', rule, {
-  valid: [
-    `
-      class ClassyArray<T> {
-        arr: T[];
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        value1: T;
-        value2: T;
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        arr: T[];
-        constructor(arr: T[]) {
-          this.arr = arr;
+  invalid: [
+    {
+      code: 'const func = <T,>(param: T) => null;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'const f1 = <T,>(): T => {};',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        interface I {
+          <T>(value: T): void;
         }
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        arr: T[];
-        workWith(value: T) {
-          this.arr.indexOf(value);
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        interface I {
+          m<T>(x: T): void;
         }
-      }
-    `,
-    `
-      abstract class ClassyArray<T> {
-        arr: T[];
-        abstract workWith(value: T): void;
-      }
-    `,
-    `
-      class Box<T> {
-        val: T | null = null;
-        get() {
-          return this.val;
+      `,
+      errors: [{ messageId: 'sole' }],
+    },
+    {
+      code: `
+        class Joiner<T extends string | number> {
+          join(el: T, other: string) {
+            return [el, other].join(',');
+          }
         }
-      }
-    `,
-    `
-      class Joiner<T extends string | number> {
-        join(els: T[]) {
-          return els.map(el => '' + el).join(',');
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C<V> {}
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'V', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C<T, U> {
+          method(param: T): U;
         }
-      }
-    `,
-    `
-      class Joiner {
-        join<T extends string | number>(els: T[]) {
-          return els.map(el => '' + el).join(',');
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'class', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C {
+          method<T, U>(param: T): U;
         }
-      }
-    `,
-    `
-      declare class Foo {
-        getProp<T>(this: Record<'prop', T>): T;
-      }
-    `,
-    'type Fn = <T>(input: T) => T;',
-    'type Fn = <T extends string>(input: T) => T;',
-    'type Fn = <T extends string>(input: T) => `a${T}b`;',
-    'type Fn = new <T>(input: T) => T;',
-    'type Fn = <T>(input: T) => typeof input;',
-    'type Fn = <T>(input: T) => keyof typeof input;',
-    'type Fn = <T>(input: Partial<T>) => typeof input;',
-    'type Fn = <T>(input: Partial<T>) => input is T;',
-    'type Fn = <T>(input: T) => { [K in keyof T]: K };',
-    'type Fn = <T>(input: T) => { [K in keyof T as K]: string };',
-    'type Fn = <T>(input: T) => { [K in keyof T as `${K & string}`]: string };',
-    'type Fn = <T>(input: T) => Partial<T>;',
-    'type Fn = <T>(input: { [i: number]: T }) => T;',
-    'type Fn = <T>(input: { [i: number]: T }) => Partial<T>;',
-    'type Fn = <T>(input: { [i: string]: T }) => Partial<T>;',
-    'type Fn = <T>(input: T) => { [i: number]: T };',
-    'type Fn = <T>(input: T) => { [i: string]: T };',
-    "type Fn = <T extends unknown[]>(input: T) => Omit<T, 'length'>;",
-    `
-      interface I {
-        <T>(value: T): T;
-      }
-    `,
-    `
-      interface I {
-        new <T>(value: T): T;
-      }
-    `,
-    `
-      function identity<T>(arg: T): T {
-        return arg;
-      }
-    `,
-    `
-      function printProperty<T>(obj: T, key: keyof T) {
-        console.log(obj[key]);
-      }
-    `,
-    `
-      function getProperty<T, K extends keyof T>(obj: T, key: K) {
-        return obj[key];
-      }
-    `,
-    `
-      function box<T>(val: T) {
-        return { val };
-      }
-    `,
-    `
-      function doStuff<K, V>(map: Map<K, V>, key: K) {
-        let v = map.get(key);
-        v = 1;
-        map.set(key, v);
-        return v;
-      }
-    `,
-    `
-      function makeMap<K, V>() {
-        return new Map<K, V>();
-      }
-    `,
-    `
-      function makeMap<K, V>(ks: K[], vs: V[]) {
-        const r = new Map<K, V>();
-        ks.forEach((k, i) => {
-          r.set(k, vs[i]);
-        });
-        return r;
-      }
-    `,
-    `
-      function arrayOfPairs<T>() {
-        return [] as [T, T][];
-      }
-    `,
-    `
-      function isNonNull<T>(v: T): v is Exclude<T, null> {
-        return v !== null;
-      }
-    `,
-    `
-      function both<Args extends unknown[]>(
-        fn1: (...args: Args) => void,
-        fn2: (...args: Args) => void,
-      ): (...args: Args) => void {
-        return function (...args: Args) {
-          fn1(...args);
-          fn2(...args);
-        };
-      }
-    `,
-    `
-      function lengthyIdentity<T extends { length: number }>(x: T) {
-        return x;
-      }
-    `,
-    `
-      interface Lengthy {
-        length: number;
-      }
-      function lengthyIdentity<T extends Lengthy>(x: T) {
-        return x;
-      }
-    `,
-    `
-      function ItemComponent<T>(props: { item: T; onSelect: (item: T) => void }) {}
-    `,
-    `
-      interface ItemProps<T> {
-        item: readonly T;
-        onSelect: (item: T) => void;
-      }
-      function ItemComponent<T>(props: ItemProps<T>) {}
-    `,
-    `
-      function useFocus<T extends HTMLOrSVGElement>(): [
-        React.RefObject<T>,
-        () => void,
-      ];
-    `,
-    `
-      function findFirstResult<U>(
-        inputs: unknown[],
-        getResult: (t: unknown) => U | undefined,
-      ): U | undefined;
-    `,
-    `
-      function findFirstResult<T, U>(
-        inputs: T[],
-        getResult: (t: T) => () => [U | undefined],
-      ): () => [U | undefined];
-    `,
-    `
-      function getData<T>(url: string): Promise<T | null> {
-        return Promise.resolve(null);
-      }
-    `,
-    `
-      function getData<T>(url: string): Promise<T extends null ? T : null> {
-        return Promise.resolve(null);
-      }
-    `,
-    `
-      function getData<T extends string>(url: string): Promise<\`a\${T}b\`> {
-        return Promise.resolve(null);
-      }
-    `,
-    `
-      async function getData<T>(url: string): Promise<T | null> {
-        return null;
-      }
-    `,
-    'declare function get(): void;',
-    'declare function get<T>(param: T[]): T;',
-    'declare function box<T>(val: T): { val: T };',
-    'declare function identity<T>(param: T): T;',
-    'declare function compare<T>(param1: T, param2: T): boolean;',
-    'declare function example<T>(a: Set<T>): T;',
-    'declare function example<T>(a: Set<T>, b: T[]): void;',
-    'declare function example<T>(a: Map<T, T>): void;',
-    'declare function example<T, U extends T>(t: T, u: U): U;',
-    'declare function makeSet<K>(): Set<K>;',
-    'declare function makeSet<K>(): [Set<K>];',
-    'declare function makeSets<K>(): Set<K>[];',
-    'declare function makeSets<K>(): [Set<K>][];',
-    'declare function makeMap<K, V>(): Map<K, V>;',
-    'declare function makeMap<K, V>(): [Map<K, V>];',
-    'declare function arrayOfPairs<T>(): [T, T][];',
-    'declare function fetchJson<T>(url: string): Promise<T>;',
-    'declare function fn<T>(input: T): 0 extends 0 ? T : never;',
-    'declare function useFocus<T extends HTMLOrSVGElement>(): [React.RefObject<T>];',
-    `
-      declare function useFocus<T extends HTMLOrSVGElement>(): {
-        ref: React.RefObject<T>;
-      };
-    `,
-    `
-      interface TwoMethods<T> {
-        a(x: T): void;
-        b(x: T): void;
-      }
-
-      declare function two<T>(props: TwoMethods<T>): void;
-    `,
-    `
-      type Obj = { a: string };
-
-      declare function hasOwnProperty<K extends keyof Obj>(
-        obj: Obj,
-        key: K,
-      ): obj is Obj & { [key in K]-?: Obj[key] };
-    `,
-    `
-      type AsMutable<T extends readonly unknown[]> = {
-        -readonly [Key in keyof T]: T[Key];
-      };
-
-      declare function makeMutable<T>(input: T): MakeMutable<T>;
-    `,
-    `
-      type AsMutable<T extends readonly unknown[]> = {
-        -readonly [Key in keyof T]: T[Key];
-      };
-
-      declare function makeMutable<T>(input: T): MakeMutable<typeof input>;
-    `,
-    `
-      type ValueNulls<U extends string> = {} & {
-        [P in U]: null;
-      };
-
-      declare function invert<T extends string>(obj: T): ValueNulls<T>;
-    `,
-    `
-      interface Middle {
-        inner: boolean;
-      }
-
-      type Conditional<T extends Middle> = {} & (T['inner'] extends true ? {} : {});
-
-      function withMiddle<T extends Middle = Middle>(options: T): Conditional<T> {
-        return options;
-      }
-    `,
-    `
-      import * as ts from 'typescript';
-
-      declare function forEachReturnStatement<T>(
-        body: ts.Block,
-        visitor: (stmt: ts.ReturnStatement) => T,
-      ): T | undefined;
-    `,
-    `
-      import type { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
-
-      declare const isNodeOfType: <NodeType extends AST_NODE_TYPES>(
-        nodeType: NodeType,
-      ) => node is Extract<TSESTree.Node, { type: NodeType }>;
-    `,
-    `
-      import type { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
-
-      const isNodeOfType =
-        <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) =>
-        (
-          node: TSESTree.Node | null,
-        ): node is Extract<TSESTree.Node, { type: NodeType }> =>
-          node?.type === nodeType;
-    `,
-    `
-      import type { AST_TOKEN_TYPES, TSESTree } from '@typescript-eslint/types';
-
-      export const isNotTokenOfTypeWithConditions =
-        <
-          TokenType extends AST_TOKEN_TYPES,
-          ExtractedToken extends Extract<TSESTree.Token, { type: TokenType }>,
-          Conditions extends Partial<ExtractedToken>,
-        >(
-          tokenType: TokenType,
-          conditions: Conditions,
-        ): ((
-          token: TSESTree.Token | null | undefined,
-        ) => token is Exclude<TSESTree.Token, Conditions & ExtractedToken>) =>
-        (token): token is Exclude<TSESTree.Token, Conditions & ExtractedToken> =>
-          tokenType in conditions;
-    `,
-    `
-      type Foo<T, S> = S extends 'somebody'
-        ? T extends 'once'
-          ? 'told'
-          : 'me'
-        : never;
-
-      declare function foo<T>(data: T): <S>(other: S) => Foo<T, S>;
-    `,
-    `
-      type Foo<T, S> = S extends 'somebody'
-        ? T extends 'once'
-          ? 'told'
-          : 'me'
-        : never;
-
-      declare function foo<T>(data: T): <S>(other: S) => Foo<S, T>;
-    `,
-    `
-      declare function mapObj<K extends string, V>(
-        obj: { [key in K]?: V },
-        fn: (key: K, val: V) => number,
-      ): number[];
-    `,
-    `
-      declare function mappedReturnType<T extends string>(
-        x: T,
-      ): { [K in T]: Capitalize<K> };
-
-      function inferredMappedReturnType<T extends string>(x: T) {
-        return mappedReturnType(x);
-      }
-    `,
-    `
-      declare function mappedReturnType<T extends string>(
-        x: T,
-      ): { [K in T]: Capitalize<K> };
-
-      function inferredMappedReturnType<T extends string>(x: T) {
-        return () => mappedReturnType(x);
-      }
-    `,
-    `
-      declare function mappedReturnType<T extends string>(
-        x: T,
-      ): { [K in T]: Capitalize<K> };
-
-      function inferredMappedReturnType<T extends string>(x: T) {
-        return [{ value: () => mappedReturnType(x) }];
-      }
-    `,
-  ],
-
-  invalid: [
-    {
-      code: 'const func = <T,>(param: T) => null;',
+      `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
-      ],
-    },
-    {
-      code: 'const f1 = <T,>(): T => {};',
-      errors: [
         {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
           messageId: 'sole',
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
         },
       ],
     },
     {
       code: `
-        interface I {
-          <T>(value: T): void;
+        declare class C {
+          prop: <P>() => P;
         }
       `,
       errors: [
         {
+          data: { descriptor: 'function', name: 'P', uses: 'used only once' },
           messageId: 'sole',
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
         },
       ],
     },
     {
       code: `
-        interface I {
-          m<T>(x: T): void;
-        }
-      `,
-      errors: [{ messageId: 'sole' }],
-    },
-    {
-      code: `
-        class Joiner<T extends string | number> {
-          join(el: T, other: string) {
-            return [el, other].join(',');
-          }
+        declare class Foo {
+          foo<T>(this: T): void;
         }
       `,
       errors: [
         {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
           messageId: 'sole',
-          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
         },
       ],
     },
     {
       code: `
-        declare class C<V> {}
+        function third<A, B, C>(a: A, b: B, c: C): C {
+          return c;
+        }
       `,
       errors: [
         {
+          data: { descriptor: 'function', name: 'A', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'B', uses: 'used only once' },
           messageId: 'sole',
-          data: { descriptor: 'class', name: 'V', uses: 'never used' },
         },
       ],
     },
     {
       code: `
-        declare class C<T, U> {
-          method(param: T): U;
+        function foo<T>(_: T) {
+          const x: T = null!;
+          const y: T = null!;
         }
       `,
       errors: [
         {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
           messageId: 'sole',
-          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
-        },
-        {
-          messageId: 'sole',
-          data: { descriptor: 'class', name: 'U', uses: 'used only once' },
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C {
-          method<T, U>(param: T): U;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-        },
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C {
-          prop: <P>() => P;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'P', uses: 'used only once' },
-        },
-      ],
-    },
-    {
-      code: `
-        declare class Foo {
-          foo<T>(this: T): void;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-        },
-      ],
-    },
-    {
-      code: `
-        function third<A, B, C>(a: A, b: B, c: C): C {
-          return c;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'A', uses: 'used only once' },
-        },
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'B', uses: 'used only once' },
-        },
-      ],
-    },
-    {
-      code: `
-        function foo<T>(_: T) {
-          const x: T = null!;
-          const y: T = null!;
-        }
-      `,
-      errors: [
-        {
-          messageId: 'sole',
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
         },
       ],
     },
@@ -561,8 +181,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -575,8 +195,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -593,8 +213,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -606,8 +226,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -619,8 +239,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'K', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -653,12 +273,12 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'CB1', uses: 'used only once' },
+          messageId: 'sole',
         },
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'CB2', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -695,8 +315,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T>(): unknown;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
         },
       ],
     },
@@ -704,8 +324,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T>(): T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -713,8 +333,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T extends object>(): T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -722,8 +342,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function take<T>(param: T): void;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -731,8 +351,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function take<T extends object>(param: T): void;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -740,8 +360,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function take<T, U = T>(param1: T, param2: U): void;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -749,8 +369,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function take<T, U extends T>(param: T): U;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -758,8 +378,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function take<T, U extends T>(param: U): U;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -767,8 +387,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T, U = T>(param: U): U;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -776,8 +396,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T, U extends T = T>(param: T): U;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -785,8 +405,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function compare<T, U extends T>(param1: T, param2: U): boolean;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -794,16 +414,16 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T>(param: <U, V>(param: U) => V): T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'V', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -811,16 +431,16 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'declare function get<T>(param: <T, U>(param: T) => U): T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -828,8 +448,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <T>() => T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -837,8 +457,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <T>() => [];',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
         },
       ],
     },
@@ -849,8 +469,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
         },
       ],
     },
@@ -861,8 +481,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
         },
       ],
     },
@@ -870,8 +490,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <U>(param: U) => void;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -879,8 +499,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Ctr = new <T>() => T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -888,8 +508,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <T>() => { [K in keyof T]: K };',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -897,8 +517,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: "type Fn = <T>() => { [K in 'a']: T };",
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -906,8 +526,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <T>(value: unknown) => value is T;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -915,8 +535,8 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       code: 'type Fn = <T extends string>() => `a${T}b`;',
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
@@ -929,10 +549,390 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       `,
       errors: [
         {
-          messageId: 'sole',
           data: { descriptor: 'function', name: 'V', uses: 'used only once' },
+          messageId: 'sole',
         },
       ],
     },
   ],
+
+  valid: [
+    `
+      class ClassyArray<T> {
+        arr: T[];
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        value1: T;
+        value2: T;
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        arr: T[];
+        constructor(arr: T[]) {
+          this.arr = arr;
+        }
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        arr: T[];
+        workWith(value: T) {
+          this.arr.indexOf(value);
+        }
+      }
+    `,
+    `
+      abstract class ClassyArray<T> {
+        arr: T[];
+        abstract workWith(value: T): void;
+      }
+    `,
+    `
+      class Box<T> {
+        val: T | null = null;
+        get() {
+          return this.val;
+        }
+      }
+    `,
+    `
+      class Joiner<T extends string | number> {
+        join(els: T[]) {
+          return els.map(el => '' + el).join(',');
+        }
+      }
+    `,
+    `
+      class Joiner {
+        join<T extends string | number>(els: T[]) {
+          return els.map(el => '' + el).join(',');
+        }
+      }
+    `,
+    `
+      declare class Foo {
+        getProp<T>(this: Record<'prop', T>): T;
+      }
+    `,
+    'type Fn = <T>(input: T) => T;',
+    'type Fn = <T extends string>(input: T) => T;',
+    'type Fn = <T extends string>(input: T) => `a${T}b`;',
+    'type Fn = new <T>(input: T) => T;',
+    'type Fn = <T>(input: T) => typeof input;',
+    'type Fn = <T>(input: T) => keyof typeof input;',
+    'type Fn = <T>(input: Partial<T>) => typeof input;',
+    'type Fn = <T>(input: Partial<T>) => input is T;',
+    'type Fn = <T>(input: T) => { [K in keyof T]: K };',
+    'type Fn = <T>(input: T) => { [K in keyof T as K]: string };',
+    'type Fn = <T>(input: T) => { [K in keyof T as `${K & string}`]: string };',
+    'type Fn = <T>(input: T) => Partial<T>;',
+    'type Fn = <T>(input: { [i: number]: T }) => T;',
+    'type Fn = <T>(input: { [i: number]: T }) => Partial<T>;',
+    'type Fn = <T>(input: { [i: string]: T }) => Partial<T>;',
+    'type Fn = <T>(input: T) => { [i: number]: T };',
+    'type Fn = <T>(input: T) => { [i: string]: T };',
+    "type Fn = <T extends unknown[]>(input: T) => Omit<T, 'length'>;",
+    `
+      interface I {
+        <T>(value: T): T;
+      }
+    `,
+    `
+      interface I {
+        new <T>(value: T): T;
+      }
+    `,
+    `
+      function identity<T>(arg: T): T {
+        return arg;
+      }
+    `,
+    `
+      function printProperty<T>(obj: T, key: keyof T) {
+        console.log(obj[key]);
+      }
+    `,
+    `
+      function getProperty<T, K extends keyof T>(obj: T, key: K) {
+        return obj[key];
+      }
+    `,
+    `
+      function box<T>(val: T) {
+        return { val };
+      }
+    `,
+    `
+      function doStuff<K, V>(map: Map<K, V>, key: K) {
+        let v = map.get(key);
+        v = 1;
+        map.set(key, v);
+        return v;
+      }
+    `,
+    `
+      function makeMap<K, V>() {
+        return new Map<K, V>();
+      }
+    `,
+    `
+      function makeMap<K, V>(ks: K[], vs: V[]) {
+        const r = new Map<K, V>();
+        ks.forEach((k, i) => {
+          r.set(k, vs[i]);
+        });
+        return r;
+      }
+    `,
+    `
+      function arrayOfPairs<T>() {
+        return [] as [T, T][];
+      }
+    `,
+    `
+      function isNonNull<T>(v: T): v is Exclude<T, null> {
+        return v !== null;
+      }
+    `,
+    `
+      function both<Args extends unknown[]>(
+        fn1: (...args: Args) => void,
+        fn2: (...args: Args) => void,
+      ): (...args: Args) => void {
+        return function (...args: Args) {
+          fn1(...args);
+          fn2(...args);
+        };
+      }
+    `,
+    `
+      function lengthyIdentity<T extends { length: number }>(x: T) {
+        return x;
+      }
+    `,
+    `
+      interface Lengthy {
+        length: number;
+      }
+      function lengthyIdentity<T extends Lengthy>(x: T) {
+        return x;
+      }
+    `,
+    `
+      function ItemComponent<T>(props: { item: T; onSelect: (item: T) => void }) {}
+    `,
+    `
+      interface ItemProps<T> {
+        item: readonly T;
+        onSelect: (item: T) => void;
+      }
+      function ItemComponent<T>(props: ItemProps<T>) {}
+    `,
+    `
+      function useFocus<T extends HTMLOrSVGElement>(): [
+        React.RefObject<T>,
+        () => void,
+      ];
+    `,
+    `
+      function findFirstResult<U>(
+        inputs: unknown[],
+        getResult: (t: unknown) => U | undefined,
+      ): U | undefined;
+    `,
+    `
+      function findFirstResult<T, U>(
+        inputs: T[],
+        getResult: (t: T) => () => [U | undefined],
+      ): () => [U | undefined];
+    `,
+    `
+      function getData<T>(url: string): Promise<T | null> {
+        return Promise.resolve(null);
+      }
+    `,
+    `
+      function getData<T>(url: string): Promise<T extends null ? T : null> {
+        return Promise.resolve(null);
+      }
+    `,
+    `
+      function getData<T extends string>(url: string): Promise<\`a\${T}b\`> {
+        return Promise.resolve(null);
+      }
+    `,
+    `
+      async function getData<T>(url: string): Promise<T | null> {
+        return null;
+      }
+    `,
+    'declare function get(): void;',
+    'declare function get<T>(param: T[]): T;',
+    'declare function box<T>(val: T): { val: T };',
+    'declare function identity<T>(param: T): T;',
+    'declare function compare<T>(param1: T, param2: T): boolean;',
+    'declare function example<T>(a: Set<T>): T;',
+    'declare function example<T>(a: Set<T>, b: T[]): void;',
+    'declare function example<T>(a: Map<T, T>): void;',
+    'declare function example<T, U extends T>(t: T, u: U): U;',
+    'declare function makeSet<K>(): Set<K>;',
+    'declare function makeSet<K>(): [Set<K>];',
+    'declare function makeSets<K>(): Set<K>[];',
+    'declare function makeSets<K>(): [Set<K>][];',
+    'declare function makeMap<K, V>(): Map<K, V>;',
+    'declare function makeMap<K, V>(): [Map<K, V>];',
+    'declare function arrayOfPairs<T>(): [T, T][];',
+    'declare function fetchJson<T>(url: string): Promise<T>;',
+    'declare function fn<T>(input: T): 0 extends 0 ? T : never;',
+    'declare function useFocus<T extends HTMLOrSVGElement>(): [React.RefObject<T>];',
+    `
+      declare function useFocus<T extends HTMLOrSVGElement>(): {
+        ref: React.RefObject<T>;
+      };
+    `,
+    `
+      interface TwoMethods<T> {
+        a(x: T): void;
+        b(x: T): void;
+      }
+
+      declare function two<T>(props: TwoMethods<T>): void;
+    `,
+    `
+      type Obj = { a: string };
+
+      declare function hasOwnProperty<K extends keyof Obj>(
+        obj: Obj,
+        key: K,
+      ): obj is Obj & { [key in K]-?: Obj[key] };
+    `,
+    `
+      type AsMutable<T extends readonly unknown[]> = {
+        -readonly [Key in keyof T]: T[Key];
+      };
+
+      declare function makeMutable<T>(input: T): MakeMutable<T>;
+    `,
+    `
+      type AsMutable<T extends readonly unknown[]> = {
+        -readonly [Key in keyof T]: T[Key];
+      };
+
+      declare function makeMutable<T>(input: T): MakeMutable<typeof input>;
+    `,
+    `
+      type ValueNulls<U extends string> = {} & {
+        [P in U]: null;
+      };
+
+      declare function invert<T extends string>(obj: T): ValueNulls<T>;
+    `,
+    `
+      interface Middle {
+        inner: boolean;
+      }
+
+      type Conditional<T extends Middle> = {} & (T['inner'] extends true ? {} : {});
+
+      function withMiddle<T extends Middle = Middle>(options: T): Conditional<T> {
+        return options;
+      }
+    `,
+    `
+      import * as ts from 'typescript';
+
+      declare function forEachReturnStatement<T>(
+        body: ts.Block,
+        visitor: (stmt: ts.ReturnStatement) => T,
+      ): T | undefined;
+    `,
+    `
+      import type { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
+
+      declare const isNodeOfType: <NodeType extends AST_NODE_TYPES>(
+        nodeType: NodeType,
+      ) => node is Extract<TSESTree.Node, { type: NodeType }>;
+    `,
+    `
+      import type { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
+
+      const isNodeOfType =
+        <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) =>
+        (
+          node: TSESTree.Node | null,
+        ): node is Extract<TSESTree.Node, { type: NodeType }> =>
+          node?.type === nodeType;
+    `,
+    `
+      import type { AST_TOKEN_TYPES, TSESTree } from '@typescript-eslint/types';
+
+      export const isNotTokenOfTypeWithConditions =
+        <
+          TokenType extends AST_TOKEN_TYPES,
+          ExtractedToken extends Extract<TSESTree.Token, { type: TokenType }>,
+          Conditions extends Partial<ExtractedToken>,
+        >(
+          tokenType: TokenType,
+          conditions: Conditions,
+        ): ((
+          token: TSESTree.Token | null | undefined,
+        ) => token is Exclude<TSESTree.Token, Conditions & ExtractedToken>) =>
+        (token): token is Exclude<TSESTree.Token, Conditions & ExtractedToken> =>
+          tokenType in conditions;
+    `,
+    `
+      type Foo<T, S> = S extends 'somebody'
+        ? T extends 'once'
+          ? 'told'
+          : 'me'
+        : never;
+
+      declare function foo<T>(data: T): <S>(other: S) => Foo<T, S>;
+    `,
+    `
+      type Foo<T, S> = S extends 'somebody'
+        ? T extends 'once'
+          ? 'told'
+          : 'me'
+        : never;
+
+      declare function foo<T>(data: T): <S>(other: S) => Foo<S, T>;
+    `,
+    `
+      declare function mapObj<K extends string, V>(
+        obj: { [key in K]?: V },
+        fn: (key: K, val: V) => number,
+      ): number[];
+    `,
+    `
+      declare function mappedReturnType<T extends string>(
+        x: T,
+      ): { [K in T]: Capitalize<K> };
+
+      function inferredMappedReturnType<T extends string>(x: T) {
+        return mappedReturnType(x);
+      }
+    `,
+    `
+      declare function mappedReturnType<T extends string>(
+        x: T,
+      ): { [K in T]: Capitalize<K> };
+
+      function inferredMappedReturnType<T extends string>(x: T) {
+        return () => mappedReturnType(x);
+      }
+    `,
+    `
+      declare function mappedReturnType<T extends string>(
+        x: T,
+      ): { [K in T]: Capitalize<K> };
+
+      function inferredMappedReturnType<T extends string>(x: T) {
+        return [{ value: () => mappedReturnType(x) }];
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
index 731bd440879b..38781b5ac32c 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
@@ -13,112 +13,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unsafe-argument', rule, {
-  valid: [
-    // unknown function should be ignored
-    `
-doesNotExist(1 as any);
-    `,
-    // non-function call should be ignored
-    `
-const foo = 1;
-foo(1 as any);
-    `,
-    // too many arguments should be ignored as this is a TS error
-    `
-declare function foo(arg: number): void;
-foo(1, 1 as any, 2 as any);
-    `,
-    `
-declare function foo(arg: number, arg2: string): void;
-foo(1, 'a');
-    `,
-    `
-declare function foo(arg: any): void;
-foo(1 as any);
-    `,
-    `
-declare function foo(arg: unknown): void;
-foo(1 as any);
-    `,
-    `
-declare function foo(...arg: number[]): void;
-foo(1, 2, 3);
-    `,
-    `
-declare function foo(...arg: any[]): void;
-foo(1, 2, 3, 4 as any);
-    `,
-    `
-declare function foo(arg: number, arg2: number): void;
-const x = [1, 2] as const;
-foo(...x);
-    `,
-    `
-declare function foo(arg: any, arg2: number): void;
-const x = [1 as any, 2] as const;
-foo(...x);
-    `,
-    `
-declare function foo(arg1: string, arg2: string): void;
-const x: string[] = [];
-foo(...x);
-    `,
-    `
-function foo(arg1: number, arg2: number) {}
-foo(...([1, 1, 1] as [number, number, number]));
-    `,
-    `
-declare function foo(arg1: Set<string>, arg2: Map<string, string>): void;
-
-const x = [new Map<string, string>()] as const;
-foo(new Set<string>(), ...x);
-    `,
-    `
-declare function foo(arg1: unknown, arg2: Set<unkown>, arg3: unknown[]): void;
-foo(1 as any, new Set<any>(), [] as any[]);
-    `,
-    `
-declare function foo(...params: [number, string, any]): void;
-foo(1, 'a', 1 as any);
-    `,
-    // Unfortunately - we cannot handle this case because TS infers `params` to be a tuple type
-    // that tuple type is the same as the type of
-    `
-declare function foo<E extends string[]>(...params: E): void;
-
-foo('a', 'b', 1 as any);
-    `,
-    `
-declare function toHaveBeenCalledWith<E extends any[]>(...params: E): void;
-toHaveBeenCalledWith(1 as any);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    `
-declare function acceptsMap(arg: Map<string, string>): void;
-acceptsMap(new Map());
-    `,
-    `
-type T = [number, T[]];
-declare function foo(t: T): void;
-declare const t: T;
-
-foo(t);
-    `,
-    `
-type T = Array<T>;
-declare function foo<T>(t: T): T;
-const t: T = [];
-foo(t);
-    `,
-    `
-function foo(templates: TemplateStringsArray) {}
-foo\`\`;
-    `,
-    `
-function foo(templates: TemplateStringsArray, arg: any) {}
-foo\`\${1 as any}\`;
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -127,14 +21,14 @@ foo(1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 5,
-          endColumn: 13,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 13,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -145,14 +39,14 @@ foo(1, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 8,
-          endColumn: 16,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 16,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -163,14 +57,14 @@ foo(1, 2, 3, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 14,
-          endColumn: 22,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 22,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -181,24 +75,24 @@ foo(1 as any, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 5,
-          endColumn: 13,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 13,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 15,
-          endColumn: 23,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 23,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -210,10 +104,10 @@ foo(...(x as any));
       `,
       errors: [
         {
-          messageId: 'unsafeSpread',
-          line: 4,
           column: 5,
           endColumn: 18,
+          line: 4,
+          messageId: 'unsafeSpread',
         },
       ],
     },
@@ -225,10 +119,10 @@ foo(...(x as any[]));
       `,
       errors: [
         {
-          messageId: 'unsafeArraySpread',
-          line: 4,
           column: 5,
           endColumn: 20,
+          line: 4,
+          messageId: 'unsafeArraySpread',
         },
       ],
     },
@@ -241,14 +135,14 @@ foo(...x);
       `,
       errors: [
         {
-          messageId: 'unsafeTupleSpread',
-          line: 5,
           column: 5,
-          endColumn: 9,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 9,
+          line: 5,
+          messageId: 'unsafeTupleSpread',
         },
       ],
     },
@@ -259,10 +153,10 @@ foo(...(['foo', 1, 2] as [string, any, number]));
       `,
       errors: [
         {
-          messageId: 'unsafeTupleSpread',
-          line: 3,
           column: 5,
           endColumn: 48,
+          line: 3,
+          messageId: 'unsafeTupleSpread',
         },
       ],
     },
@@ -275,14 +169,14 @@ foo('a', ...x, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 5,
           column: 16,
-          endColumn: 24,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 24,
+          line: 5,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -295,14 +189,14 @@ foo('a', ...x, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 5,
           column: 16,
-          endColumn: 24,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 24,
+          line: 5,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -315,24 +209,24 @@ foo(new Set<any>(), ...x);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 5,
           column: 5,
-          endColumn: 19,
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          endColumn: 19,
+          line: 5,
+          messageId: 'unsafeArgument',
         },
         {
-          messageId: 'unsafeTupleSpread',
-          line: 5,
           column: 21,
-          endColumn: 25,
           data: {
-            sender: 'Map<any, string>',
             receiver: 'Map<string, string>',
+            sender: 'Map<any, string>',
           },
+          endColumn: 25,
+          line: 5,
+          messageId: 'unsafeTupleSpread',
         },
       ],
     },
@@ -343,24 +237,24 @@ foo(1 as any, 'a' as any, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 5,
-          endColumn: 13,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 13,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 15,
-          endColumn: 25,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 25,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -371,24 +265,24 @@ foo('a', 1 as any, 'a' as any, 1 as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 10,
-          endColumn: 18,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 18,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
         {
-          messageId: 'unsafeArgument',
-          line: 3,
           column: 20,
-          endColumn: 30,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 30,
+          line: 3,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -401,14 +295,14 @@ foo(t as any);
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 5,
           column: 5,
-          endColumn: 13,
           data: {
-            sender: 'any',
             receiver: 'T',
+            sender: 'any',
           },
+          endColumn: 13,
+          line: 5,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -425,24 +319,24 @@ foo<number>\`\${arg}\${arg}\${arg}\`;
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 9,
           column: 15,
-          endColumn: 18,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 18,
+          line: 9,
+          messageId: 'unsafeArgument',
         },
         {
-          messageId: 'unsafeArgument',
-          line: 9,
           column: 27,
-          endColumn: 30,
           data: {
-            sender: 'any',
             receiver: 'string',
+            sender: 'any',
           },
+          endColumn: 30,
+          line: 9,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -454,14 +348,14 @@ foo\`\${arg}\`;
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 4,
           column: 7,
-          endColumn: 10,
           data: {
-            sender: 'any',
             receiver: 'number',
+            sender: 'any',
           },
+          endColumn: 10,
+          line: 4,
+          messageId: 'unsafeArgument',
         },
       ],
     },
@@ -474,16 +368,122 @@ foo\`\${arg}\`;
       `,
       errors: [
         {
-          messageId: 'unsafeArgument',
-          line: 5,
           column: 7,
-          endColumn: 10,
           data: {
-            sender: 'any',
             receiver: 'T',
+            sender: 'any',
           },
+          endColumn: 10,
+          line: 5,
+          messageId: 'unsafeArgument',
         },
       ],
     },
   ],
+  valid: [
+    // unknown function should be ignored
+    `
+doesNotExist(1 as any);
+    `,
+    // non-function call should be ignored
+    `
+const foo = 1;
+foo(1 as any);
+    `,
+    // too many arguments should be ignored as this is a TS error
+    `
+declare function foo(arg: number): void;
+foo(1, 1 as any, 2 as any);
+    `,
+    `
+declare function foo(arg: number, arg2: string): void;
+foo(1, 'a');
+    `,
+    `
+declare function foo(arg: any): void;
+foo(1 as any);
+    `,
+    `
+declare function foo(arg: unknown): void;
+foo(1 as any);
+    `,
+    `
+declare function foo(...arg: number[]): void;
+foo(1, 2, 3);
+    `,
+    `
+declare function foo(...arg: any[]): void;
+foo(1, 2, 3, 4 as any);
+    `,
+    `
+declare function foo(arg: number, arg2: number): void;
+const x = [1, 2] as const;
+foo(...x);
+    `,
+    `
+declare function foo(arg: any, arg2: number): void;
+const x = [1 as any, 2] as const;
+foo(...x);
+    `,
+    `
+declare function foo(arg1: string, arg2: string): void;
+const x: string[] = [];
+foo(...x);
+    `,
+    `
+function foo(arg1: number, arg2: number) {}
+foo(...([1, 1, 1] as [number, number, number]));
+    `,
+    `
+declare function foo(arg1: Set<string>, arg2: Map<string, string>): void;
+
+const x = [new Map<string, string>()] as const;
+foo(new Set<string>(), ...x);
+    `,
+    `
+declare function foo(arg1: unknown, arg2: Set<unkown>, arg3: unknown[]): void;
+foo(1 as any, new Set<any>(), [] as any[]);
+    `,
+    `
+declare function foo(...params: [number, string, any]): void;
+foo(1, 'a', 1 as any);
+    `,
+    // Unfortunately - we cannot handle this case because TS infers `params` to be a tuple type
+    // that tuple type is the same as the type of
+    `
+declare function foo<E extends string[]>(...params: E): void;
+
+foo('a', 'b', 1 as any);
+    `,
+    `
+declare function toHaveBeenCalledWith<E extends any[]>(...params: E): void;
+toHaveBeenCalledWith(1 as any);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    `
+declare function acceptsMap(arg: Map<string, string>): void;
+acceptsMap(new Map());
+    `,
+    `
+type T = [number, T[]];
+declare function foo(t: T): void;
+declare const t: T;
+
+foo(t);
+    `,
+    `
+type T = Array<T>;
+declare function foo<T>(t: T): T;
+const t: T = [];
+foo(t);
+    `,
+    `
+function foo(templates: TemplateStringsArray) {}
+foo\`\`;
+    `,
+    `
+function foo(templates: TemplateStringsArray, arg: any) {}
+foo\`\${1 as any}\`;
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
index 19357a7adf11..f089a29654ce 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
@@ -1,11 +1,13 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
-import rule from '../../src/rules/no-unsafe-assignment';
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../../src/util';
+
+import rule from '../../src/rules/no-unsafe-assignment';
 import { getFixturesRootDir } from '../RuleTester';
 
 type Options = InferOptionsTypeFromRule<typeof rule>;
@@ -22,10 +24,10 @@ function assignmentTest(
         code: `const ${assignment}`,
         errors: [
           {
-            messageId: 'unsafeArrayPatternFromTuple',
-            line: 1,
             column: column + 6,
             endColumn: endColumn + 6,
+            line: 1,
+            messageId: 'unsafeArrayPatternFromTuple',
           },
         ],
       });
@@ -34,10 +36,10 @@ function assignmentTest(
         code: `function foo(${assignment}) {}`,
         errors: [
           {
-            messageId: 'unsafeArrayPatternFromTuple',
-            line: 1,
             column: column + 13,
             endColumn: endColumn + 13,
+            line: 1,
+            messageId: 'unsafeArrayPatternFromTuple',
           },
         ],
       });
@@ -47,10 +49,10 @@ function assignmentTest(
           code: `(${assignment})`,
           errors: [
             {
-              messageId: 'unsafeArrayPatternFromTuple',
-              line: 1,
               column: column + 1,
               endColumn: endColumn + 1,
+              line: 1,
+              messageId: 'unsafeArrayPatternFromTuple',
             },
           ],
         });
@@ -73,104 +75,6 @@ const ruleTester = new RuleTester({
 });
 
 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] as number[];',
-    'const [x, ...y] = [1, 2, 3, 4, 5];',
-    'const [x, ...y] = [1];',
-    'const [{ ...x }] = [{ x: 1 }] as [{ x: any }];',
-    '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 = 1 };',
-    noFormat`const x = { y(){} };`,
-    'const x: { y: number } = { y: 1 };',
-    'const x = [...[1, 2, 3]];',
-    'const [{ [`x${1}`]: x }] = [{ [`x`]: 1 }] as [{ [`x`]: any }];',
-    `
-type T = [string, T[]];
-const test: T = ['string', []] as T;
-    `,
-    {
-      code: `
-type Props = { a: string };
-declare function Foo(props: Props): never;
-<Foo a={'foo'} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-
-    {
-      code: `
-declare function Foo(props: { a: string }): never;
-<Foo a="foo" />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    {
-      code: `
-declare function Foo(props: { a: string }): never;
-<Foo a={} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    'const x: unknown = y as any;',
-    'const x: unknown[] = y as any[];',
-    'const x: Set<unknown> = y as Set<any>;',
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    'const x: Map<string, string> = new Map();',
-    `
-type Foo = { bar: unknown };
-const bar: any = 1;
-const foo: Foo = { bar };
-    `,
-  ],
   invalid: [
     {
       code: 'const x = 1 as any;',
@@ -209,8 +113,8 @@ const [x] = spooky;
       `,
       errors: [
         {
+          data: { receiver: 'error typed', sender: 'error typed' },
           messageId: 'anyAssignment',
-          data: { sender: 'error typed', receiver: 'error typed' },
         },
       ],
     },
@@ -220,8 +124,8 @@ const [[[x]]] = [spooky];
       `,
       errors: [
         {
+          data: { receiver: 'error typed', sender: 'error typed' },
           messageId: 'unsafeArrayPatternFromTuple',
-          data: { sender: 'error typed', receiver: 'error typed' },
         },
       ],
     },
@@ -233,12 +137,12 @@ const {
       `,
       errors: [
         {
+          data: { receiver: 'error typed', sender: 'error typed' },
           messageId: 'unsafeArrayPatternFromTuple',
-          data: { sender: 'error typed', receiver: 'error typed' },
         },
         {
+          data: { receiver: 'error typed', sender: 'error typed' },
           messageId: 'anyAssignment',
-          data: { sender: 'error typed', receiver: 'error typed' },
         },
       ],
     },
@@ -250,10 +154,10 @@ value = spooky;
       `,
       errors: [
         {
-          messageId: 'anyAssignment',
           data: {
             sender: 'error typed',
           },
+          messageId: 'anyAssignment',
         },
       ],
     },
@@ -274,11 +178,11 @@ const [x] = [] as any[];
       code: 'const x: Set<string> = new Set<any>();',
       errors: [
         {
-          messageId: 'unsafeAssignment',
           data: {
-            sender: '`Set<any>`',
             receiver: '`Set<string>`',
+            sender: '`Set<any>`',
           },
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -286,11 +190,11 @@ const [x] = [] as any[];
       code: 'const x: Map<string, string> = new Map<string, any>();',
       errors: [
         {
-          messageId: 'unsafeAssignment',
           data: {
-            sender: '`Map<string, any>`',
             receiver: '`Map<string, string>`',
+            sender: '`Map<string, any>`',
           },
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -298,11 +202,11 @@ const [x] = [] as any[];
       code: 'const x: Set<string[]> = new Set<any[]>();',
       errors: [
         {
-          messageId: 'unsafeAssignment',
           data: {
-            sender: '`Set<any[]>`',
             receiver: '`Set<string[]>`',
+            sender: '`Set<any[]>`',
           },
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -310,11 +214,11 @@ const [x] = [] as any[];
       code: 'const x: Set<Set<Set<string>>> = new Set<Set<Set<any>>>();',
       errors: [
         {
-          messageId: 'unsafeAssignment',
           data: {
-            sender: '`Set<Set<Set<any>>>`',
             receiver: '`Set<Set<Set<string>>>`',
+            sender: '`Set<Set<Set<any>>>`',
           },
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -332,10 +236,10 @@ const [x] = [] as any[];
       code: '[[[[x]]]] = [1 as any];',
       errors: [
         {
-          messageId: 'unsafeAssignment',
-          line: 1,
           column: 1,
           endColumn: 23,
+          line: 1,
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -364,9 +268,9 @@ const x = [...([] as any[])];
       code: 'const x = { y: 1 as any };',
       errors: [
         {
-          messageId: 'anyAssignment',
           column: 13,
           endColumn: 24,
+          messageId: 'anyAssignment',
         },
       ],
     },
@@ -374,9 +278,9 @@ const x = [...([] as any[])];
       code: 'const x = { y: { z: 1 as any } };',
       errors: [
         {
-          messageId: 'anyAssignment',
           column: 18,
           endColumn: 29,
+          messageId: 'anyAssignment',
         },
       ],
     },
@@ -384,13 +288,13 @@ const x = [...([] as any[])];
       code: 'const x: { y: Set<Set<Set<string>>> } = { y: new Set<Set<Set<any>>>() };',
       errors: [
         {
-          messageId: 'unsafeAssignment',
           column: 43,
-          endColumn: 70,
           data: {
-            sender: '`Set<Set<Set<any>>>`',
             receiver: '`Set<Set<Set<string>>>`',
+            sender: '`Set<Set<Set<any>>>`',
           },
+          endColumn: 70,
+          messageId: 'unsafeAssignment',
         },
       ],
     },
@@ -399,9 +303,9 @@ const x = [...([] as any[])];
       errors: [
         {
           // spreading an any widens the object type to any
-          messageId: 'anyAssignment',
           column: 7,
           endColumn: 28,
+          messageId: 'anyAssignment',
         },
       ],
     },
@@ -412,6 +316,14 @@ type Props = { a: string };
 declare function Foo(props: Props): never;
 <Foo a={1 as any} />;
       `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 17,
+          line: 4,
+          messageId: 'anyAssignment',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -419,14 +331,6 @@ declare function Foo(props: Props): never;
           },
         },
       },
-      errors: [
-        {
-          messageId: 'anyAssignment',
-          line: 4,
-          column: 9,
-          endColumn: 17,
-        },
-      ],
     },
     {
       code: `
@@ -436,10 +340,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'anyAssignmentThis',
-          line: 3,
           column: 9,
           endColumn: 19,
+          line: 3,
+          messageId: 'anyAssignmentThis',
         },
       ],
     },
@@ -450,10 +354,10 @@ const test: T = ['string', []] as any;
       `,
       errors: [
         {
-          messageId: 'anyAssignment',
-          line: 3,
           column: 7,
           endColumn: 38,
+          line: 3,
+          messageId: 'anyAssignment',
         },
       ],
     },
@@ -465,12 +369,110 @@ const foo: Foo = { bar };
       `,
       errors: [
         {
-          messageId: 'anyAssignment',
-          line: 4,
           column: 20,
           endColumn: 23,
+          line: 4,
+          messageId: 'anyAssignment',
         },
       ],
     },
   ],
+  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] as number[];',
+    'const [x, ...y] = [1, 2, 3, 4, 5];',
+    'const [x, ...y] = [1];',
+    'const [{ ...x }] = [{ x: 1 }] as [{ x: any }];',
+    '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 = 1 };',
+    noFormat`const x = { y(){} };`,
+    'const x: { y: number } = { y: 1 };',
+    'const x = [...[1, 2, 3]];',
+    'const [{ [`x${1}`]: x }] = [{ [`x`]: 1 }] as [{ [`x`]: any }];',
+    `
+type T = [string, T[]];
+const test: T = ['string', []] as T;
+    `,
+    {
+      code: `
+type Props = { a: string };
+declare function Foo(props: Props): never;
+<Foo a={'foo'} />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+
+    {
+      code: `
+declare function Foo(props: { a: string }): never;
+<Foo a="foo" />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+declare function Foo(props: { a: string }): never;
+<Foo a={} />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    'const x: unknown = y as any;',
+    'const x: unknown[] = y as any[];',
+    'const x: Set<unknown> = y as Set<any>;',
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    'const x: Map<string, string> = new Map();',
+    `
+type Foo = { bar: unknown };
+const bar: any = 1;
+const foo: Foo = { bar };
+    `,
+  ],
 });
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 1a26a4ef3d33..c32493858839 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -14,37 +14,6 @@ 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');",
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1825
-    `
-      let foo: any = 23;
-      String(foo); // ERROR: Unsafe call of an any typed value
-    `,
-    // TS 3.9 changed this to be safe
-    `
-      function foo<T extends any>(x: T) {
-        x();
-      }
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -54,13 +23,13 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 4,
           data: {
             type: '`any`',
           },
+          endColumn: 4,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -72,13 +41,13 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 4,
           data: {
             type: '`any`',
           },
+          endColumn: 4,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -90,13 +59,13 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 18,
           data: {
             type: '`any`',
           },
+          endColumn: 18,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -108,13 +77,13 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 18,
           data: {
             type: '`any`',
           },
+          endColumn: 18,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -126,13 +95,13 @@ function foo(x: { a: any }) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 6,
           data: {
             type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -144,13 +113,13 @@ function foo(x: { a: any }) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 7,
           data: {
             type: '`any`',
           },
+          endColumn: 7,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -162,13 +131,13 @@ function foo(x: { a: any }) {
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 3,
-          endColumn: 6,
           data: {
             type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
@@ -221,16 +190,16 @@ const methods = {
       `,
       errors: [
         {
-          messageId: 'unsafeCallThis',
-          line: 4,
           column: 12,
           endColumn: 24,
+          line: 4,
+          messageId: 'unsafeCallThis',
         },
         {
-          messageId: 'unsafeCallThis',
-          line: 10,
           column: 12,
           endColumn: 16,
+          line: 10,
+          messageId: 'unsafeCallThis',
         },
       ],
     },
@@ -241,15 +210,46 @@ value();
       `,
       errors: [
         {
-          messageId: 'unsafeCall',
-          line: 3,
           column: 1,
-          endColumn: 6,
           data: {
             type: '`error` type',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeCall',
         },
       ],
     },
   ],
+  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');",
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1825
+    `
+      let foo: any = 23;
+      String(foo); // ERROR: Unsafe call of an any typed value
+    `,
+    // TS 3.9 changed this to be safe
+    `
+      function foo<T extends any>(x: T) {
+        x();
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
index 8d724ef6f1c2..cbd58771b0d2 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
@@ -8,59 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('no-unsafe-declaration-merging', rule, {
-  valid: [
-    `
-interface Foo {}
-class Bar implements Foo {}
-    `,
-    `
-namespace Foo {}
-namespace Foo {}
-    `,
-    `
-enum Foo {}
-namespace Foo {}
-    `,
-    `
-namespace Fooo {}
-function Foo() {}
-    `,
-    `
-const Foo = class {};
-    `,
-    `
-interface Foo {
-  props: string;
-}
-
-function bar() {
-  return class Foo {};
-}
-    `,
-    `
-interface Foo {
-  props: string;
-}
-
-(function bar() {
-  class Foo {}
-})();
-    `,
-    `
-declare global {
-  interface Foo {}
-}
-
-class Foo {}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -69,14 +23,14 @@ class Foo {}
       `,
       errors: [
         {
-          messageId: 'unsafeMerging',
-          line: 2,
           column: 11,
+          line: 2,
+          messageId: 'unsafeMerging',
         },
         {
-          messageId: 'unsafeMerging',
-          line: 3,
           column: 7,
+          line: 3,
+          messageId: 'unsafeMerging',
         },
       ],
     },
@@ -87,14 +41,14 @@ interface Foo {}
       `,
       errors: [
         {
-          messageId: 'unsafeMerging',
-          line: 2,
           column: 7,
+          line: 2,
+          messageId: 'unsafeMerging',
         },
         {
-          messageId: 'unsafeMerging',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'unsafeMerging',
         },
       ],
     },
@@ -107,16 +61,62 @@ declare global {
       `,
       errors: [
         {
-          messageId: 'unsafeMerging',
-          line: 3,
           column: 13,
+          line: 3,
+          messageId: 'unsafeMerging',
         },
         {
-          messageId: 'unsafeMerging',
-          line: 4,
           column: 9,
+          line: 4,
+          messageId: 'unsafeMerging',
         },
       ],
     },
   ],
+  valid: [
+    `
+interface Foo {}
+class Bar implements Foo {}
+    `,
+    `
+namespace Foo {}
+namespace Foo {}
+    `,
+    `
+enum Foo {}
+namespace Foo {}
+    `,
+    `
+namespace Fooo {}
+function Foo() {}
+    `,
+    `
+const Foo = class {};
+    `,
+    `
+interface Foo {
+  props: string;
+}
+
+function bar() {
+  return class Foo {};
+}
+    `,
+    `
+interface Foo {
+  props: string;
+}
+
+(function bar() {
+  class Foo {}
+})();
+    `,
+    `
+declare global {
+  interface Foo {}
+}
+
+class Foo {}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
index ab5b488dd7d5..ffa4fbf1fa9f 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
@@ -8,334 +8,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-unsafe-enum-comparison', rule, {
-  valid: [
-    "'a' > 'b';",
-    "'a' < 'b';",
-    "'a' == 'b';",
-    "'a' === 'b';",
-    '1 > 2;',
-    '1 < 2;',
-    '1 == 2;',
-    '1 === 2;',
-    `
-      enum Fruit {
-        Apple,
-      }
-      Fruit.Apple === ({} as any);
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      Fruit.Apple === undefined;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      Fruit.Apple === null;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      declare const fruit: Fruit | -1;
-      fruit === -1;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      declare const fruit: Fruit | number;
-      fruit === -1;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      declare const fruit: Fruit | 'apple';
-      fruit === 'apple';
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      declare const fruit: Fruit | string;
-      fruit === 'apple';
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | 'apple';
-      fruit === 'apple';
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | string;
-      fruit === 'apple';
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | 0;
-      fruit === 0;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | number;
-      fruit === 0;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-      declare const fruit: Fruit | 'apple';
-      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | 'apple';
-      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | string;
-      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | 0;
-      fruit === Math.random() > 0.5 ? 0 : Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-      }
-      declare const fruit: Fruit | number;
-      fruit === Math.random() > 0.5 ? 0 : Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-      }
-      Fruit.Apple === Fruit.Banana;
-    `,
-    `
-      enum Fruit {
-        Apple = 0,
-        Banana = 1,
-      }
-      Fruit.Apple === Fruit.Banana;
-    `,
-    `
-      enum Fruit {
-        Apple = 'apple',
-        Banana = 'banana',
-      }
-      Fruit.Apple === Fruit.Banana;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-      }
-      const fruit = Fruit.Apple;
-      fruit === Fruit.Banana;
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
-      }
-      const vegetable = Vegetable.Asparagus;
-      vegetable === Vegetable.Beet;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-        Cherry,
-      }
-      const fruit1 = Fruit.Apple;
-      const fruit2 = Fruit.Banana;
-      fruit1 === fruit2;
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
-      }
-      const vegetable1 = Vegetable.Asparagus;
-      const vegetable2 = Vegetable.Beet;
-      vegetable1 === vegetable2;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-        Cherry,
-      }
-      enum Fruit2 {
-        Apple2,
-        Banana2,
-        Cherry2,
-      }
-      declare const left: number | Fruit;
-      declare const right: number | Fruit2;
-      left === right;
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
-      }
-      enum Vegetable2 {
-        Asparagus2 = 'asparagus2',
-        Beet2 = 'beet2',
-        Celery2 = 'celery2',
-      }
-      declare const left: string | Vegetable;
-      declare const right: string | Vegetable2;
-      left === right;
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
-      }
-      const foo = {};
-      const vegetable = Vegetable.Asparagus;
-      vegetable in foo;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-        Cherry,
-      }
-      declare const fruitOrBoolean: Fruit | boolean;
-      fruitOrBoolean === true;
-    `,
-    `
-      enum Str {
-        A = 'a',
-      }
-      enum Num {
-        B = 1,
-      }
-      enum Mixed {
-        A = 'a',
-        B = 1,
-      }
-
-      declare const str: Str;
-      declare const strOrString: Str | string;
-
-      declare const num: Num;
-      declare const numOrNumber: Num | number;
-
-      declare const mixed: Mixed;
-      declare const mixedOrStringOrNumber: Mixed | string | number;
-
-      function someFunction() {}
-
-      // following are all ignored due to the presence of "| string" or "| number"
-      strOrString === 'a';
-      numOrNumber === 1;
-      mixedOrStringOrNumber === 'a';
-      mixedOrStringOrNumber === 1;
-
-      // following are all ignored because the value can never be an enum value
-      str === 1;
-      num === 'a';
-      str === {};
-      num === {};
-      mixed === {};
-      str === true;
-      num === true;
-      mixed === true;
-      str === someFunction;
-      num === someFunction;
-      mixed === someFunction;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-
-      const bitShift = 1 << Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-
-      const bitShift = 1 >> Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-
-      declare const fruit: Fruit;
-
-      switch (fruit) {
-        case Fruit.Apple: {
-          break;
-        }
-      }
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-      }
-
-      declare const vegetable: Vegetable;
-
-      switch (vegetable) {
-        case Vegetable.Asparagus: {
-          break;
-        }
-      }
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-      }
-
-      declare const vegetable: Vegetable;
-
-      switch (vegetable) {
-        default: {
-          break;
-        }
-      }
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -1247,4 +926,325 @@ ruleTester.run('no-unsafe-enum-comparison', rule, {
       errors: [{ messageId: 'mismatchedCondition' }],
     },
   ],
+  valid: [
+    "'a' > 'b';",
+    "'a' < 'b';",
+    "'a' == 'b';",
+    "'a' === 'b';",
+    '1 > 2;',
+    '1 < 2;',
+    '1 == 2;',
+    '1 === 2;',
+    `
+      enum Fruit {
+        Apple,
+      }
+      Fruit.Apple === ({} as any);
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      Fruit.Apple === undefined;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      Fruit.Apple === null;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      declare const fruit: Fruit | -1;
+      fruit === -1;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      declare const fruit: Fruit | number;
+      fruit === -1;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      declare const fruit: Fruit | 'apple';
+      fruit === 'apple';
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      declare const fruit: Fruit | string;
+      fruit === 'apple';
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | 'apple';
+      fruit === 'apple';
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | string;
+      fruit === 'apple';
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | 0;
+      fruit === 0;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | number;
+      fruit === 0;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+      declare const fruit: Fruit | 'apple';
+      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | 'apple';
+      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | string;
+      fruit === Math.random() > 0.5 ? 'apple' : Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | 0;
+      fruit === Math.random() > 0.5 ? 0 : Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+      }
+      declare const fruit: Fruit | number;
+      fruit === Math.random() > 0.5 ? 0 : Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+      }
+      Fruit.Apple === Fruit.Banana;
+    `,
+    `
+      enum Fruit {
+        Apple = 0,
+        Banana = 1,
+      }
+      Fruit.Apple === Fruit.Banana;
+    `,
+    `
+      enum Fruit {
+        Apple = 'apple',
+        Banana = 'banana',
+      }
+      Fruit.Apple === Fruit.Banana;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+      }
+      const fruit = Fruit.Apple;
+      fruit === Fruit.Banana;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      const vegetable = Vegetable.Asparagus;
+      vegetable === Vegetable.Beet;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+        Cherry,
+      }
+      const fruit1 = Fruit.Apple;
+      const fruit2 = Fruit.Banana;
+      fruit1 === fruit2;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      const vegetable1 = Vegetable.Asparagus;
+      const vegetable2 = Vegetable.Beet;
+      vegetable1 === vegetable2;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+        Cherry,
+      }
+      enum Fruit2 {
+        Apple2,
+        Banana2,
+        Cherry2,
+      }
+      declare const left: number | Fruit;
+      declare const right: number | Fruit2;
+      left === right;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      enum Vegetable2 {
+        Asparagus2 = 'asparagus2',
+        Beet2 = 'beet2',
+        Celery2 = 'celery2',
+      }
+      declare const left: string | Vegetable;
+      declare const right: string | Vegetable2;
+      left === right;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      const foo = {};
+      const vegetable = Vegetable.Asparagus;
+      vegetable in foo;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+        Cherry,
+      }
+      declare const fruitOrBoolean: Fruit | boolean;
+      fruitOrBoolean === true;
+    `,
+    `
+      enum Str {
+        A = 'a',
+      }
+      enum Num {
+        B = 1,
+      }
+      enum Mixed {
+        A = 'a',
+        B = 1,
+      }
+
+      declare const str: Str;
+      declare const strOrString: Str | string;
+
+      declare const num: Num;
+      declare const numOrNumber: Num | number;
+
+      declare const mixed: Mixed;
+      declare const mixedOrStringOrNumber: Mixed | string | number;
+
+      function someFunction() {}
+
+      // following are all ignored due to the presence of "| string" or "| number"
+      strOrString === 'a';
+      numOrNumber === 1;
+      mixedOrStringOrNumber === 'a';
+      mixedOrStringOrNumber === 1;
+
+      // following are all ignored because the value can never be an enum value
+      str === 1;
+      num === 'a';
+      str === {};
+      num === {};
+      mixed === {};
+      str === true;
+      num === true;
+      mixed === true;
+      str === someFunction;
+      num === someFunction;
+      mixed === someFunction;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      const bitShift = 1 << Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      const bitShift = 1 >> Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      declare const fruit: Fruit;
+
+      switch (fruit) {
+        case Fruit.Apple: {
+          break;
+        }
+      }
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+      }
+
+      declare const vegetable: Vegetable;
+
+      switch (vegetable) {
+        case Vegetable.Asparagus: {
+          break;
+        }
+      }
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+      }
+
+      declare const vegetable: Vegetable;
+
+      switch (vegetable) {
+        default: {
+          break;
+        }
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
index 75c116a66aa5..2ec23a17db1b 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
@@ -5,47 +5,39 @@ import rule from '../../src/rules/no-unsafe-function-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unsafe-function-type', rule, {
-  valid: [
-    'let value: () => void;',
-    'let value: <T>(t: T) => T;',
-    `
-      type Function = () => void;
-      let value: Function;
-    `,
-  ],
   invalid: [
     {
       code: 'let value: Function;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedFunctionType',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'bannedFunctionType',
         },
       ],
+      output: null,
     },
     {
       code: 'let value: Function[];',
-      output: null,
       errors: [
         {
-          messageId: 'bannedFunctionType',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'bannedFunctionType',
         },
       ],
+      output: null,
     },
     {
       code: 'let value: Function | number;',
-      output: null,
       errors: [
         {
-          messageId: 'bannedFunctionType',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'bannedFunctionType',
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -53,14 +45,14 @@ ruleTester.run('no-unsafe-function-type', rule, {
           // ...
         }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'bannedFunctionType',
-          line: 2,
           column: 32,
+          line: 2,
+          messageId: 'bannedFunctionType',
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -68,14 +60,22 @@ ruleTester.run('no-unsafe-function-type', rule, {
           // ...
         }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'bannedFunctionType',
-          line: 2,
           column: 33,
+          line: 2,
+          messageId: 'bannedFunctionType',
         },
       ],
+      output: null,
     },
   ],
+  valid: [
+    'let value: () => void;',
+    'let value: <T>(t: T) => T;',
+    `
+      type Function = () => void;
+      let value: Function;
+    `,
+  ],
 });
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 de597dd9ba8e..78d08c4bceec 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
@@ -14,60 +14,6 @@ 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];
-}
-    `,
-    `
-class B implements FG.A {}
-    `,
-    `
-interface B extends FG.A {}
-    `,
-    `
-class B implements F.S.T.A {}
-    `,
-    `
-interface B extends F.S.T.A {}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -77,14 +23,14 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 3,
           column: 5,
-          endColumn: 6,
           data: {
-            type: '`any`',
             property: '.a',
+            type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -96,14 +42,14 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 3,
           column: 5,
-          endColumn: 6,
           data: {
-            type: '`any`',
             property: '.a',
+            type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -115,14 +61,14 @@ function foo(x: { a: any }) {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 3,
           column: 7,
-          endColumn: 8,
           data: {
-            type: '`any`',
             property: '.b',
+            type: '`any`',
           },
+          endColumn: 8,
+          line: 3,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -134,14 +80,14 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 3,
           column: 5,
-          endColumn: 8,
           data: {
-            type: '`any`',
             property: "['a']",
+            type: '`any`',
           },
+          endColumn: 8,
+          line: 3,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -153,14 +99,14 @@ function foo(x: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 3,
           column: 5,
-          endColumn: 8,
           data: {
-            type: '`any`',
             property: "['a']",
+            type: '`any`',
           },
+          endColumn: 8,
+          line: 3,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -172,14 +118,14 @@ value.property;
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 4,
           column: 7,
-          endColumn: 15,
           data: {
-            type: '`error` typed',
             property: '.property',
+            type: '`error` typed',
           },
+          endColumn: 15,
+          line: 4,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
@@ -191,14 +137,14 @@ function foo(x: { a: number }, y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 5,
-          endColumn: 6,
           data: {
             property: '[y]',
             type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -210,14 +156,14 @@ function foo(x?: { a: number }, y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 7,
-          endColumn: 8,
           data: {
             property: '[y]',
             type: '`any`',
           },
+          endColumn: 8,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -229,14 +175,14 @@ function foo(x: { a: number }, y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 6,
-          endColumn: 12,
           data: {
             property: '[y += 1]',
             type: '`any`',
           },
+          endColumn: 12,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -248,14 +194,14 @@ function foo(x: { a: number }, y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 5,
-          endColumn: 13,
           data: {
             property: '[1 as any]',
             type: '`any`',
           },
+          endColumn: 13,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -267,14 +213,14 @@ function foo(x: { a: number }, y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 5,
-          endColumn: 8,
           data: {
             property: '[y()]',
             type: '`any`',
           },
+          endColumn: 8,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -286,14 +232,14 @@ function foo(x: string[], y: any) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 5,
-          endColumn: 6,
           data: {
             property: '[y]',
             type: '`any`',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -305,14 +251,14 @@ function foo(x: { a: number }, y: NotKnown) {
       `,
       errors: [
         {
-          messageId: 'unsafeComputedMemberAccess',
-          line: 3,
           column: 5,
-          endColumn: 6,
           data: {
             property: '[y]',
             type: '`error` typed',
           },
+          endColumn: 6,
+          line: 3,
+          messageId: 'unsafeComputedMemberAccess',
         },
       ],
     },
@@ -337,22 +283,22 @@ const methods = {
       `,
       errors: [
         {
-          messageId: 'unsafeThisMemberExpression',
-          line: 4,
           column: 17,
           endColumn: 24,
+          line: 4,
+          messageId: 'unsafeThisMemberExpression',
         },
         {
-          messageId: 'unsafeThisMemberExpression',
-          line: 8,
           column: 17,
           endColumn: 30,
+          line: 8,
+          messageId: 'unsafeThisMemberExpression',
         },
         {
-          messageId: 'unsafeThisMemberExpression',
-          line: 14,
           column: 19,
           endColumn: 26,
+          line: 14,
+          messageId: 'unsafeThisMemberExpression',
         },
       ],
     },
@@ -369,18 +315,72 @@ class C {
       `,
       errors: [
         {
-          messageId: 'unsafeMemberExpression',
-          line: 5,
           column: 18,
           endColumn: 22,
+          line: 5,
+          messageId: 'unsafeMemberExpression',
         },
         {
-          messageId: 'unsafeMemberExpression',
-          line: 5,
           column: 25,
           endColumn: 34,
+          line: 5,
+          messageId: 'unsafeMemberExpression',
         },
       ],
     },
   ],
+  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];
+}
+    `,
+    `
+class B implements FG.A {}
+    `,
+    `
+interface B extends FG.A {}
+    `,
+    `
+class B implements F.S.T.A {}
+    `,
+    `
+interface B extends F.S.T.A {}
+    `,
+  ],
 });
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 6f64ed565972..3ffa255f92b8 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
@@ -14,153 +14,6 @@ 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;
-}
-    `,
-    // this actually types as `never[]`
-    `
-function foo() {
-  return [];
-}
-    `,
-    // explicit any return type is allowed, if you want to be unsafe like that
-    `
-function foo(): any {
-  return {} as any;
-}
-    `,
-    `
-declare function foo(arg: () => any): void;
-foo((): any => 'foo' as any);
-    `,
-    `
-declare function foo(arg: null | (() => any)): void;
-foo((): any => 'foo' as any);
-    `,
-    // explicit any array return type is allowed, if you want to be unsafe like that
-    `
-function foo(): any[] {
-  return [] as any[];
-}
-    `,
-    // explicit any generic return type is allowed, if you want to be unsafe like that
-    `
-function foo(): Set<any> {
-  return new Set<any>();
-}
-    `,
-    `
-async function foo(): Promise<any> {
-  return Promise.resolve({} as any);
-}
-    `,
-    `
-async function foo(): Promise<any> {
-  return {} as any;
-}
-    `,
-    `
-function foo(): object {
-  return Promise.resolve({} as 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]);
-}
-    `,
-    `
-      type Foo<T = number> = { prop: T };
-      function foo(): Foo {
-        return { prop: 1 } as Foo<number>;
-      }
-    `,
-    `
-      type Foo = { prop: any };
-      function foo(): Foo {
-        return { prop: '' } as Foo;
-      }
-    `,
-    // TS 3.9 changed this to be safe
-    `
-      function fn<T extends any>(x: T) {
-        return x;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): unknown {
-        return x as any;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): unknown[] {
-        return x as any[];
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): Set<unknown> {
-        return x as Set<any>;
-      }
-    `,
-    `
-      async function fn<T extends any>(x: T): Promise<unknown> {
-        return x as any;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): Promise<unknown> {
-        return Promise.resolve(x as any);
-      }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    `
-      function test(): Map<string, string> {
-        return new Map();
-      }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3549
-    `
-      function foo(): any {
-        return [] as any[];
-      }
-    `,
-    `
-      function foo(): unknown {
-        return [] as any[];
-      }
-    `,
-    `
-      declare const value: Promise<any>;
-      function foo() {
-        return value;
-      }
-    `,
-    'const foo: (() => void) | undefined = () => 1;',
-  ],
   invalid: [
     {
       code: `
@@ -170,10 +23,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -185,10 +38,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -200,10 +53,10 @@ const foo = () => {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -211,10 +64,10 @@ const foo = () => {
       code: 'const foo = () => Object.create(null);',
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -226,10 +79,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -241,10 +94,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -256,10 +109,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -271,10 +124,10 @@ function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -286,10 +139,10 @@ const foo = () => {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -297,10 +150,10 @@ const foo = () => {
       code: 'const foo = () => [] as any[];',
       errors: [
         {
-          messageId: 'unsafeReturn',
           data: {
             type: '`any[]`',
           },
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -312,11 +165,11 @@ function foo(): Set<string> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -328,11 +181,11 @@ function foo(): Map<string, string> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
           data: {
-            sender: 'Map<string, any>',
             receiver: 'Map<string, string>',
+            sender: 'Map<string, any>',
           },
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -344,11 +197,11 @@ function foo(): Set<string[]> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
           data: {
-            sender: 'Set<any[]>',
             receiver: 'Set<string[]>',
+            sender: 'Set<any[]>',
           },
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -360,11 +213,11 @@ function foo(): Set<Set<Set<string>>> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
           data: {
-            sender: 'Set<Set<Set<any>>>',
             receiver: 'Set<Set<Set<string>>>',
+            sender: 'Set<Set<Set<any>>>',
           },
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -379,20 +232,20 @@ const foo2: Fn = function test() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
-          line: 3,
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          line: 3,
+          messageId: 'unsafeReturnAssignment',
         },
         {
-          messageId: 'unsafeReturnAssignment',
-          line: 5,
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          line: 5,
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -407,20 +260,20 @@ receiver(function test() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnAssignment',
-          line: 4,
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          line: 4,
+          messageId: 'unsafeReturnAssignment',
         },
         {
-          messageId: 'unsafeReturnAssignment',
-          line: 6,
           data: {
-            sender: 'Set<any>',
             receiver: 'Set<string>',
+            sender: 'Set<any>',
           },
+          line: 6,
+          messageId: 'unsafeReturnAssignment',
         },
       ],
     },
@@ -436,22 +289,22 @@ function bar() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturnThis',
-          line: 3,
           column: 3,
-          endColumn: 15,
           data: {
             type: '`any`',
           },
+          endColumn: 15,
+          line: 3,
+          messageId: 'unsafeReturnThis',
         },
         {
-          messageId: 'unsafeReturnThis',
-          line: 7,
           column: 16,
-          endColumn: 20,
           data: {
             type: '`any`',
           },
+          endColumn: 20,
+          line: 7,
+          messageId: 'unsafeReturnThis',
         },
       ],
     },
@@ -462,13 +315,13 @@ foo(() => 'foo' as any);
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 11,
-          endColumn: 23,
           data: {
             type: '`any`',
           },
+          endColumn: 23,
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -482,13 +335,13 @@ function example() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 5,
           column: 3,
-          endColumn: 16,
           data: {
             type: 'error',
           },
+          endColumn: 16,
+          line: 5,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -501,12 +354,12 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 4,
           column: 3,
           data: {
             type: '`any`',
           },
+          line: 4,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -519,12 +372,12 @@ async function foo(): Promise<number> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 4,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 4,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -536,12 +389,12 @@ async function foo(arg: number) {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -553,12 +406,12 @@ function foo(): Promise<any> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`any`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -570,12 +423,12 @@ function foo(): Promise<object> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`any`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -587,12 +440,12 @@ async function foo(): Promise<object> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -604,12 +457,12 @@ async function foo(): Promise<object> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -621,12 +474,12 @@ async function foo(): Promise<object> {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -638,12 +491,12 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -655,12 +508,12 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -672,12 +525,12 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -689,12 +542,12 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 3,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 3,
+          messageId: 'unsafeReturn',
         },
       ],
     },
@@ -711,14 +564,161 @@ async function foo() {
       `,
       errors: [
         {
-          messageId: 'unsafeReturn',
-          line: 8,
           column: 3,
           data: {
             type: '`Promise<any>`',
           },
+          line: 8,
+          messageId: 'unsafeReturn',
         },
       ],
     },
   ],
+  valid: [
+    `
+function foo() {
+  return;
+}
+    `,
+    `
+function foo() {
+  return 1;
+}
+    `,
+    `
+function foo() {
+  return '';
+}
+    `,
+    `
+function foo() {
+  return true;
+}
+    `,
+    // this actually types as `never[]`
+    `
+function foo() {
+  return [];
+}
+    `,
+    // explicit any return type is allowed, if you want to be unsafe like that
+    `
+function foo(): any {
+  return {} as any;
+}
+    `,
+    `
+declare function foo(arg: () => any): void;
+foo((): any => 'foo' as any);
+    `,
+    `
+declare function foo(arg: null | (() => any)): void;
+foo((): any => 'foo' as any);
+    `,
+    // explicit any array return type is allowed, if you want to be unsafe like that
+    `
+function foo(): any[] {
+  return [] as any[];
+}
+    `,
+    // explicit any generic return type is allowed, if you want to be unsafe like that
+    `
+function foo(): Set<any> {
+  return new Set<any>();
+}
+    `,
+    `
+async function foo(): Promise<any> {
+  return Promise.resolve({} as any);
+}
+    `,
+    `
+async function foo(): Promise<any> {
+  return {} as any;
+}
+    `,
+    `
+function foo(): object {
+  return Promise.resolve({} as 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]);
+}
+    `,
+    `
+      type Foo<T = number> = { prop: T };
+      function foo(): Foo {
+        return { prop: 1 } as Foo<number>;
+      }
+    `,
+    `
+      type Foo = { prop: any };
+      function foo(): Foo {
+        return { prop: '' } as Foo;
+      }
+    `,
+    // TS 3.9 changed this to be safe
+    `
+      function fn<T extends any>(x: T) {
+        return x;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): unknown {
+        return x as any;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): unknown[] {
+        return x as any[];
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): Set<unknown> {
+        return x as Set<any>;
+      }
+    `,
+    `
+      async function fn<T extends any>(x: T): Promise<unknown> {
+        return x as any;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): Promise<unknown> {
+        return Promise.resolve(x as any);
+      }
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    `
+      function test(): Map<string, string> {
+        return new Map();
+      }
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3549
+    `
+      function foo(): any {
+        return [] as any[];
+      }
+    `,
+    `
+      function foo(): unknown {
+        return [] as any[];
+      }
+    `,
+    `
+      declare const value: Promise<any>;
+      function foo() {
+        return value;
+      }
+    `,
+    'const foo: (() => void) | undefined = () => 1;',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
index db0c7d2defa3..2e047a0477d4 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
@@ -7,13 +7,27 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('no-unsafe-unary-minus', rule, {
+  invalid: [
+    { code: '(a: string) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: {}) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: number[]) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: "-'hello';", errors: [{ messageId: 'unaryMinus' }] },
+    { code: '-`hello`;', errors: [{ messageId: 'unaryMinus' }] },
+    {
+      code: '(a: { x: number }) => -a;',
+      errors: [{ messageId: 'unaryMinus' }],
+    },
+    { code: '(a: unknown) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: void) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '<T,>(t: T) => -t;', errors: [{ messageId: 'unaryMinus' }] },
+  ],
   valid: [
     '+42;',
     '-42;',
@@ -30,18 +44,4 @@ ruleTester.run('no-unsafe-unary-minus', rule, {
     '(a: never) => -a;',
     '<T extends number>(t: T) => -t;',
   ],
-  invalid: [
-    { code: '(a: string) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: {}) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: number[]) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: "-'hello';", errors: [{ messageId: 'unaryMinus' }] },
-    { code: '-`hello`;', errors: [{ messageId: 'unaryMinus' }] },
-    {
-      code: '(a: { x: number }) => -a;',
-      errors: [{ messageId: 'unaryMinus' }],
-    },
-    { code: '(a: unknown) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: void) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '<T,>(t: T) => -t;', errors: [{ messageId: 'unaryMinus' }] },
-  ],
 });
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 5587aef55183..04a7e40a1025 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
@@ -1,4 +1,5 @@
 import type { TestCaseError } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-unused-expressions';
@@ -26,68 +27,6 @@ function error(
 }
 
 ruleTester.run('no-unused-expressions', rule, {
-  valid: [
-    `
-      test.age?.toLocaleString();
-    `,
-    `
-      let a = (a?.b).c;
-    `,
-    `
-      let b = a?.['b'];
-    `,
-    `
-      let c = one[2]?.[3][4];
-    `,
-    `
-      one[2]?.[3][4]?.();
-    `,
-    `
-      a?.['b']?.c();
-    `,
-    `
-      module Foo {
-        'use strict';
-      }
-    `,
-    `
-      namespace Foo {
-        'use strict';
-
-        export class Foo {}
-        export class Bar {}
-      }
-    `,
-    `
-      function foo() {
-        'use strict';
-
-        return null;
-      }
-    `,
-    `
-      import('./foo');
-    `,
-    `
-      import('./foo').then(() => {});
-    `,
-    `
-      class Foo<T> {}
-      new Foo<string>();
-    `,
-    {
-      code: 'foo && foo?.();',
-      options: [{ allowShortCircuit: true }],
-    },
-    {
-      code: "foo && import('./foo');",
-      options: [{ allowShortCircuit: true }],
-    },
-    {
-      code: "foo ? import('./foo') : import('./bar');",
-      options: [{ allowTernary: true }],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -95,8 +34,8 @@ if (0) 0;
       `,
       errors: error([
         {
-          line: 2,
           column: 8,
+          line: 2,
         },
       ]),
     },
@@ -106,8 +45,8 @@ f(0), {};
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -117,8 +56,8 @@ a, b();
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -131,8 +70,8 @@ a() &&
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -142,8 +81,8 @@ a?.b;
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -153,8 +92,8 @@ a?.b;
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -164,8 +103,8 @@ a?.['b'];
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -175,8 +114,8 @@ a?.['b'];
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -186,8 +125,8 @@ a?.b()?.c;
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -197,8 +136,8 @@ a?.b()?.c;
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -208,8 +147,8 @@ one[2]?.[3][4];
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -219,8 +158,8 @@ one.two?.three.four;
       `,
       errors: error([
         {
-          line: 2,
           column: 1,
+          line: 2,
         },
       ]),
     },
@@ -233,10 +172,10 @@ module Foo {
       `,
       errors: error([
         {
-          line: 4,
-          endLine: 4,
           column: 3,
           endColumn: 16,
+          endLine: 4,
+          line: 4,
         },
       ]),
     },
@@ -251,10 +190,10 @@ namespace Foo {
       `,
       errors: error([
         {
-          line: 6,
-          endLine: 6,
           column: 3,
           endColumn: 16,
+          endLine: 6,
+          line: 6,
         },
       ]),
     },
@@ -268,36 +207,36 @@ function foo() {
       `,
       errors: error([
         {
-          line: 5,
-          endLine: 5,
           column: 3,
           endColumn: 16,
+          endLine: 5,
+          line: 5,
         },
       ]),
     },
     {
       code: 'foo && foo?.bar;',
-      options: [{ allowShortCircuit: true }],
       errors: error([
         {
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 17,
+          endLine: 1,
+          line: 1,
         },
       ]),
+      options: [{ allowShortCircuit: true }],
     },
     {
       code: 'foo ? foo?.bar : bar.baz;',
-      options: [{ allowTernary: true }],
       errors: error([
         {
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 26,
+          endLine: 1,
+          line: 1,
         },
       ]),
+      options: [{ allowTernary: true }],
     },
     {
       code: noFormat`
@@ -306,10 +245,10 @@ Foo<string>;
       `,
       errors: error([
         {
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 13,
+          endLine: 3,
+          line: 3,
         },
       ]),
     },
@@ -317,10 +256,10 @@ Foo<string>;
       code: 'Map<string, string>;',
       errors: error([
         {
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 21,
+          endLine: 1,
+          line: 1,
         },
       ]),
     },
@@ -331,10 +270,10 @@ foo;
       `,
       errors: error([
         {
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 5,
+          endLine: 3,
+          line: 3,
         },
       ]),
     },
@@ -345,10 +284,10 @@ foo as any;
       `,
       errors: error([
         {
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 12,
+          endLine: 3,
+          line: 3,
         },
       ]),
     },
@@ -359,10 +298,10 @@ declare const foo: number | undefined;
       `,
       errors: error([
         {
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 10,
+          endLine: 3,
+          line: 3,
         },
       ]),
     },
@@ -373,12 +312,74 @@ foo!;
       `,
       errors: error([
         {
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 6,
+          endLine: 3,
+          line: 3,
         },
       ]),
     },
   ],
+  valid: [
+    `
+      test.age?.toLocaleString();
+    `,
+    `
+      let a = (a?.b).c;
+    `,
+    `
+      let b = a?.['b'];
+    `,
+    `
+      let c = one[2]?.[3][4];
+    `,
+    `
+      one[2]?.[3][4]?.();
+    `,
+    `
+      a?.['b']?.c();
+    `,
+    `
+      module Foo {
+        'use strict';
+      }
+    `,
+    `
+      namespace Foo {
+        'use strict';
+
+        export class Foo {}
+        export class Bar {}
+      }
+    `,
+    `
+      function foo() {
+        'use strict';
+
+        return null;
+      }
+    `,
+    `
+      import('./foo');
+    `,
+    `
+      import('./foo').then(() => {});
+    `,
+    `
+      class Foo<T> {}
+      new Foo<string>();
+    `,
+    {
+      code: 'foo && foo?.();',
+      options: [{ allowShortCircuit: true }],
+    },
+    {
+      code: "foo && import('./foo');",
+      options: [{ allowShortCircuit: true }],
+    },
+    {
+      code: "foo ? import('./foo') : import('./bar');",
+      options: [{ allowTernary: true }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts b/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts
index cf2ace7e9539..c9048412d8c0 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts
@@ -3,11 +3,13 @@
 // License      : https://github.com/eslint/eslint/blob/eb76282e0a2db8aa10a3d5659f5f9237d9729121/LICENSE
 
 import type { TestCaseError } from '@typescript-eslint/rule-tester';
-import { RuleTester } from '@typescript-eslint/rule-tester';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { RuleTester } from '@typescript-eslint/rule-tester';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import type { MessageIds } from '../../../src/rules/no-unused-vars';
+
 import rule from '../../../src/rules/no-unused-vars';
 
 const ruleTester = new RuleTester({
@@ -28,15 +30,15 @@ ruleTester.defineRule('use-every-a', {
       context.sourceCode.markVariableAsUsed('a', node);
     }
     return {
-      VariableDeclaration: useA,
       ReturnStatement: useA,
+      VariableDeclaration: useA,
     };
   },
   defaultOptions: [],
   meta: {
     messages: {},
-    type: 'problem',
     schema: [],
+    type: 'problem',
   },
 });
 
@@ -52,12 +54,12 @@ function definedError(
   additional = '',
 ): TestCaseError<MessageIds> {
   return {
-    messageId: 'unusedVar',
     data: {
-      varName,
       action: 'defined',
       additional,
+      varName,
     },
+    messageId: 'unusedVar',
   };
 }
 
@@ -73,12 +75,12 @@ function assignedError(
   additional = '',
 ): TestCaseError<MessageIds> {
   return {
-    messageId: 'unusedVar',
     data: {
-      varName,
       action: 'assigned a value',
       additional,
+      varName,
     },
+    messageId: 'unusedVar',
   };
 }
 
@@ -95,3379 +97,3379 @@ function usedIgnoredError(
   type = AST_NODE_TYPES.Identifier,
 ): TestCaseError<MessageIds> {
   return {
-    messageId: 'usedIgnoredVar',
     data: {
-      varName,
       additional,
+      varName,
     },
+    messageId: 'usedIgnoredVar',
     type,
   };
 }
 
 ruleTester.run('no-unused-vars', rule, {
-  valid: [
-    `
-var foo = 5;
-
-label: while (true) {
-  console.log(foo);
-  break label;
-}
-    `,
-    `
-var foo = 5;
-
-while (true) {
-  console.log(foo);
-  break;
+  invalid: [
+    {
+      code: `
+function foox() {
+  return foox();
 }
-    `,
+      `,
+      errors: [definedError('foox')],
+    },
     {
       code: `
-for (let prop in box) {
-  box[prop] = parseInt(box[prop]);
+(function () {
+  function foox() {
+    if (true) {
+      return foox();
+    }
+  }
+})();
+      `,
+      errors: [definedError('foox')],
+    },
+    {
+      code: 'var a = 10;',
+      errors: [assignedError('a')],
+    },
+    {
+      code: `
+function f() {
+  var a = 1;
+  return function () {
+    f((a *= 2));
+  };
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('f')],
     },
-    `
-var box = { a: 2 };
-for (var prop in box) {
-  box[prop] = parseInt(box[prop]);
+    {
+      code: `
+function f() {
+  var a = 1;
+  return function () {
+    f(++a);
+  };
 }
-    `,
-    `
-f({
-  set foo(a) {
-    return;
-  },
-});
-    `,
+      `,
+      errors: [definedError('f')],
+    },
+    {
+      code: '/*global a */',
+      errors: [definedError('a', '')],
+    },
     {
       code: `
-a;
-var a;
+function foo(first, second) {
+  doStuff(function () {
+    console.log(second);
+  });
+}
       `,
+      errors: [definedError('foo')],
+    },
+    {
+      code: 'var a = 10;',
+      errors: [assignedError('a')],
       options: ['all'],
     },
     {
       code: `
 var a = 10;
-alert(a);
+a = 20;
       `,
+      errors: [assignedError('a')],
       options: ['all'],
     },
     {
       code: `
 var a = 10;
 (function () {
+  var a = 1;
   alert(a);
 })();
       `,
+      errors: [assignedError('a')],
       options: ['all'],
     },
     {
       code: `
-var a = 10;
-(function () {
-  setTimeout(function () {
-    alert(a);
-  }, 0);
-})();
+var a = 10,
+  b = 0,
+  c = null;
+alert(a + b);
       `,
+      errors: [assignedError('c')],
       options: ['all'],
     },
     {
       code: `
-var a = 10;
-d[a] = 0;
+var a = 10,
+  b = 0,
+  c = null;
+setTimeout(function () {
+  var b = 2;
+  alert(a + b + c);
+}, 0);
       `,
+      errors: [assignedError('b')],
       options: ['all'],
     },
     {
       code: `
-(function () {
-  var a = 10;
-  return a;
-})();
+var a = 10,
+  b = 0,
+  c = null;
+setTimeout(function () {
+  var b = 2;
+  var c = 2;
+  alert(a + b + c);
+}, 0);
       `,
+      errors: [assignedError('b'), assignedError('c')],
       options: ['all'],
     },
     {
-      code: '(function g() {})();',
+      code: `
+function f() {
+  var a = [];
+  return a.map(function () {});
+}
+      `,
+      errors: [definedError('f')],
       options: ['all'],
     },
     {
       code: `
-function f(a) {
-  alert(a);
+function f() {
+  var a = [];
+  return a.map(function g() {});
 }
-f();
       `,
+      errors: [definedError('f')],
       options: ['all'],
     },
     {
       code: `
-var c = 0;
-function f(a) {
-  var b = a;
-  return b;
+function foo() {
+  function foo(x) {
+    return x;
+  }
+  return function () {
+    return foo;
+  };
 }
-f(c);
       `,
-      options: ['all'],
+      errors: [
+        {
+          data: { action: 'defined', additional: '', varName: 'foo' },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
       code: `
-function a(x, y) {
-  return y;
+function f() {
+  var x;
+  function a() {
+    x = 42;
+  }
+  function b() {
+    alert(x);
+  }
 }
-a();
       `,
+      errors: [definedError('f'), definedError('a'), definedError('b')],
+      options: ['all'],
+    },
+    {
+      code: `
+function f(a) {}
+f();
+      `,
+      errors: [definedError('a')],
       options: ['all'],
     },
     {
       code: `
-var arr1 = [1, 2];
-var arr2 = [3, 4];
-for (var i in arr1) {
-  arr1[i] = 5;
-}
-for (var i in arr2) {
-  arr2[i] = 10;
+function a(x, y, z) {
+  return y;
 }
+a();
       `,
+      errors: [definedError('z')],
       options: ['all'],
     },
     {
-      code: 'var a = 10;',
-      options: ['local'],
+      code: 'var min = Math.min;',
+      errors: [assignedError('min')],
+      options: ['all'],
     },
     {
-      code: `
-var min = 'min';
-Math[min];
-      `,
+      code: 'var min = { min: 1 };',
+      errors: [assignedError('min')],
       options: ['all'],
     },
     {
       code: `
 Foo.bar = function (baz) {
-  return baz;
+  return 1;
 };
       `,
+      errors: [definedError('baz')],
       options: ['all'],
     },
-    'myFunc(function foo() {}.bind(this));',
-    'myFunc(function foo() {}.toString());',
-    `
-function foo(first, second) {
-  doStuff(function () {
-    console.log(second);
-  });
-}
-foo();
-    `,
-    `
-(function () {
-  var doSomething = function doSomething() {};
-  doSomething();
-})();
-    `,
-    '/*global a */ a;',
     {
-      code: `
-var a = 10;
-(function () {
-  alert(a);
-})();
-      `,
+      code: 'var min = { min: 1 };',
+      errors: [assignedError('min')],
       options: [{ vars: 'all' }],
     },
     {
       code: `
-function g(bar, baz) {
+function gg(baz, bar) {
   return baz;
 }
-g();
+gg();
       `,
+      errors: [definedError('bar')],
       options: [{ vars: 'all' }],
     },
     {
       code: `
-function g(bar, baz) {
+(function (foo, baz, bar) {
   return baz;
-}
-g();
-      `,
-      options: [{ vars: 'all', args: 'after-used' }],
-    },
-    {
-      code: `
-function g(bar, baz) {
-  return bar;
-}
-g();
+})();
       `,
-      options: [{ vars: 'all', args: 'none' }],
+      errors: [definedError('bar')],
+      options: [{ args: 'after-used', vars: 'all' }],
     },
     {
       code: `
-function g(bar, baz) {
-  return 2;
-}
-g();
+(function (foo, baz, bar) {
+  return baz;
+})();
       `,
-      options: [{ vars: 'all', args: 'none' }],
+      errors: [definedError('foo'), definedError('bar')],
+      options: [{ args: 'all', vars: 'all' }],
     },
     {
       code: `
-function g(bar, baz) {
-  return bar + baz;
-}
-g();
+(function z(foo) {
+  var bar = 33;
+})();
       `,
-      options: [{ vars: 'local', args: 'all' }],
+      errors: [definedError('foo'), assignedError('bar')],
+      options: [{ args: 'all', vars: 'all' }],
     },
     {
       code: `
-var g = function (bar, baz) {
-  return 2;
-};
-g();
-      `,
-      options: [{ vars: 'all', args: 'none' }],
-    },
-    `
-(function z() {
+(function z(foo) {
   z();
 })();
-    `,
-    {
-      code: ' ',
-      languageOptions: { globals: { a: true } },
+      `,
+      errors: [definedError('foo')],
+      options: [{}],
     },
     {
       code: `
-var who = 'Paul';
-module.exports = \`Hello \${who}!\`;
+function f() {
+  var a = 1;
+  return function () {
+    f((a = 2));
+  };
+}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'export var foo = 123;',
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
+      errors: [definedError('f'), assignedError('a')],
+      options: [{}],
     },
     {
-      code: 'export function foo() {}',
+      code: "import x from 'y';",
+      errors: [definedError('x')],
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
     },
     {
       code: `
-let toUpper = partial => partial.toUpperCase;
-export { toUpper };
+export function fn2({ x, y }) {
+  console.log(x);
+}
       `,
+      errors: [definedError('y')],
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
     },
     {
-      code: 'export class foo {}',
+      code: `
+export function fn2(x, y) {
+  console.log(x);
+}
+      `,
+      errors: [definedError('y')],
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
     },
+
+    // exported
     {
       code: `
-class Foo {}
-var x = new Foo();
-x.foo();
+/*exported max*/ var max = 1,
+  min = { min: 1 };
       `,
+      errors: [assignedError('min')],
+    },
+    {
+      code: '/*exported x*/ var { x, y } = z;',
+      errors: [assignedError('y')],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
+    // ignore pattern
     {
       code: `
-const foo = 'hello!';
-function bar(foobar = foo) {
-  foobar.replace(/!$/, ' world!');
-}
-bar();
+var _a;
+var b;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 5,
+          data: {
+            action: 'defined',
+            additional: '. Allowed unused vars must match /^_/u',
+            varName: 'b',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
     },
-    `
-function Foo() {}
-var x = new Foo();
-x.foo();
-    `,
-    `
-function foo() {
-  var foo = 1;
-  return foo;
-}
-foo();
-    `,
-    `
-function foo(foo) {
-  return foo;
-}
-foo(1);
-    `,
-    `
-function foo() {
-  function foo() {
-    return 1;
-  }
-  return foo();
-}
-foo();
-    `,
     {
       code: `
+var a;
 function foo() {
-  var foo = 1;
-  return foo;
+  var _b;
+  var c_;
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 7,
+          data: {
+            action: 'defined',
+            additional: '. Allowed unused vars must match /^_/u',
+            varName: 'c_',
+          },
+          line: 5,
+          messageId: 'unusedVar',
+        },
+      ],
+      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
     },
     {
       code: `
-function foo(foo) {
-  return foo;
-}
-foo(1);
+function foo(a, _b) {}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 14,
+          data: {
+            action: 'defined',
+            additional: '. Allowed unused args must match /^_/u',
+            varName: 'a',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+      options: [{ args: 'all', argsIgnorePattern: '^_' }],
     },
     {
       code: `
-function foo() {
-  function foo() {
-    return 1;
-  }
-  return foo();
+function foo(a, _b, c) {
+  return a;
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 21,
+          data: {
+            action: 'defined',
+            additional: '. Allowed unused args must match /^_/u',
+            varName: 'c',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
     },
     {
       code: `
-const x = 1;
-const [y = x] = [];
-foo(y);
+function foo(_a) {}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 14,
+          data: {
+            action: 'defined',
+            additional: '. Allowed unused args must match /[iI]gnored/u',
+            varName: '_a',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+      options: [{ args: 'all', argsIgnorePattern: '[iI]gnored' }],
     },
     {
-      code: `
-const x = 1;
-const { y = x } = {};
-foo(y);
-      `,
+      code: 'var [firstItemIgnored, secondItem] = items;',
+      errors: [
+        {
+          column: 24,
+          data: {
+            action: 'assigned a value',
+            additional: '. Allowed unused vars must match /[iI]gnored/u',
+            varName: 'secondItem',
+          },
+          line: 1,
+          messageId: 'unusedVar',
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
     },
+
+    // https://github.com/eslint/eslint/issues/15611
     {
       code: `
-const x = 1;
-const {
-  z: [y = x],
-} = {};
-foo(y);
+const array = ['a', 'b', 'c'];
+const [a, _b, c] = array;
+const newArray = [a, c];
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        // should report only `newArray`
+        { ...assignedError('newArray'), column: 7, line: 4 },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-const x = [];
-const { z: [y] = x } = {};
-foo(y);
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-const x = 1;
-let y;
-[y = x] = [];
-foo(y);
+const array = ['a', 'b', 'c', 'd', 'e'];
+const [a, _b, c] = array;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          ...assignedError(
+            'a',
+            '. Allowed unused elements of array destructuring must match /^_/u',
+          ),
+          column: 8,
+          line: 3,
+        },
+        {
+          ...assignedError(
+            'c',
+            '. Allowed unused elements of array destructuring must match /^_/u',
+          ),
+          column: 15,
+          line: 3,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-const x = 1;
-let y;
-({
-  z: [y = x],
-} = {});
-foo(y);
+const array = ['a', 'b', 'c'];
+const [a, _b, c] = array;
+const fooArray = ['foo'];
+const barArray = ['bar'];
+const ignoreArray = ['ignore'];
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          ...assignedError(
+            'a',
+            '. Allowed unused elements of array destructuring must match /^_/u',
+          ),
+          column: 8,
+          line: 3,
+        },
+        {
+          ...assignedError(
+            'c',
+            '. Allowed unused elements of array destructuring must match /^_/u',
+          ),
+          column: 15,
+          line: 3,
+        },
+        {
+          ...assignedError(
+            'fooArray',
+            '. Allowed unused vars must match /ignore/u',
+          ),
+          column: 7,
+          line: 4,
+        },
+        {
+          ...assignedError(
+            'barArray',
+            '. Allowed unused vars must match /ignore/u',
+          ),
+          column: 7,
+          line: 5,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [
+        { destructuredArrayIgnorePattern: '^_', varsIgnorePattern: 'ignore' },
+      ],
     },
     {
       code: `
-const x = [];
-let y;
-({ z: [y] = x } = {});
-foo(y);
+const array = [obj];
+const [{ _a, foo }] = array;
+console.log(foo);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          ...assignedError('_a'),
+          column: 10,
+          line: 3,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-const x = 1;
-function foo(y = x) {
-  bar(y);
+function foo([{ _a, bar }]) {
+  bar;
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          ...definedError('_a'),
+          column: 17,
+          line: 2,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-const x = 1;
-function foo({ y = x } = {}) {
-  bar(y);
-}
-foo();
+let _a, b;
+
+foo.forEach(item => {
+  [a, b] = item;
+});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          ...definedError('_a'),
+          column: 5,
+          line: 2,
+        },
+        {
+          ...assignedError('b'),
+          column: 9,
+          line: 2,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
+
+    // for-in loops (see #2342)
     {
       code: `
-const x = 1;
-function foo(
-  y = function (z = x) {
-    bar(z);
-  },
-) {
-  y();
-}
-foo();
+(function (obj) {
+  var name;
+  for (name in obj) {
+    i();
+    return;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
       code: `
-const x = 1;
-function foo(
-  y = function () {
-    bar(x);
-  },
-) {
-  y();
-}
-foo();
+(function (obj) {
+  var name;
+  for (name in obj) {
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
       code: `
-var x = 1;
-var [y = x] = [];
-foo(y);
+(function (obj) {
+  for (var name in obj) {
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 12,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
     },
+
+    // For-of loops
     {
       code: `
-var x = 1;
-var { y = x } = {};
-foo(y);
+(function (iter) {
+  var name;
+  for (name of iter) {
+    i();
+    return;
+  }
+})({});
       `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var x = 1;
-var {
-  z: [y = x],
-} = {};
-foo(y);
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var x = [];
-var { z: [y] = x } = {};
-foo(y);
+(function (iter) {
+  var name;
+  for (name of iter) {
+  }
+})({});
       `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var x = 1,
-  y;
-[y = x] = [];
-foo(y);
+(function (iter) {
+  for (var name of iter) {
+  }
+})({});
       `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'name',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
+    // https://github.com/eslint/eslint/issues/3617
     {
       code: `
-var x = 1,
-  y;
-({
-  z: [y = x],
-} = {});
-foo(y);
+/* global foobar, foo, bar */
+foobar;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 19,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 22,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 24,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'bar',
+          },
+          endColumn: 27,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
       code: `
-var x = [],
-  y;
-({ z: [y] = x } = {});
-foo(y);
+/* global foobar,
+   foo,
+   bar
+ */
+foobar;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 4,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 7,
+          endLine: 3,
+          line: 3,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 4,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'bar',
+          },
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
     },
+
+    // Rest property sibling without ignoreRestSiblings
     {
       code: `
-var x = 1;
-function foo(y = x) {
-  bar(y);
-}
-foo();
+const data = { type: 'coords', x: 1, y: 2 };
+const { type, ...coords } = data;
+console.log(coords);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 9,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'type',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
+
+    // Unused rest property with ignoreRestSiblings
     {
       code: `
-var x = 1;
-function foo({ y = x } = {}) {
-  bar(y);
-}
-foo();
+const data = { type: 'coords', x: 2, y: 2 };
+const { type, ...coords } = data;
+console.log(type);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 18,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'coords',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ ignoreRestSiblings: true }],
     },
     {
       code: `
-var x = 1;
-function foo(
-  y = function (z = x) {
-    bar(z);
-  },
-) {
-  y();
-}
-foo();
+let type, coords;
+({ type, ...coords } = data);
+console.log(type);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 13,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'coords',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ ignoreRestSiblings: true }],
     },
+
+    // Unused rest property without ignoreRestSiblings
     {
       code: `
-var x = 1;
-function foo(
-  y = function () {
-    bar(x);
-  },
-) {
-  y();
-}
-foo();
+const data = { type: 'coords', x: 3, y: 2 };
+const { type, ...coords } = data;
+console.log(type);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 18,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'coords',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
 
-    // exported variables should work
-    "/*exported toaster*/ var toaster = 'great';",
-    `
-/*exported toaster, poster*/ var toaster = 1;
-poster = 0;
-    `,
-    {
-      code: '/*exported x*/ var { x } = y;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
+    // Nested array destructuring with rest property
     {
-      code: '/*exported x, y*/ var { x, y } = z;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: `
+const data = { vars: ['x', 'y'], x: 1, y: 2 };
+const {
+  vars: [x],
+  ...coords
+} = data;
+console.log(coords);
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'x',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
 
-    // Can mark variables as used via context.markVariableAsUsed()
-    '/*eslint @rule-tester/use-every-a:1*/ var a;',
-    `
-/*eslint @rule-tester/use-every-a:1*/ !function (a) {
-  return 1;
-};
-    `,
-    `
-/*eslint @rule-tester/use-every-a:1*/ !function () {
-  var a;
-  return 1;
-};
-    `,
+    // Nested object destructuring with rest property
+    {
+      code: `
+const data = { defaults: { x: 0 }, x: 1, y: 2 };
+const {
+  defaults: { x },
+  ...coords
+} = data;
+console.log(coords);
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'x',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+    },
 
-    // ignore pattern
+    // https://github.com/eslint/eslint/issues/8119
     {
-      code: 'var _a;',
-      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
+      code: '({ a, ...rest }) => {};',
+      errors: [definedError('rest')],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ args: 'all', ignoreRestSiblings: true }],
     },
+
+    // https://github.com/eslint/eslint/issues/3714
     {
       code: `
-var a;
-function foo() {
-  var _b;
-}
-foo();
+/* global a$fooz,$foo */
+a$fooz;
       `,
-      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
+      errors: [
+        {
+          column: 18,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: '$foo',
+          },
+          endColumn: 22,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
       code: `
-function foo(_a) {}
-foo();
+/* globals a$fooz, $ */
+a$fooz;
       `,
-      options: [{ args: 'all', argsIgnorePattern: '^_' }],
+      errors: [
+        {
+          column: 20,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: '$',
+          },
+          endColumn: 21,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
-      code: `
-function foo(a, _b) {
-  return a;
-}
-foo();
-      `,
-      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
+      code: '/*globals $foo*/',
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: '$foo',
+          },
+          endColumn: 15,
+          endLine: 1,
+          line: 1,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
-      code: `
-var [firstItemIgnored, secondItem] = items;
-console.log(secondItem);
-      `,
-      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: '/* global global*/',
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'global',
+          },
+          endColumn: 17,
+          endLine: 1,
+          line: 1,
+          messageId: 'unusedVar',
+        },
+      ],
     },
     {
-      code: `
-const [a, _b, c] = items;
-console.log(a + c);
-      `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: '/*global foo:true*/',
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 13,
+          endLine: 1,
+          line: 1,
+          messageId: 'unusedVar',
+        },
+      ],
     },
+
+    // non ascii.
     {
       code: `
-const [[a, _b, c]] = items;
-console.log(a + c);
+/*global 変数, 数*/
+
+変数;
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 14,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: '数',
+          },
+          endColumn: 15,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
     },
+
+    // surrogate pair.
     {
       code: `
-const {
-  x: [_a, foo],
-} = bar;
-console.log(foo);
+/*global 𠮷𩸽, 𠮷*/
+𠮷𩸽;
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
+      errors: [
+        {
+          column: 16,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: '𠮷',
+          },
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
+    // https://github.com/eslint/eslint/issues/4047
     {
-      code: `
-function baz([_b, foo]) {
-  foo;
-}
-baz();
-      `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'export default function (a) {}',
+      errors: [definedError('a')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: `
-function baz({ x: [_b, foo] }) {
-  foo;
+export default function (a, b) {
+  console.log(a);
 }
-baz();
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('b')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
-      code: `
-function baz([
-  {
-    x: [_b, foo],
-  },
-]) {
-  foo;
-}
-baz();
-      `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'export default (function (a) {});',
+      errors: [definedError('a')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: `
-let _a, b;
-foo.forEach(item => {
-  [_a, b] = item;
-  doSomething(b);
+export default (function (a, b) {
+  console.log(a);
 });
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('b')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
+    },
+    {
+      code: 'export default a => {};',
+      errors: [definedError('a')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: `
-// doesn't report _x
-let _x, y;
-_x = 1;
-[_x, y] = foo;
-y;
-
-// doesn't report _a
-let _a, b;
-[_a, b] = foo;
-_a = 1;
-b;
+export default (a, b) => {
+  console.log(a);
+};
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      errors: [definedError('b')],
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
+
+    // caughtErrors
     {
       code: `
-// doesn't report _x
-let _x, y;
-_x = 1;
-[_x, y] = foo;
-y;
-
-// doesn't report _a
-let _a, b;
-_a = 1;
-({ _a, ...b } = foo);
-b;
+try {
+} catch (err) {}
       `,
-      options: [
-        { destructuredArrayIgnorePattern: '^_', ignoreRestSiblings: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      errors: [definedError('err')],
     },
-
-    // for-in loops (see #2342)
-    `
-(function (obj) {
-  var name;
-  for (name in obj) return;
-})({});
-    `,
-    `
-(function (obj) {
-  var name;
-  for (name in obj) {
-    return;
-  }
-})({});
-    `,
-    `
-(function (obj) {
-  for (var name in obj) {
-    return true;
-  }
-})({});
-    `,
-    `
-(function (obj) {
-  for (var name in obj) return true;
-})({});
-    `,
-
     {
       code: `
-(function (obj) {
-  let name;
-  for (name in obj) return;
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('err')],
+      options: [{ caughtErrors: 'all' }],
     },
     {
       code: `
-(function (obj) {
-  let name;
-  for (name in obj) {
-    return;
-  }
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        definedError(
+          'err',
+          '. Allowed unused caught errors must match /^ignore/u',
+        ),
+      ],
+      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
     },
     {
       code: `
-(function (obj) {
-  for (let name in obj) {
-    return true;
-  }
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('err')],
+      options: [{ caughtErrors: 'all', varsIgnorePattern: '^err' }],
     },
     {
       code: `
-(function (obj) {
-  for (let name in obj) return true;
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('err')],
+      options: [{ caughtErrors: 'all', varsIgnorePattern: '^.' }],
     },
 
+    // multiple try catch with one success
     {
       code: `
-(function (obj) {
-  for (const name in obj) {
-    return true;
-  }
-})({});
+try {
+} catch (ignoreErr) {}
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        definedError(
+          'err',
+          '. Allowed unused caught errors must match /^ignore/u',
+        ),
+      ],
+      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
     },
+
+    // multiple try catch both fail
     {
       code: `
-(function (obj) {
-  for (const name in obj) return true;
-})({});
+try {
+} catch (error) {}
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        definedError(
+          'error',
+          '. Allowed unused caught errors must match /^ignore/u',
+        ),
+        definedError(
+          'err',
+          '. Allowed unused caught errors must match /^ignore/u',
+        ),
+      ],
+      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
     },
 
-    // For-of loops
+    // caughtErrors with other configs
     {
       code: `
-(function (iter) {
-  let name;
-  for (name of iter) return;
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('err')],
+      options: [{ args: 'all', caughtErrors: 'all', vars: 'all' }],
     },
+
+    // no conflict in ignore patterns
     {
       code: `
-(function (iter) {
-  let name;
-  for (name of iter) {
-    return;
-  }
-})({});
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('err')],
+      options: [
+        {
+          args: 'all',
+          argsIgnorePattern: '^er',
+          caughtErrors: 'all',
+          vars: 'all',
+        },
+      ],
     },
+
+    // Ignore reads for modifications to itself: https://github.com/eslint/eslint/issues/6348
     {
       code: `
-(function (iter) {
-  for (let name of iter) {
-    return true;
-  }
-})({});
+var a = 0;
+a = a + 1;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
     {
       code: `
-(function (iter) {
-  for (let name of iter) return true;
-})({});
+var a = 0;
+a = a + a;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
-
     {
       code: `
-(function (iter) {
-  for (const name of iter) {
-    return true;
-  }
-})({});
+var a = 0;
+a += a + 1;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
     {
       code: `
-(function (iter) {
-  for (const name of iter) return true;
-})({});
+var a = 0;
+a++;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
-
-    // Sequence Expressions (See https://github.com/eslint/eslint/issues/14325)
     {
       code: `
-let x = 0;
-foo = (0, x++);
+function foo(a) {
+  a = a + 1;
+}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
     {
       code: `
-let x = 0;
-foo = (0, (x += 1));
+function foo(a) {
+  a += a + 1;
+}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
     {
       code: `
-let x = 0;
-foo = (0, (x = x + 1));
+function foo(a) {
+  a++;
+}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('a')],
     },
-
-    // caughtErrors
     {
       code: `
-try {
-} catch (err) {}
+var a = 3;
+a = a * 5 + 6;
       `,
-      options: [{ caughtErrors: 'none' }],
+      errors: [assignedError('a')],
     },
     {
       code: `
-try {
-} catch (err) {
-  console.error(err);
-}
+var a = 2,
+  b = 4;
+a = a * 2 + b;
       `,
-      options: [{ caughtErrors: 'all' }],
+      errors: [assignedError('a')],
     },
+
+    // https://github.com/eslint/eslint/issues/6576 (For coverage)
     {
       code: `
-try {
-} catch (ignoreErr) {}
-      `,
-      options: [{ caughtErrorsIgnorePattern: '^ignore' }],
-    },
-    {
-      code: `
-try {
-} catch (ignoreErr) {}
-      `,
-      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
-    },
-
-    // caughtErrors with other combinations
-    {
-      code: `
-try {
-} catch (err) {}
+function foo(cb) {
+  cb = function (a) {
+    cb(1 + a);
+  };
+  bar(not_cb);
+}
+foo();
       `,
-      options: [{ caughtErrors: 'none', vars: 'all', args: 'all' }],
+      errors: [assignedError('cb')],
     },
-
-    // Using object rest for variable omission
     {
       code: `
-const data = { type: 'coords', x: 1, y: 2 };
-const { type, ...coords } = data;
-console.log(coords);
-      `,
-      options: [{ ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-    },
-
-    // https://github.com/eslint/eslint/issues/6348
-    `
-var a = 0,
-  b;
-b = a = a + 1;
-foo(b);
-    `,
-    `
-var a = 0,
-  b;
-b = a += a + 1;
-foo(b);
-    `,
-    `
-var a = 0,
-  b;
-b = a++;
-foo(b);
-    `,
-    `
-function foo(a) {
-  var b = (a = a + 1);
-  bar(b);
-}
-foo();
-    `,
-    `
-function foo(a) {
-  var b = (a += a + 1);
-  bar(b);
-}
-foo();
-    `,
-    `
-function foo(a) {
-  var b = a++;
-  bar(b);
-}
-foo();
-    `,
-
-    // https://github.com/eslint/eslint/issues/6576
-    `
-var unregisterFooWatcher;
-// ...
-unregisterFooWatcher = $scope.$watch('foo', function () {
-  // ...some code..
-  unregisterFooWatcher();
-});
-    `,
-    `
-var ref;
-ref = setInterval(function () {
-  clearInterval(ref);
-}, 10);
-    `,
-    `
-var _timer;
-function f() {
-  _timer = setTimeout(function () {}, _timer ? 100 : 0);
-}
-f();
-    `,
-    `
 function foo(cb) {
-  cb = (function () {
-    function something(a) {
-      cb(1 + a);
-    }
-    register(something);
+  cb = (function (a) {
+    return cb(1 + a);
   })();
 }
 foo();
-    `,
+      `,
+      errors: [assignedError('cb')],
+    },
     {
       code: `
-function* foo(cb) {
-  cb = yield function (a) {
-    cb(1 + a);
-  };
+function foo(cb) {
+  cb =
+    (function (a) {
+      cb(1 + a);
+    },
+    cb);
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('cb')],
     },
     {
       code: `
 function foo(cb) {
-  cb = tag\`hello\${function (a) {
-    cb(1 + a);
-  }}\`;
+  cb =
+    (0,
+    function (a) {
+      cb(1 + a);
+    });
 }
 foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [assignedError('cb')],
     },
-    `
-function foo(cb) {
-  var b;
-  cb = b = function (a) {
-    cb(1 + a);
-  };
-  b();
-}
-foo();
-    `,
 
     // https://github.com/eslint/eslint/issues/6646
-    `
-function someFunction() {
-  var a = 0,
-    i;
-  for (i = 0; i < 2; i++) {
-    a = myFunction(a);
+    {
+      code: `
+while (a) {
+  function foo(b) {
+    b = b + 1;
   }
+  foo();
 }
-someFunction();
-    `,
+      `,
+      errors: [assignedError('b')],
+    },
 
     // https://github.com/eslint/eslint/issues/7124
     {
-      code: `
-(function (a, b, { c, d }) {
-  d;
-});
-      `,
+      code: '(function (a, b, c) {});',
+      errors: [
+        definedError('a', '. Allowed unused args must match /c/u'),
+        definedError('b', '. Allowed unused args must match /c/u'),
+      ],
+      options: [{ argsIgnorePattern: 'c' }],
+    },
+    {
+      code: '(function (a, b, { c, d }) {});',
+      errors: [
+        definedError('a', '. Allowed unused args must match /[cd]/u'),
+        definedError('b', '. Allowed unused args must match /[cd]/u'),
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ argsIgnorePattern: '[cd]' }],
+    },
+    {
+      code: '(function (a, b, { c, d }) {});',
+      errors: [
+        definedError('a', '. Allowed unused args must match /c/u'),
+        definedError('b', '. Allowed unused args must match /c/u'),
+        definedError('d', '. Allowed unused args must match /c/u'),
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: [{ argsIgnorePattern: 'c' }],
+    },
+    {
+      code: '(function (a, b, { c, d }) {});',
+      errors: [
+        definedError('a', '. Allowed unused args must match /d/u'),
+        definedError('b', '. Allowed unused args must match /d/u'),
+        definedError('c', '. Allowed unused args must match /d/u'),
+      ],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ argsIgnorePattern: 'd' }],
     },
     {
       code: `
-(function (a, b, { c, d }) {
-  c;
-});
+/*global
+foo*/
       `,
-      options: [{ argsIgnorePattern: 'd' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [
+        {
+          column: 1,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
     },
 
-    // https://github.com/eslint/eslint/issues/7250
+    // https://github.com/eslint/eslint/issues/8442
     {
       code: `
-(function (a, b, c) {
-  c;
-});
+(function ({ a }, b) {
+  return b;
+})();
       `,
-      options: [{ argsIgnorePattern: 'c' }],
+      errors: [definedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-(function (a, b, { c, d }) {
-  c;
-});
+(function ({ a }, { b, c }) {
+  return b;
+})();
       `,
-      options: [{ argsIgnorePattern: '[cd]' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
 
-    // https://github.com/eslint/eslint/issues/7351
+    // https://github.com/eslint/eslint/issues/14325
     {
       code: `
-(class {
-  set foo(UNUSED) {}
-});
+let x = 0;
+x++, (x = 0);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [{ ...assignedError('x'), column: 7, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-class Foo {
-  set bar(UNUSED) {}
-}
-console.log(Foo);
+let x = 0;
+x++, (x = 0);
+x = 3;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-
-    // https://github.com/eslint/eslint/issues/8119
-    {
-      code: '({ a, ...rest }) => rest;',
-      options: [{ args: 'all', ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      errors: [{ ...assignedError('x'), column: 1, line: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
-
-    // https://github.com/eslint/eslint/issues/14163
     {
       code: `
-let foo, rest;
-({ foo, ...rest } = something);
-console.log(rest);
+let x = 0;
+x++, 0;
       `,
-      options: [{ ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      errors: [{ ...assignedError('x'), column: 1, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
-
-    // https://github.com/eslint/eslint/issues/10952
-    `
-/*eslint @rule-tester/use-every-a:1*/ !function (b, a) {
-  return 1;
-};
-    `,
-
-    // https://github.com/eslint/eslint/issues/10982
-    `
-var a = function () {
-  a();
-};
-a();
-    `,
-    `
-var a = function () {
-  return function () {
-    a();
-  };
-};
-a();
-    `,
     {
       code: `
-const a = () => {
-  a();
-};
-a();
+let x = 0;
+0, x++;
       `,
+      errors: [{ ...assignedError('x'), column: 4, line: 3 }],
       languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-const a = () => () => {
-  a();
-};
-a();
+let x = 0;
+0, (1, x++);
       `,
+      errors: [{ ...assignedError('x'), column: 8, line: 3 }],
       languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
-
-    // export * as ns from "source"
-    {
-      code: "export * as ns from 'source';",
-      languageOptions: {
-        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
-      },
-    },
-
-    // import.meta
-    {
-      code: 'import.meta;',
-      languageOptions: {
-        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
-      },
-    },
-
-    // https://github.com/eslint/eslint/issues/17299
     {
       code: `
-var a;
-a ||= 1;
+let x = 0;
+foo = (x++, 0);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
+      errors: [{ ...assignedError('x'), column: 8, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-var a;
-a &&= 1;
+let x = 0;
+foo = ((0, x++), 0);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
+      errors: [{ ...assignedError('x'), column: 12, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-var a;
-a ??= 1;
+let x = 0;
+(x += 1), 0;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
+      errors: [{ ...assignedError('x'), column: 2, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
-
-    // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
     {
       code: `
-class Foo {
-  static {}
-}
+let x = 0;
+0, (x += 1);
       `,
-      options: [{ ignoreClassWithStaticInitBlock: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      errors: [{ ...assignedError('x'), column: 5, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-class Foo {
-  static {}
-}
+let x = 0;
+0, (1, (x += 1));
       `,
-      options: [
-        { ignoreClassWithStaticInitBlock: true, varsIgnorePattern: '^_' },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      errors: [{ ...assignedError('x'), column: 9, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-class Foo {
-  static {}
-}
+let x = 0;
+foo = ((x += 1), 0);
       `,
-      options: [
-        { ignoreClassWithStaticInitBlock: false, varsIgnorePattern: '^Foo' },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      errors: [{ ...assignedError('x'), column: 9, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
-
-    // https://github.com/eslint/eslint/issues/17568
     {
       code: `
-const a = 5;
-const _c = a + 5;
+let x = 0;
+foo = ((0, (x += 1)), 0);
       `,
-      options: [
-        { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [{ ...assignedError('x'), column: 13, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
+
+    // https://github.com/eslint/eslint/issues/14866
     {
       code: `
-(function foo(a, _b) {
-  return a + 5;
-})(5);
+let z = 0;
+(z = z + 1), (z = 2);
       `,
-      options: [
-        { args: 'all', argsIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
+      errors: [{ ...assignedError('z'), column: 15, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-const [a, _b, c] = items;
-console.log(a + c);
+let z = 0;
+(z = z + 1), (z = 2);
+z = 3;
       `,
-      options: [
-        { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      errors: [{ ...assignedError('z'), column: 1, line: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
-  ],
-  invalid: [
     {
       code: `
-function foox() {
-  return foox();
-}
+let z = 0;
+(z = z + 1), (z = 2);
+z = z + 3;
       `,
-      errors: [definedError('foox')],
+      errors: [{ ...assignedError('z'), column: 1, line: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-(function () {
-  function foox() {
-    if (true) {
-      return foox();
-    }
-  }
-})();
+let x = 0;
+0, (x = x + 1);
       `,
-      errors: [definedError('foox')],
-    },
-    {
-      code: 'var a = 10;',
-      errors: [assignedError('a')],
+      errors: [{ ...assignedError('x'), column: 5, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-function f() {
-  var a = 1;
-  return function () {
-    f((a *= 2));
-  };
-}
+let x = 0;
+(x = x + 1), 0;
       `,
-      errors: [definedError('f')],
+      errors: [{ ...assignedError('x'), column: 2, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-function f() {
-  var a = 1;
-  return function () {
-    f(++a);
-  };
-}
+let x = 0;
+foo = ((0, (x = x + 1)), 0);
       `,
-      errors: [definedError('f')],
-    },
-    {
-      code: '/*global a */',
-      errors: [definedError('a', '')],
+      errors: [{ ...assignedError('x'), column: 13, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-function foo(first, second) {
-  doStuff(function () {
-    console.log(second);
-  });
-}
+let x = 0;
+foo = ((x = x + 1), 0);
       `,
-      errors: [definedError('foo')],
-    },
-    {
-      code: 'var a = 10;',
-      options: ['all'],
-      errors: [assignedError('a')],
+      errors: [{ ...assignedError('x'), column: 9, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-var a = 10;
-a = 20;
+let x = 0;
+0, (1, (x = x + 1));
       `,
-      options: ['all'],
-      errors: [assignedError('a')],
+      errors: [{ ...assignedError('x'), column: 9, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-var a = 10;
-(function () {
-  var a = 1;
-  alert(a);
+(function ({ a, b }, { c }) {
+  return b;
 })();
       `,
-      options: ['all'],
-      errors: [assignedError('a')],
+      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-var a = 10,
-  b = 0,
-  c = null;
-alert(a + b);
+(function ([a], b) {
+  return b;
+})();
       `,
-      options: ['all'],
-      errors: [assignedError('c')],
+      errors: [definedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-var a = 10,
-  b = 0,
-  c = null;
-setTimeout(function () {
-  var b = 2;
-  alert(a + b + c);
-}, 0);
+(function ([a], [b, c]) {
+  return b;
+})();
       `,
-      options: ['all'],
-      errors: [assignedError('b')],
+      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-var a = 10,
-  b = 0,
-  c = null;
-setTimeout(function () {
-  var b = 2;
-  var c = 2;
-  alert(a + b + c);
-}, 0);
+(function ([a, b], [c]) {
+  return b;
+})();
       `,
-      options: ['all'],
-      errors: [assignedError('b'), assignedError('c')],
+      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
+    },
+
+    // https://github.com/eslint/eslint/issues/9774
+    {
+      code: '(function (_a) {})();',
+      errors: [definedError('_a')],
+      options: [{ args: 'all', varsIgnorePattern: '^_' }],
     },
     {
-      code: `
-function f() {
-  var a = [];
-  return a.map(function () {});
-}
-      `,
-      options: ['all'],
-      errors: [definedError('f')],
+      code: '(function (_a) {})();',
+      errors: [definedError('_a')],
+      options: [{ args: 'all', caughtErrorsIgnorePattern: '^_' }],
     },
+
+    // https://github.com/eslint/eslint/issues/10982
     {
       code: `
-function f() {
-  var a = [];
-  return a.map(function g() {});
-}
+var a = function () {
+  a();
+};
       `,
-      options: ['all'],
-      errors: [definedError('f')],
+      errors: [assignedError('a')],
     },
     {
       code: `
-function foo() {
-  function foo(x) {
-    return x;
-  }
+var a = function () {
   return function () {
-    return foo;
+    a();
   };
-}
+};
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: { varName: 'foo', action: 'defined', additional: '' },
-          line: 2,
-        },
-      ],
+      errors: [{ ...assignedError('a'), column: 5, line: 2 }],
     },
     {
       code: `
-function f() {
-  var x;
-  function a() {
-    x = 42;
-  }
-  function b() {
-    alert(x);
-  }
-}
+const a = () => () => {
+  a();
+};
       `,
-      options: ['all'],
-      errors: [definedError('f'), definedError('a'), definedError('b')],
+      errors: [{ ...assignedError('a'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-function f(a) {}
-f();
+let myArray = [1, 2, 3, 4].filter(x => x == 0);
+myArray = myArray.filter(x => x == 1);
       `,
-      options: ['all'],
-      errors: [definedError('a')],
+      errors: [{ ...assignedError('myArray'), column: 1, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-function a(x, y, z) {
-  return y;
-}
-a();
+const a = 1;
+a += 1;
       `,
-      options: ['all'],
-      errors: [definedError('z')],
-    },
-    {
-      code: 'var min = Math.min;',
-      options: ['all'],
-      errors: [assignedError('min')],
+      errors: [{ ...assignedError('a'), column: 1, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
-      code: 'var min = { min: 1 };',
-      options: ['all'],
-      errors: [assignedError('min')],
+      code: `
+const a = () => {
+  a();
+};
+      `,
+      errors: [{ ...assignedError('a'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
+
+    // https://github.com/eslint/eslint/issues/14324
     {
       code: `
-Foo.bar = function (baz) {
-  return 1;
-};
+let x = [];
+x = x.concat(x);
       `,
-      options: ['all'],
-      errors: [definedError('baz')],
+      errors: [{ ...assignedError('x'), column: 1, line: 3 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
-      code: 'var min = { min: 1 };',
-      options: [{ vars: 'all' }],
-      errors: [assignedError('min')],
+      code: `
+let a = 'a';
+a = 10;
+function foo() {
+  a = 11;
+  a = () => {
+    a = 13;
+  };
+}
+      `,
+      errors: [
+        {
+          ...assignedError('a'),
+          column: 1,
+          line: 3,
+        },
+        {
+          ...definedError('foo'),
+          column: 10,
+          line: 4,
+        },
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-function gg(baz, bar) {
-  return baz;
+let foo;
+init();
+foo = foo + 2;
+function init() {
+  foo = 1;
 }
-gg();
       `,
-      options: [{ vars: 'all' }],
-      errors: [definedError('bar')],
+      errors: [{ ...assignedError('foo'), column: 1, line: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-(function (foo, baz, bar) {
-  return baz;
-})();
+function foo(n) {
+  if (n < 2) return 1;
+  return n * foo(n - 1);
+}
       `,
-      options: [{ vars: 'all', args: 'after-used' }],
-      errors: [definedError('bar')],
+      errors: [{ ...definedError('foo'), column: 10, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
-(function (foo, baz, bar) {
-  return baz;
-})();
+let c = 'c';
+c = 10;
+function foo1() {
+  c = 11;
+  c = () => {
+    c = 13;
+  };
+}
+
+c = foo1;
       `,
-      options: [{ vars: 'all', args: 'all' }],
-      errors: [definedError('foo'), definedError('bar')],
+      errors: [{ ...assignedError('c'), column: 1, line: 11 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
+
+    // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
     {
       code: `
-(function z(foo) {
-  var bar = 33;
-})();
+class Foo {
+  static {}
+}
       `,
-      options: [{ vars: 'all', args: 'all' }],
-      errors: [definedError('foo'), assignedError('bar')],
+      errors: [{ ...definedError('Foo'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: false }],
     },
     {
       code: `
-(function z(foo) {
-  z();
-})();
+class Foo {
+  static {}
+}
       `,
-      options: [{}],
-      errors: [definedError('foo')],
+      errors: [{ ...definedError('Foo'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: `
-function f() {
-  var a = 1;
-  return function () {
-    f((a = 2));
-  };
+class Foo {
+  static {
+    var bar;
+  }
 }
       `,
-      options: [{}],
-      errors: [definedError('f'), assignedError('a')],
+      errors: [{ ...definedError('bar'), column: 9, line: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: true }],
     },
     {
-      code: "import x from 'y';",
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [definedError('x')],
+      code: 'class Foo {}',
+      errors: [{ ...definedError('Foo'), column: 7, line: 1 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: true }],
     },
     {
       code: `
-export function fn2({ x, y }) {
-  console.log(x);
+class Foo {
+  static bar;
 }
       `,
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [definedError('y')],
+      errors: [{ ...definedError('Foo'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: true }],
     },
     {
       code: `
-export function fn2(x, y) {
-  console.log(x);
+class Foo {
+  static bar() {}
 }
       `,
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [definedError('y')],
+      errors: [{ ...definedError('Foo'), column: 7, line: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: true }],
     },
 
-    // exported
+    // https://github.com/eslint/eslint/issues/17568
     {
       code: `
-/*exported max*/ var max = 1,
-  min = { min: 1 };
+const _a = 5;
+const _b = _a + 5;
       `,
-      errors: [assignedError('min')],
-    },
-    {
-      code: '/*exported x*/ var { x, y } = z;',
+      errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [assignedError('y')],
+      options: [
+        { args: 'all', reportUsedIgnorePattern: true, varsIgnorePattern: '^_' },
+      ],
     },
-
-    // ignore pattern
     {
       code: `
-var _a;
-var b;
-      `,
-      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
-      errors: [
-        {
-          line: 3,
-          column: 5,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'b',
-            action: 'defined',
-            additional: '. Allowed unused vars must match /^_/u',
-          },
-        },
+const _a = 42;
+foo(() => _a);
+      `,
+      errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [
+        { args: 'all', reportUsedIgnorePattern: true, varsIgnorePattern: '^_' },
       ],
     },
     {
       code: `
-var a;
-function foo() {
-  var _b;
-  var c_;
-}
-foo();
+(function foo(_a) {
+  return _a + 5;
+})(5);
       `,
-      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
-      errors: [
-        {
-          line: 5,
-          column: 7,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'c_',
-            action: 'defined',
-            additional: '. Allowed unused vars must match /^_/u',
-          },
-        },
+      errors: [usedIgnoredError('_a', '. Used args must not match /^_/u')],
+      options: [
+        { args: 'all', argsIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
     },
     {
       code: `
-function foo(a, _b) {}
-foo();
+const [a, _b] = items;
+console.log(a + _b);
       `,
-      options: [{ args: 'all', argsIgnorePattern: '^_' }],
       errors: [
-        {
-          line: 2,
-          column: 14,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'a',
-            action: 'defined',
-            additional: '. Allowed unused args must match /^_/u',
-          },
-        },
+        usedIgnoredError(
+          '_b',
+          '. Used elements of array destructuring must not match /^_/u',
+        ),
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [
+        { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
     },
     {
       code: `
-function foo(a, _b, c) {
-  return a;
-}
-foo();
+let _x;
+[_x] = arr;
+foo(_x);
       `,
-      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
       errors: [
+        usedIgnoredError(
+          '_x',
+          '. Used elements of array destructuring must not match /^_/u',
+        ),
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [
         {
-          line: 2,
-          column: 21,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'c',
-            action: 'defined',
-            additional: '. Allowed unused args must match /^_/u',
-          },
+          destructuredArrayIgnorePattern: '^_',
+          reportUsedIgnorePattern: true,
+          varsIgnorePattern: '[iI]gnored',
         },
       ],
     },
     {
       code: `
-function foo(_a) {}
-foo();
+const [ignored] = arr;
+foo(ignored);
       `,
-      options: [{ args: 'all', argsIgnorePattern: '[iI]gnored' }],
       errors: [
+        usedIgnoredError('ignored', '. Used vars must not match /[iI]gnored/u'),
+      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [
         {
-          line: 2,
-          column: 14,
-          messageId: 'unusedVar',
-          data: {
-            varName: '_a',
-            action: 'defined',
-            additional: '. Allowed unused args must match /[iI]gnored/u',
-          },
+          destructuredArrayIgnorePattern: '^_',
+          reportUsedIgnorePattern: true,
+          varsIgnorePattern: '[iI]gnored',
         },
       ],
     },
     {
-      code: 'var [firstItemIgnored, secondItem] = items;',
-      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: `
+try {
+} catch (_err) {
+  console.error(_err);
+}
+      `,
       errors: [
+        usedIgnoredError('_err', '. Used caught errors must not match /^_/u'),
+      ],
+      options: [
         {
-          line: 1,
-          column: 24,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'secondItem',
-            action: 'assigned a value',
-            additional: '. Allowed unused vars must match /[iI]gnored/u',
-          },
+          caughtErrors: 'all',
+          caughtErrorsIgnorePattern: '^_',
+          reportUsedIgnorePattern: true,
         },
       ],
     },
-
-    // https://github.com/eslint/eslint/issues/15611
     {
       code: `
-const array = ['a', 'b', 'c'];
-const [a, _b, c] = array;
-const newArray = [a, c];
+try {
+} catch (_) {
+  _ = 'foo';
+}
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
-        // should report only `newArray`
-        { ...assignedError('newArray'), line: 4, column: 7 },
+        assignedError('_', '. Allowed unused caught errors must match /foo/u'),
       ],
+      options: [{ caughtErrorsIgnorePattern: 'foo' }],
     },
     {
       code: `
-const array = ['a', 'b', 'c', 'd', 'e'];
-const [a, _b, c] = array;
+try {
+} catch (_) {
+  _ = 'foo';
+}
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
+        assignedError(
+          '_',
+          '. Allowed unused caught errors must match /ignored/u',
+        ),
+      ],
+      options: [
         {
-          ...assignedError(
-            'a',
-            '. Allowed unused elements of array destructuring must match /^_/u',
-          ),
-          line: 3,
-          column: 8,
-        },
-        {
-          ...assignedError(
-            'c',
-            '. Allowed unused elements of array destructuring must match /^_/u',
-          ),
-          line: 3,
-          column: 15,
+          caughtErrorsIgnorePattern: 'ignored',
+          varsIgnorePattern: '_',
         },
       ],
     },
     {
       code: `
-const array = ['a', 'b', 'c'];
-const [a, _b, c] = array;
-const fooArray = ['foo'];
-const barArray = ['bar'];
-const ignoreArray = ['ignore'];
+try {
+} catch ({ message, errors: [firstError] }) {}
       `,
-      options: [
-        { destructuredArrayIgnorePattern: '^_', varsIgnorePattern: 'ignore' },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
-          ...assignedError(
-            'a',
-            '. Allowed unused elements of array destructuring must match /^_/u',
-          ),
-          line: 3,
-          column: 8,
-        },
-        {
-          ...assignedError(
-            'c',
-            '. Allowed unused elements of array destructuring must match /^_/u',
-          ),
-          line: 3,
-          column: 15,
-        },
-        {
-          ...assignedError(
-            'fooArray',
-            '. Allowed unused vars must match /ignore/u',
+          ...definedError(
+            'message',
+            '. Allowed unused caught errors must match /foo/u',
           ),
-          line: 4,
-          column: 7,
+          column: 12,
+          endColumn: 19,
         },
         {
-          ...assignedError(
-            'barArray',
-            '. Allowed unused vars must match /ignore/u',
+          ...definedError(
+            'firstError',
+            '. Allowed unused caught errors must match /foo/u',
           ),
-          line: 5,
-          column: 7,
+          column: 30,
+          endColumn: 40,
         },
       ],
+      options: [{ caughtErrorsIgnorePattern: 'foo' }],
     },
     {
       code: `
-const array = [obj];
-const [{ _a, foo }] = array;
-console.log(foo);
+try {
+} catch ({ stack: $ }) {
+  $ = 'Something broke: ' + $;
+}
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
-          ...assignedError('_a'),
-          line: 3,
-          column: 10,
+          ...assignedError(
+            '$',
+            '. Allowed unused caught errors must match /\\w/u',
+          ),
+          column: 3,
+          endColumn: 4,
         },
       ],
+      options: [{ caughtErrorsIgnorePattern: '\\w' }],
     },
     {
       code: `
-function foo([{ _a, bar }]) {
-  bar;
-}
-foo();
+_ => {
+  _ = _ + 1;
+};
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
-        {
-          ...definedError('_a'),
-          line: 2,
-          column: 17,
+        assignedError('_', '. Allowed unused args must match /ignored/u'),
+      ],
+      options: [
+        {
+          argsIgnorePattern: 'ignored',
+          varsIgnorePattern: '_',
         },
       ],
     },
+  ],
+  valid: [
+    `
+var foo = 5;
+
+label: while (true) {
+  console.log(foo);
+  break label;
+}
+    `,
+    `
+var foo = 5;
+
+while (true) {
+  console.log(foo);
+  break;
+}
+    `,
     {
       code: `
-let _a, b;
-
-foo.forEach(item => {
-  [a, b] = item;
+for (let prop in box) {
+  box[prop] = parseInt(box[prop]);
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    `
+var box = { a: 2 };
+for (var prop in box) {
+  box[prop] = parseInt(box[prop]);
+}
+    `,
+    `
+f({
+  set foo(a) {
+    return;
+  },
 });
+    `,
+    {
+      code: `
+a;
+var a;
       `,
-      options: [{ destructuredArrayIgnorePattern: '^_' }],
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [
-        {
-          ...definedError('_a'),
-          line: 2,
-          column: 5,
-        },
-        {
-          ...assignedError('b'),
-          line: 2,
-          column: 9,
-        },
-      ],
+      options: ['all'],
     },
-
-    // for-in loops (see #2342)
     {
       code: `
-(function (obj) {
-  var name;
-  for (name in obj) {
-    i();
-    return;
-  }
-})({});
+var a = 10;
+alert(a);
       `,
-      errors: [
-        {
-          line: 4,
-          column: 8,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
     {
       code: `
-(function (obj) {
-  var name;
-  for (name in obj) {
-  }
-})({});
+var a = 10;
+(function () {
+  alert(a);
+})();
       `,
-      errors: [
-        {
-          line: 4,
-          column: 8,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
     {
       code: `
-(function (obj) {
-  for (var name in obj) {
-  }
-})({});
+var a = 10;
+(function () {
+  setTimeout(function () {
+    alert(a);
+  }, 0);
+})();
       `,
-      errors: [
-        {
-          line: 3,
-          column: 12,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // For-of loops
     {
       code: `
-(function (iter) {
-  var name;
-  for (name of iter) {
-    i();
-    return;
-  }
-})({});
+var a = 10;
+d[a] = 0;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          line: 4,
-          column: 8,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
     {
       code: `
-(function (iter) {
-  var name;
-  for (name of iter) {
-  }
-})({});
+(function () {
+  var a = 10;
+  return a;
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          line: 4,
-          column: 8,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
+    },
+    {
+      code: '(function g() {})();',
+      options: ['all'],
     },
     {
       code: `
-(function (iter) {
-  for (var name of iter) {
-  }
-})({});
+function f(a) {
+  alert(a);
+}
+f();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          line: 3,
-          column: 12,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'name',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // https://github.com/eslint/eslint/issues/3617
     {
       code: `
-/* global foobar, foo, bar */
-foobar;
+var c = 0;
+function f(a) {
+  var b = a;
+  return b;
+}
+f(c);
       `,
-      errors: [
-        {
-          line: 2,
-          endLine: 2,
-          column: 19,
-          endColumn: 22,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-        {
-          line: 2,
-          endLine: 2,
-          column: 24,
-          endColumn: 27,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'bar',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
     {
       code: `
-/* global foobar,
-   foo,
-   bar
- */
-foobar;
+function a(x, y) {
+  return y;
+}
+a();
       `,
-      errors: [
-        {
-          line: 3,
-          column: 4,
-          endLine: 3,
-          endColumn: 7,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-        {
-          line: 4,
-          column: 4,
-          endLine: 4,
-          endColumn: 7,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'bar',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // Rest property sibling without ignoreRestSiblings
     {
       code: `
-const data = { type: 'coords', x: 1, y: 2 };
-const { type, ...coords } = data;
-console.log(coords);
+var arr1 = [1, 2];
+var arr2 = [3, 4];
+for (var i in arr1) {
+  arr1[i] = 5;
+}
+for (var i in arr2) {
+  arr2[i] = 10;
+}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 3,
-          column: 9,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'type',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // Unused rest property with ignoreRestSiblings
     {
-      code: `
-const data = { type: 'coords', x: 2, y: 2 };
-const { type, ...coords } = data;
-console.log(type);
-      `,
-      options: [{ ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 3,
-          column: 18,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'coords',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      code: 'var a = 10;',
+      options: ['local'],
     },
     {
       code: `
-let type, coords;
-({ type, ...coords } = data);
-console.log(type);
+var min = 'min';
+Math[min];
       `,
-      options: [{ ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 3,
-          column: 13,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'coords',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // Unused rest property without ignoreRestSiblings
     {
       code: `
-const data = { type: 'coords', x: 3, y: 2 };
-const { type, ...coords } = data;
-console.log(type);
+Foo.bar = function (baz) {
+  return baz;
+};
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 3,
-          column: 18,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'coords',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: ['all'],
     },
-
-    // Nested array destructuring with rest property
+    'myFunc(function foo() {}.bind(this));',
+    'myFunc(function foo() {}.toString());',
+    `
+function foo(first, second) {
+  doStuff(function () {
+    console.log(second);
+  });
+}
+foo();
+    `,
+    `
+(function () {
+  var doSomething = function doSomething() {};
+  doSomething();
+})();
+    `,
+    '/*global a */ a;',
     {
       code: `
-const data = { vars: ['x', 'y'], x: 1, y: 2 };
-const {
-  vars: [x],
-  ...coords
-} = data;
-console.log(coords);
+var a = 10;
+(function () {
+  alert(a);
+})();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 4,
-          column: 10,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'x',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
+      options: [{ vars: 'all' }],
     },
-
-    // Nested object destructuring with rest property
     {
       code: `
-const data = { defaults: { x: 0 }, x: 1, y: 2 };
-const {
-  defaults: { x },
-  ...coords
-} = data;
-console.log(coords);
+function g(bar, baz) {
+  return baz;
+}
+g();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [
-        {
-          line: 4,
-          column: 15,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'x',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
-    },
-
-    // https://github.com/eslint/eslint/issues/8119
-    {
-      code: '({ a, ...rest }) => {};',
-      options: [{ args: 'all', ignoreRestSiblings: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-      errors: [definedError('rest')],
+      options: [{ vars: 'all' }],
     },
-
-    // https://github.com/eslint/eslint/issues/3714
     {
       code: `
-/* global a$fooz,$foo */
-a$fooz;
+function g(bar, baz) {
+  return baz;
+}
+g();
       `,
-      errors: [
-        {
-          line: 2,
-          column: 18,
-          endLine: 2,
-          endColumn: 22,
-          messageId: 'unusedVar',
-          data: {
-            varName: '$foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: [{ args: 'after-used', vars: 'all' }],
     },
     {
       code: `
-/* globals a$fooz, $ */
-a$fooz;
+function g(bar, baz) {
+  return bar;
+}
+g();
       `,
-      errors: [
-        {
-          line: 2,
-          column: 20,
-          endLine: 2,
-          endColumn: 21,
-          messageId: 'unusedVar',
-          data: {
-            varName: '$',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: '/*globals $foo*/',
-      errors: [
-        {
-          line: 1,
-          column: 11,
-          endLine: 1,
-          endColumn: 15,
-          messageId: 'unusedVar',
-          data: {
-            varName: '$foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: '/* global global*/',
-      errors: [
-        {
-          line: 1,
-          column: 11,
-          endLine: 1,
-          endColumn: 17,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'global',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: '/*global foo:true*/',
-      errors: [
-        {
-          line: 1,
-          column: 10,
-          endLine: 1,
-          endColumn: 13,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: [{ args: 'none', vars: 'all' }],
     },
-
-    // non ascii.
     {
       code: `
-/*global 変数, 数*/
-
-変数;
+function g(bar, baz) {
+  return 2;
+}
+g();
       `,
-      errors: [
-        {
-          line: 2,
-          column: 14,
-          endLine: 2,
-          endColumn: 15,
-          messageId: 'unusedVar',
-          data: {
-            varName: '数',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: [{ args: 'none', vars: 'all' }],
     },
-
-    // surrogate pair.
     {
       code: `
-/*global 𠮷𩸽, 𠮷*/
-𠮷𩸽;
+function g(bar, baz) {
+  return bar + baz;
+}
+g();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        {
-          line: 2,
-          column: 16,
-          endLine: 2,
-          endColumn: 18,
-          messageId: 'unusedVar',
-          data: {
-            varName: '𠮷',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      options: [{ args: 'all', vars: 'local' }],
+    },
+    {
+      code: `
+var g = function (bar, baz) {
+  return 2;
+};
+g();
+      `,
+      options: [{ args: 'none', vars: 'all' }],
     },
-
-    // https://github.com/eslint/eslint/issues/4047
+    `
+(function z() {
+  z();
+})();
+    `,
     {
-      code: 'export default function (a) {}',
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [definedError('a')],
+      code: ' ',
+      languageOptions: { globals: { a: true } },
     },
     {
       code: `
-export default function (a, b) {
-  console.log(a);
-}
+var who = 'Paul';
+module.exports = \`Hello \${who}!\`;
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'export var foo = 123;',
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
-      errors: [definedError('b')],
     },
     {
-      code: 'export default (function (a) {});',
+      code: 'export function foo() {}',
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
-      errors: [definedError('a')],
     },
     {
       code: `
-export default (function (a, b) {
-  console.log(a);
-});
+let toUpper = partial => partial.toUpperCase;
+export { toUpper };
       `,
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
-      errors: [definedError('b')],
     },
     {
-      code: 'export default a => {};',
+      code: 'export class foo {}',
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },
-      errors: [definedError('a')],
     },
     {
       code: `
-export default (a, b) => {
-  console.log(a);
-};
+class Foo {}
+var x = new Foo();
+x.foo();
       `,
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
-      errors: [definedError('b')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // caughtErrors
     {
       code: `
-try {
-} catch (err) {}
+const foo = 'hello!';
+function bar(foobar = foo) {
+  foobar.replace(/!$/, ' world!');
+}
+bar();
       `,
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+    `
+function Foo() {}
+var x = new Foo();
+x.foo();
+    `,
+    `
+function foo() {
+  var foo = 1;
+  return foo;
+}
+foo();
+    `,
+    `
+function foo(foo) {
+  return foo;
+}
+foo(1);
+    `,
+    `
+function foo() {
+  function foo() {
+    return 1;
+  }
+  return foo();
+}
+foo();
+    `,
     {
       code: `
-try {
-} catch (err) {}
+function foo() {
+  var foo = 1;
+  return foo;
+}
+foo();
       `,
-      options: [{ caughtErrors: 'all' }],
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-try {
-} catch (err) {}
+function foo(foo) {
+  return foo;
+}
+foo(1);
       `,
-      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
-      errors: [
-        definedError(
-          'err',
-          '. Allowed unused caught errors must match /^ignore/u',
-        ),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-try {
-} catch (err) {}
+function foo() {
+  function foo() {
+    return 1;
+  }
+  return foo();
+}
+foo();
       `,
-      options: [{ caughtErrors: 'all', varsIgnorePattern: '^err' }],
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-try {
-} catch (err) {}
+const x = 1;
+const [y = x] = [];
+foo(y);
       `,
-      options: [{ caughtErrors: 'all', varsIgnorePattern: '^.' }],
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // multiple try catch with one success
     {
       code: `
-try {
-} catch (ignoreErr) {}
-try {
-} catch (err) {}
+const x = 1;
+const { y = x } = {};
+foo(y);
       `,
-      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
-      errors: [
-        definedError(
-          'err',
-          '. Allowed unused caught errors must match /^ignore/u',
-        ),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // multiple try catch both fail
     {
       code: `
-try {
-} catch (error) {}
-try {
-} catch (err) {}
+const x = 1;
+const {
+  z: [y = x],
+} = {};
+foo(y);
       `,
-      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
-      errors: [
-        definedError(
-          'error',
-          '. Allowed unused caught errors must match /^ignore/u',
-        ),
-        definedError(
-          'err',
-          '. Allowed unused caught errors must match /^ignore/u',
-        ),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // caughtErrors with other configs
     {
       code: `
-try {
-} catch (err) {}
+const x = [];
+const { z: [y] = x } = {};
+foo(y);
       `,
-      options: [{ vars: 'all', args: 'all', caughtErrors: 'all' }],
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // no conflict in ignore patterns
     {
       code: `
-try {
-} catch (err) {}
+const x = 1;
+let y;
+[y = x] = [];
+foo(y);
       `,
-      options: [
-        {
-          vars: 'all',
-          args: 'all',
-          caughtErrors: 'all',
-          argsIgnorePattern: '^er',
-        },
-      ],
-      errors: [definedError('err')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // Ignore reads for modifications to itself: https://github.com/eslint/eslint/issues/6348
     {
       code: `
-var a = 0;
-a = a + 1;
+const x = 1;
+let y;
+({
+  z: [y = x],
+} = {});
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 0;
-a = a + a;
+const x = [];
+let y;
+({ z: [y] = x } = {});
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+const x = 1;
+function foo(y = x) {
+  bar(y);
+}
+foo();
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+const x = 1;
+function foo({ y = x } = {}) {
+  bar(y);
+}
+foo();
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+const x = 1;
+function foo(
+  y = function (z = x) {
+    bar(z);
+  },
+) {
+  y();
+}
+foo();
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 0;
-a += a + 1;
+const x = 1;
+function foo(
+  y = function () {
+    bar(x);
+  },
+) {
+  y();
+}
+foo();
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 0;
-a++;
+var x = 1;
+var [y = x] = [];
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(a) {
-  a = a + 1;
-}
-foo();
+var x = 1;
+var { y = x } = {};
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(a) {
-  a += a + 1;
-}
-foo();
+var x = 1;
+var {
+  z: [y = x],
+} = {};
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(a) {
-  a++;
-}
-foo();
+var x = [];
+var { z: [y] = x } = {};
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 3;
-a = a * 5 + 6;
+var x = 1,
+  y;
+[y = x] = [];
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = 2,
-  b = 4;
-a = a * 2 + b;
+var x = 1,
+  y;
+({
+  z: [y = x],
+} = {});
+foo(y);
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // https://github.com/eslint/eslint/issues/6576 (For coverage)
     {
       code: `
-function foo(cb) {
-  cb = function (a) {
-    cb(1 + a);
-  };
-  bar(not_cb);
-}
-foo();
+var x = [],
+  y;
+({ z: [y] = x } = {});
+foo(y);
       `,
-      errors: [assignedError('cb')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(cb) {
-  cb = (function (a) {
-    return cb(1 + a);
-  })();
+var x = 1;
+function foo(y = x) {
+  bar(y);
 }
 foo();
       `,
-      errors: [assignedError('cb')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(cb) {
-  cb =
-    (function (a) {
-      cb(1 + a);
-    },
-    cb);
+var x = 1;
+function foo({ y = x } = {}) {
+  bar(y);
 }
 foo();
       `,
-      errors: [assignedError('cb')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(cb) {
-  cb =
-    (0,
-    function (a) {
-      cb(1 + a);
-    });
+var x = 1;
+function foo(
+  y = function (z = x) {
+    bar(z);
+  },
+) {
+  y();
 }
 foo();
       `,
-      errors: [assignedError('cb')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // https://github.com/eslint/eslint/issues/6646
     {
       code: `
-while (a) {
-  function foo(b) {
-    b = b + 1;
-  }
-  foo();
+var x = 1;
+function foo(
+  y = function () {
+    bar(x);
+  },
+) {
+  y();
 }
+foo();
       `,
-      errors: [assignedError('b')],
-    },
-
-    // https://github.com/eslint/eslint/issues/7124
-    {
-      code: '(function (a, b, c) {});',
-      options: [{ argsIgnorePattern: 'c' }],
-      errors: [
-        definedError('a', '. Allowed unused args must match /c/u'),
-        definedError('b', '. Allowed unused args must match /c/u'),
-      ],
-    },
-    {
-      code: '(function (a, b, { c, d }) {});',
-      options: [{ argsIgnorePattern: '[cd]' }],
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        definedError('a', '. Allowed unused args must match /[cd]/u'),
-        definedError('b', '. Allowed unused args must match /[cd]/u'),
-      ],
     },
+
+    // exported variables should work
+    "/*exported toaster*/ var toaster = 'great';",
+    `
+/*exported toaster, poster*/ var toaster = 1;
+poster = 0;
+    `,
     {
-      code: '(function (a, b, { c, d }) {});',
-      options: [{ argsIgnorePattern: 'c' }],
+      code: '/*exported x*/ var { x } = y;',
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        definedError('a', '. Allowed unused args must match /c/u'),
-        definedError('b', '. Allowed unused args must match /c/u'),
-        definedError('d', '. Allowed unused args must match /c/u'),
-      ],
     },
     {
-      code: '(function (a, b, { c, d }) {});',
-      options: [{ argsIgnorePattern: 'd' }],
+      code: '/*exported x, y*/ var { x, y } = z;',
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        definedError('a', '. Allowed unused args must match /d/u'),
-        definedError('b', '. Allowed unused args must match /d/u'),
-        definedError('c', '. Allowed unused args must match /d/u'),
-      ],
-    },
-    {
-      code: `
-/*global
-foo*/
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 1,
-          endLine: 3,
-          endColumn: 4,
-          messageId: 'unusedVar',
-          data: {
-            varName: 'foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
     },
 
-    // https://github.com/eslint/eslint/issues/8442
+    // Can mark variables as used via context.markVariableAsUsed()
+    '/*eslint @rule-tester/use-every-a:1*/ var a;',
+    `
+/*eslint @rule-tester/use-every-a:1*/ !function (a) {
+  return 1;
+};
+    `,
+    `
+/*eslint @rule-tester/use-every-a:1*/ !function () {
+  var a;
+  return 1;
+};
+    `,
+
+    // ignore pattern
     {
-      code: `
-(function ({ a }, b) {
-  return b;
-})();
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a')],
+      code: 'var _a;',
+      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
     },
     {
       code: `
-(function ({ a }, { b, c }) {
-  return b;
-})();
+var a;
+function foo() {
+  var _b;
+}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a'), definedError('c')],
+      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
     },
-
-    // https://github.com/eslint/eslint/issues/14325
     {
       code: `
-let x = 0;
-x++, (x = 0);
+function foo(_a) {}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 7 }],
+      options: [{ args: 'all', argsIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-x++, (x = 0);
-x = 3;
+function foo(a, _b) {
+  return a;
+}
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 4, column: 1 }],
+      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-x++, 0;
+var [firstItemIgnored, secondItem] = items;
+console.log(secondItem);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 1 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
     },
     {
       code: `
-let x = 0;
-0, x++;
+const [a, _b, c] = items;
+console.log(a + c);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 4 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-0, (1, x++);
+const [[a, _b, c]] = items;
+console.log(a + c);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 8 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-foo = (x++, 0);
+const {
+  x: [_a, foo],
+} = bar;
+console.log(foo);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 8 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-foo = ((0, x++), 0);
+function baz([_b, foo]) {
+  foo;
+}
+baz();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 12 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-(x += 1), 0;
+function baz({ x: [_b, foo] }) {
+  foo;
+}
+baz();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-0, (x += 1);
+function baz([
+  {
+    x: [_b, foo],
+  },
+]) {
+  foo;
+}
+baz();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 5 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-0, (1, (x += 1));
+let _a, b;
+foo.forEach(item => {
+  [_a, b] = item;
+  doSomething(b);
+});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 9 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-foo = ((x += 1), 0);
+// doesn't report _x
+let _x, y;
+_x = 1;
+[_x, y] = foo;
+y;
+
+// doesn't report _a
+let _a, b;
+[_a, b] = foo;
+_a = 1;
+b;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 9 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ destructuredArrayIgnorePattern: '^_' }],
     },
     {
       code: `
-let x = 0;
-foo = ((0, (x += 1)), 0);
+// doesn't report _x
+let _x, y;
+_x = 1;
+[_x, y] = foo;
+y;
+
+// doesn't report _a
+let _a, b;
+_a = 1;
+({ _a, ...b } = foo);
+b;
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 13 }],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [
+        { destructuredArrayIgnorePattern: '^_', ignoreRestSiblings: true },
+      ],
     },
 
-    // https://github.com/eslint/eslint/issues/14866
+    // for-in loops (see #2342)
+    `
+(function (obj) {
+  var name;
+  for (name in obj) return;
+})({});
+    `,
+    `
+(function (obj) {
+  var name;
+  for (name in obj) {
+    return;
+  }
+})({});
+    `,
+    `
+(function (obj) {
+  for (var name in obj) {
+    return true;
+  }
+})({});
+    `,
+    `
+(function (obj) {
+  for (var name in obj) return true;
+})({});
+    `,
+
     {
       code: `
-let z = 0;
-(z = z + 1), (z = 2);
+(function (obj) {
+  let name;
+  for (name in obj) return;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('z'), line: 3, column: 15 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-let z = 0;
-(z = z + 1), (z = 2);
-z = 3;
+(function (obj) {
+  let name;
+  for (name in obj) {
+    return;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('z'), line: 4, column: 1 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-let z = 0;
-(z = z + 1), (z = 2);
-z = z + 3;
+(function (obj) {
+  for (let name in obj) {
+    return true;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('z'), line: 4, column: 1 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-let x = 0;
-0, (x = x + 1);
+(function (obj) {
+  for (let name in obj) return true;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 5 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
     {
       code: `
-let x = 0;
-(x = x + 1), 0;
+(function (obj) {
+  for (const name in obj) {
+    return true;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 2 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-let x = 0;
-foo = ((0, (x = x + 1)), 0);
+(function (obj) {
+  for (const name in obj) return true;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 13 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
+    // For-of loops
     {
       code: `
-let x = 0;
-foo = ((x = x + 1), 0);
+(function (iter) {
+  let name;
+  for (name of iter) return;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 9 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-let x = 0;
-0, (1, (x = x + 1));
+(function (iter) {
+  let name;
+  for (name of iter) {
+    return;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 9 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-(function ({ a, b }, { c }) {
-  return b;
-})();
+(function (iter) {
+  for (let name of iter) {
+    return true;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-(function ([a], b) {
-  return b;
-})();
+(function (iter) {
+  for (let name of iter) return true;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
     {
       code: `
-(function ([a], [b, c]) {
-  return b;
-})();
+(function (iter) {
+  for (const name of iter) {
+    return true;
+  }
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-(function ([a, b], [c]) {
-  return b;
-})();
+(function (iter) {
+  for (const name of iter) return true;
+})({});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [definedError('a'), definedError('c')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
-    // https://github.com/eslint/eslint/issues/9774
-    {
-      code: '(function (_a) {})();',
-      options: [{ args: 'all', varsIgnorePattern: '^_' }],
-      errors: [definedError('_a')],
-    },
+    // Sequence Expressions (See https://github.com/eslint/eslint/issues/14325)
     {
-      code: '(function (_a) {})();',
-      options: [{ args: 'all', caughtErrorsIgnorePattern: '^_' }],
-      errors: [definedError('_a')],
+      code: `
+let x = 0;
+foo = (0, x++);
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-
-    // https://github.com/eslint/eslint/issues/10982
     {
       code: `
-var a = function () {
-  a();
-};
+let x = 0;
+foo = (0, (x += 1));
       `,
-      errors: [assignedError('a')],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-var a = function () {
-  return function () {
-    a();
-  };
-};
+let x = 0;
+foo = (0, (x = x + 1));
       `,
-      errors: [{ ...assignedError('a'), line: 2, column: 5 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
+
+    // caughtErrors
     {
       code: `
-const a = () => () => {
-  a();
-};
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('a'), line: 2, column: 7 }],
+      options: [{ caughtErrors: 'none' }],
     },
     {
       code: `
-let myArray = [1, 2, 3, 4].filter(x => x == 0);
-myArray = myArray.filter(x => x == 1);
+try {
+} catch (err) {
+  console.error(err);
+}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('myArray'), line: 3, column: 1 }],
+      options: [{ caughtErrors: 'all' }],
     },
     {
       code: `
-const a = 1;
-a += 1;
+try {
+} catch (ignoreErr) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('a'), line: 3, column: 1 }],
+      options: [{ caughtErrorsIgnorePattern: '^ignore' }],
     },
     {
       code: `
-const a = () => {
-  a();
-};
+try {
+} catch (ignoreErr) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('a'), line: 2, column: 7 }],
+      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
     },
 
-    // https://github.com/eslint/eslint/issues/14324
+    // caughtErrors with other combinations
     {
       code: `
-let x = [];
-x = x.concat(x);
+try {
+} catch (err) {}
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
-      errors: [{ ...assignedError('x'), line: 3, column: 1 }],
+      options: [{ args: 'all', caughtErrors: 'none', vars: 'all' }],
     },
+
+    // Using object rest for variable omission
     {
       code: `
-let a = 'a';
-a = 10;
-function foo() {
-  a = 11;
-  a = () => {
-    a = 13;
-  };
-}
+const data = { type: 'coords', x: 1, y: 2 };
+const { type, ...coords } = data;
+console.log(coords);
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [
-        {
-          ...assignedError('a'),
-          line: 3,
-          column: 1,
-        },
-        {
-          ...definedError('foo'),
-          line: 4,
-          column: 10,
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ ignoreRestSiblings: true }],
     },
+
+    // https://github.com/eslint/eslint/issues/6348
+    `
+var a = 0,
+  b;
+b = a = a + 1;
+foo(b);
+    `,
+    `
+var a = 0,
+  b;
+b = a += a + 1;
+foo(b);
+    `,
+    `
+var a = 0,
+  b;
+b = a++;
+foo(b);
+    `,
+    `
+function foo(a) {
+  var b = (a = a + 1);
+  bar(b);
+}
+foo();
+    `,
+    `
+function foo(a) {
+  var b = (a += a + 1);
+  bar(b);
+}
+foo();
+    `,
+    `
+function foo(a) {
+  var b = a++;
+  bar(b);
+}
+foo();
+    `,
+
+    // https://github.com/eslint/eslint/issues/6576
+    `
+var unregisterFooWatcher;
+// ...
+unregisterFooWatcher = $scope.$watch('foo', function () {
+  // ...some code..
+  unregisterFooWatcher();
+});
+    `,
+    `
+var ref;
+ref = setInterval(function () {
+  clearInterval(ref);
+}, 10);
+    `,
+    `
+var _timer;
+function f() {
+  _timer = setTimeout(function () {}, _timer ? 100 : 0);
+}
+f();
+    `,
+    `
+function foo(cb) {
+  cb = (function () {
+    function something(a) {
+      cb(1 + a);
+    }
+    register(something);
+  })();
+}
+foo();
+    `,
     {
       code: `
-let foo;
-init();
-foo = foo + 2;
-function init() {
-  foo = 1;
+function* foo(cb) {
+  cb = yield function (a) {
+    cb(1 + a);
+  };
 }
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('foo'), line: 4, column: 1 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
-function foo(n) {
-  if (n < 2) return 1;
-  return n * foo(n - 1);
+function foo(cb) {
+  cb = tag\`hello\${function (a) {
+    cb(1 + a);
+  }}\`;
 }
+foo();
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...definedError('foo'), line: 2, column: 10 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-    {
-      code: `
-let c = 'c';
-c = 10;
-function foo1() {
-  c = 11;
-  c = () => {
-    c = 13;
+    `
+function foo(cb) {
+  var b;
+  cb = b = function (a) {
+    cb(1 + a);
   };
+  b();
 }
+foo();
+    `,
 
-c = foo1;
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      errors: [{ ...assignedError('c'), line: 11, column: 1 }],
-    },
+    // https://github.com/eslint/eslint/issues/6646
+    `
+function someFunction() {
+  var a = 0,
+    i;
+  for (i = 0; i < 2; i++) {
+    a = myFunction(a);
+  }
+}
+someFunction();
+    `,
 
-    // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
+    // https://github.com/eslint/eslint/issues/7124
     {
       code: `
-class Foo {
-  static {}
-}
+(function (a, b, { c, d }) {
+  d;
+});
       `,
-      options: [{ ignoreClassWithStaticInitBlock: false }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ argsIgnorePattern: 'c' }],
     },
     {
       code: `
-class Foo {
-  static {}
-}
+(function (a, b, { c, d }) {
+  c;
+});
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ argsIgnorePattern: 'd' }],
     },
+
+    // https://github.com/eslint/eslint/issues/7250
     {
       code: `
-class Foo {
-  static {
-    var bar;
-  }
-}
+(function (a, b, c) {
+  c;
+});
       `,
-      options: [{ ignoreClassWithStaticInitBlock: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('bar'), line: 4, column: 9 }],
+      options: [{ argsIgnorePattern: 'c' }],
     },
     {
-      code: 'class Foo {}',
-      options: [{ ignoreClassWithStaticInitBlock: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('Foo'), line: 1, column: 7 }],
+      code: `
+(function (a, b, { c, d }) {
+  c;
+});
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ argsIgnorePattern: '[cd]' }],
     },
+
+    // https://github.com/eslint/eslint/issues/7351
     {
       code: `
-class Foo {
-  static bar;
-}
+(class {
+  set foo(UNUSED) {}
+});
       `,
-      options: [{ ignoreClassWithStaticInitBlock: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 class Foo {
-  static bar() {}
+  set bar(UNUSED) {}
 }
+console.log(Foo);
       `,
-      options: [{ ignoreClassWithStaticInitBlock: true }],
-      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
-      errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
-    // https://github.com/eslint/eslint/issues/17568
+    // https://github.com/eslint/eslint/issues/8119
+    {
+      code: '({ a, ...rest }) => rest;',
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+      options: [{ args: 'all', ignoreRestSiblings: true }],
+    },
+
+    // https://github.com/eslint/eslint/issues/14163
     {
       code: `
-const _a = 5;
-const _b = _a + 5;
+let foo, rest;
+({ foo, ...rest } = something);
+console.log(rest);
       `,
-      options: [
-        { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ ignoreRestSiblings: true }],
     },
+
+    // https://github.com/eslint/eslint/issues/10952
+    `
+/*eslint @rule-tester/use-every-a:1*/ !function (b, a) {
+  return 1;
+};
+    `,
+
+    // https://github.com/eslint/eslint/issues/10982
+    `
+var a = function () {
+  a();
+};
+a();
+    `,
+    `
+var a = function () {
+  return function () {
+    a();
+  };
+};
+a();
+    `,
     {
       code: `
-const _a = 42;
-foo(() => _a);
+const a = () => {
+  a();
+};
+a();
       `,
-      options: [
-        { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
-(function foo(_a) {
-  return _a + 5;
-})(5);
+const a = () => () => {
+  a();
+};
+a();
       `,
-      options: [
-        { args: 'all', argsIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      errors: [usedIgnoredError('_a', '. Used args must not match /^_/u')],
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
+    },
+
+    // export * as ns from "source"
+    {
+      code: "export * as ns from 'source';",
+      languageOptions: {
+        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      },
+    },
+
+    // import.meta
+    {
+      code: 'import.meta;',
+      languageOptions: {
+        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      },
     },
+
+    // https://github.com/eslint/eslint/issues/17299
     {
       code: `
-const [a, _b] = items;
-console.log(a + _b);
+var a;
+a ||= 1;
       `,
-      options: [
-        { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        usedIgnoredError(
-          '_b',
-          '. Used elements of array destructuring must not match /^_/u',
-        ),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
-let _x;
-[_x] = arr;
-foo(_x);
+var a;
+a &&= 1;
       `,
-      options: [
-        {
-          destructuredArrayIgnorePattern: '^_',
-          reportUsedIgnorePattern: true,
-          varsIgnorePattern: '[iI]gnored',
-        },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        usedIgnoredError(
-          '_x',
-          '. Used elements of array destructuring must not match /^_/u',
-        ),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
-const [ignored] = arr;
-foo(ignored);
+var a;
+a ??= 1;
       `,
-      options: [
-        {
-          destructuredArrayIgnorePattern: '^_',
-          reportUsedIgnorePattern: true,
-          varsIgnorePattern: '[iI]gnored',
-        },
-      ],
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      errors: [
-        usedIgnoredError('ignored', '. Used vars must not match /[iI]gnored/u'),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
+
+    // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
     {
       code: `
-try {
-} catch (_err) {
-  console.error(_err);
+class Foo {
+  static {}
 }
       `,
-      options: [
-        {
-          caughtErrors: 'all',
-          caughtErrorsIgnorePattern: '^_',
-          reportUsedIgnorePattern: true,
-        },
-      ],
-      errors: [
-        usedIgnoredError('_err', '. Used caught errors must not match /^_/u'),
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [{ ignoreClassWithStaticInitBlock: true }],
     },
     {
       code: `
-try {
-} catch (_) {
-  _ = 'foo';
+class Foo {
+  static {}
 }
       `,
-      options: [{ caughtErrorsIgnorePattern: 'foo' }],
-      errors: [
-        assignedError('_', '. Allowed unused caught errors must match /foo/u'),
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+      options: [
+        { ignoreClassWithStaticInitBlock: true, varsIgnorePattern: '^_' },
       ],
     },
     {
       code: `
-try {
-} catch (_) {
-  _ = 'foo';
+class Foo {
+  static {}
 }
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       options: [
-        {
-          caughtErrorsIgnorePattern: 'ignored',
-          varsIgnorePattern: '_',
-        },
-      ],
-      errors: [
-        assignedError(
-          '_',
-          '. Allowed unused caught errors must match /ignored/u',
-        ),
+        { ignoreClassWithStaticInitBlock: false, varsIgnorePattern: '^Foo' },
       ],
     },
+
+    // https://github.com/eslint/eslint/issues/17568
     {
       code: `
-try {
-} catch ({ message, errors: [firstError] }) {}
+const a = 5;
+const _c = a + 5;
       `,
-      options: [{ caughtErrorsIgnorePattern: 'foo' }],
-      errors: [
-        {
-          ...definedError(
-            'message',
-            '. Allowed unused caught errors must match /foo/u',
-          ),
-          column: 12,
-          endColumn: 19,
-        },
-        {
-          ...definedError(
-            'firstError',
-            '. Allowed unused caught errors must match /foo/u',
-          ),
-          column: 30,
-          endColumn: 40,
-        },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [
+        { args: 'all', reportUsedIgnorePattern: true, varsIgnorePattern: '^_' },
       ],
     },
     {
       code: `
-try {
-} catch ({ stack: $ }) {
-  $ = 'Something broke: ' + $;
-}
+(function foo(a, _b) {
+  return a + 5;
+})(5);
       `,
-      options: [{ caughtErrorsIgnorePattern: '\\w' }],
-      errors: [
-        {
-          ...assignedError(
-            '$',
-            '. Allowed unused caught errors must match /\\w/u',
-          ),
-          column: 3,
-          endColumn: 4,
-        },
+      options: [
+        { args: 'all', argsIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
     },
     {
       code: `
-_ => {
-  _ = _ + 1;
-};
+const [a, _b, c] = items;
+console.log(a + c);
       `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: [
-        {
-          argsIgnorePattern: 'ignored',
-          varsIgnorePattern: '_',
-        },
-      ],
-      errors: [
-        assignedError('_', '. Allowed unused args must match /ignored/u'),
+        { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars.test.ts b/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars.test.ts
index 5a94f751993a..e50f81feb505 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars.test.ts
@@ -7,9 +7,9 @@ import { getFixturesRootDir } from '../../RuleTester';
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
+      ecmaFeatures: {},
       ecmaVersion: 6,
       sourceType: 'module',
-      ecmaFeatures: {},
     },
   },
 });
@@ -29,2242 +29,2242 @@ ruleTester.defineRule('collect-unused-vars', {
   defaultOptions: [],
   meta: {
     messages: {},
-    type: 'problem',
     schema: [],
+    type: 'problem',
   },
 });
 
 ruleTester.run('no-unused-vars', rule, {
-  valid: [
-    `
+  invalid: [
+    {
+      code: `
 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() {}
-}
-    `,
-    `
-import { AccessorDecorator } from 'decorators';
-export class Foo {
-  @AccessorDecorator
-  set bar() {}
-}
-    `,
-    `
-import { MethodDecoratorFactory } from 'decorators';
-export class Foo {
-  @MethodDecoratorFactory(false)
-  bar() {}
-}
-    `,
-    `
-import { MethodDecorator } from 'decorators';
-export class Foo {
-  @MethodDecorator
-  static bar() {}
-}
-    `,
-    `
-import { ConstructorParameterDecoratorFactory } from 'decorators';
-export class Service {
-  constructor(
-    @ConstructorParameterDecoratorFactory(APP_CONFIG) config: AppConfig,
-  ) {
-    this.title = config.title;
-  }
-}
-    `,
-    `
-import { ConstructorParameterDecorator } from 'decorators';
-export class Foo {
-  constructor(@ConstructorParameterDecorator bar) {
-    this.bar = bar;
-  }
-}
-    `,
-    `
-import { ParameterDecoratorFactory } from 'decorators';
-export class Qux {
-  bar(@ParameterDecoratorFactory(true) baz: number) {
-    console.log(baz);
-  }
-}
-    `,
-    `
-import { ParameterDecorator } from 'decorators';
-export class Foo {
-  static greet(@ParameterDecorator name: string) {
-    return name;
-  }
-}
-    `,
-    `
-import { Input, Output, EventEmitter } from 'decorators';
-export class SomeComponent {
-  @Input() data;
-  @Output()
-  click = new EventEmitter();
-}
-    `,
-    `
-import { configurable } from 'decorators';
-export class A {
-  @configurable(true) static prop1;
-
-  @configurable(false)
-  static prop2;
-}
-    `,
-    `
-import { foo, bar } from 'decorators';
-export class B {
-  @foo x;
-
-  @bar
-  y;
-}
-    `,
-    `
-interface Base {}
-class Thing implements Base {}
-new Thing();
-    `,
-    `
-interface Base {}
-const a: Base = {};
-console.log(a);
-    `,
-    `
-import { Foo } from 'foo';
-function bar<T>(): T {}
-bar<Foo>();
-    `,
-    `
-import { Foo } from 'foo';
-const bar = function <T>(): T {};
-bar<Foo>();
-    `,
-    `
-import { Foo } from 'foo';
-const bar = <T,>(): T => {};
-bar<Foo>();
-    `,
-    `
-import { Foo } from 'foo';
-<Foo>(<T,>(): 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);
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'ClassDecoratorFactory',
+          },
+          endColumn: 31,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+import { Foo, Bar } from 'foo';
+function baz<Foo>(): Foo {}
+baz<Bar>();
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
-const a: Nullable & undefined = 'hello';
+const a: string = 'hello';
 console.log(a);
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Nullable',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
-const a: Nullable<SomeOther[]> = 'hello';
+const a: Nullable<string> = 'hello';
 console.log(a);
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'SomeOther',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+
+    {
+      code: `
 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> {}
-
-new Foo();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { Component } from 'react';
-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>, {}> {}
-new Foo();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'some';
-import { Component } from 'react';
-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 {}
-new Foo();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { Another } from 'some';
-class A {
-  do = (a: Nullable<Another>) => {
-    console.log(a);
-  };
-}
-new A();
-    `,
-    `
+import { Another } from 'some';
+class A {
+  do = (a: Nullable) => {
+    console.log(a);
+  };
+}
+new A();
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Another',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-  do(a: Nullable<Another>) {
+  do(a: Nullable) {
     console.log(a);
   }
 }
 new A();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Another',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-  do(): Nullable<Another> {
+  do(): Nullable {
     return null;
   }
 }
 new A();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Another',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 export interface A {
-  do(a: Nullable<Another>);
+  do(a: Nullable);
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Another',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 export interface A {
-  other: Nullable<Another>;
+  other: Nullable;
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Another',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
-function foo(a: Nullable) {
+function foo(a: string) {
   console.log(a);
 }
 foo();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Nullable',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
-function foo(): Nullable {
+function foo(): string | null {
   return null;
 }
 foo();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'some';
-class A extends Nullable<SomeOther> {
-  other: Nullable<Another>;
-}
-new A();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Nullable',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
-class A extends Nullable<SomeOther> {
-  do(a: Nullable<Another>) {
-    console.log(a);
-  }
+class A extends Nullable {
+  other: Nullable<Another>;
 }
 new A();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'SomeOther',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
-export interface A extends Nullable<SomeOther> {
+abstract class A extends Nullable {
   other: Nullable<Another>;
 }
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'some';
-import { Another } from 'some';
-export interface A extends Nullable<SomeOther> {
-  do(a: Nullable<Another>);
+new A();
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'SomeOther',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+enum FormFieldIds {
+  PHONE = 'phone',
+  EMAIL = 'email',
 }
-    `,
-    `
-import { Foo } from './types';
-
-class Bar<T extends Foo> {
-  prop: T;
-}
-
-new Bar<number>();
-    `,
-    `
-import { Foo, Bar } from './types';
-
-class Baz<T extends Foo & Bar> {
-  prop: T;
+      `,
+      errors: [
+        {
+          column: 6,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'FormFieldIds',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+import test from 'test';
+import baz from 'baz';
+export interface Bar extends baz.test {}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'test',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+import test from 'test';
+import baz from 'baz';
+export interface Bar extends baz().test {}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'test',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+import test from 'test';
+import baz from 'baz';
+export class Bar implements baz.test {}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'test',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+import test from 'test';
+import baz from 'baz';
+export class Bar implements baz().test {}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'test',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+namespace Foo {}
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+namespace Foo {
+  export const Foo = 1;
 }
-
-new Baz<any>();
-    `,
-    `
-import { Foo } from './types';
-
-class Bar<T = Foo> {
-  prop: T;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+namespace Foo {
+  const Foo = 1;
+  console.log(Foo);
 }
-
-new Bar<number>();
-    `,
-    `
-import { Foo } from './types';
-
-class Foo<T = any> {
-  prop: T;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+namespace Foo {
+  export const Bar = 1;
+  console.log(Foo.Bar);
 }
-
-new Foo();
-    `,
-    `
-import { Foo } from './types';
-
-class Foo<T = {}> {
-  prop: T;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+namespace Foo {
+  namespace Foo {
+    export const Bar = 1;
+    console.log(Foo.Bar);
+  }
 }
-
-new Foo();
-    `,
-    `
-import { Foo } from './types';
-
-class Foo<T extends {} = {}> {
-  prop: T;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 13,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    // self-referencing types
+    {
+      code: `
+interface Foo {
+  bar: string;
+  baz: Foo['bar'];
 }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+type Foo = Array<Foo>;
+      `,
+      errors: [
+        {
+          column: 6,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2455
+    {
+      code: `
+import React from 'react';
+import { Fragment } from 'react';
 
-new Foo();
-    `,
-    `
-type Foo = 'a' | 'b' | 'c';
-type Bar = number;
-
-export const map: { [name in Foo]: Bar } = {
-  a: 1,
-  b: 2,
-  c: 3,
+export const ComponentFoo = () => {
+  return <div>Foo Foo</div>;
 };
-    `,
-    // 4.1 remapped mapped type
-    `
-type Foo = 'a' | 'b' | 'c';
-type Bar = number;
+      `,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Fragment',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+import React from 'react';
+import { h } from 'some-other-jsx-lib';
 
-export const map: { [name in Foo as string]: Bar } = {
-  a: 1,
-  b: 2,
-  c: 3,
-};
-    `,
-    `
-import { Nullable } from 'nullable';
-class A<T> {
-  bar: T;
-}
-new A<Nullable>();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'other';
-function foo<T extends Nullable>(): T {}
-foo<SomeOther>();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'other';
-class A<T extends Nullable> {
-  bar: T;
-}
-new A<SomeOther>();
-    `,
-    `
-import { Nullable } from 'nullable';
-import { SomeOther } from 'other';
-interface A<T extends Nullable> {
-  bar: T;
-}
-export const a: A<SomeOther> = {
-  foo: 'bar',
+export const ComponentFoo = () => {
+  return <div>Foo Foo</div>;
 };
-    `,
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/150
-    `
-export class App {
-  constructor(private logger: Logger) {
-    console.log(this.logger);
-  }
-}
-    `,
-    `
-export class App {
-  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);
-  }
-}
-    `,
-    `
-export class App {
-  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);
-  }
-}
-    `,
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/126
-    `
-import { Component, Vue } from 'vue-property-decorator';
-import HelloWorld from './components/HelloWorld.vue';
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'React',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: 'h',
+        },
+      },
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3303
+    {
+      code: `
+import React from 'react';
 
-@Component({
-  components: {
-    HelloWorld,
-  },
-})
-export default class App extends Vue {}
-    `,
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/189
-    `
-import firebase, { User } from 'firebase/app';
-// initialize firebase project
-firebase.initializeApp({});
-export function authenticated(cb: (user: User | null) => void): void {
-  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> {
-  prop: T;
-}
-    `,
-    `
-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();
-}
-    `,
-    `
-import { Foo, Bar } from './types';
-export class Baz<F = Foo & Bar> {
-  prop: F;
+export const ComponentFoo = () => {
+  return <div>Foo Foo</div>;
+};
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'React',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: null,
+        },
+      },
+    },
+    {
+      code: `
+declare module 'foo' {
+  type Test = any;
+  const x = 1;
+  export = x;
 }
-    `,
-    `
-// warning 'B' is defined but never used
-export const a: Array<{ b: B }> = [];
-    `,
-    `
-export enum FormFieldIds {
-  PHONE = 'phone',
-  EMAIL = 'email',
+      `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Test',
+          },
+          endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+// not declared
+export namespace Foo {
+  namespace Bar {
+    namespace Baz {
+      namespace Bam {
+        const x = 1;
+      }
+    }
+  }
 }
-    `,
-    `
-enum FormFieldIds {
-  PHONE = 'phone',
-  EMAIL = 'email',
+      `,
+      errors: [
+        {
+          column: 13,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Bar',
+          },
+          line: 4,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 15,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Baz',
+          },
+          line: 5,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 17,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Bam',
+          },
+          line: 6,
+          messageId: 'unusedVar',
+        },
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'x',
+          },
+          line: 7,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  a: string;
 }
-export interface IFoo {
-  fieldName: FormFieldIds;
+interface Foo {
+  b: Foo;
 }
-    `,
-    `
-enum FormFieldIds {
-  PHONE = 'phone',
-  EMAIL = 'email',
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+let x = null;
+x = foo(x);
+      `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'x',
+          },
+          endColumn: 2,
+          endLine: 3,
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  bar: string;
 }
-export interface IFoo {
-  fieldName: FormFieldIds.EMAIL;
+const Foo = 'bar';
+      `,
+      errors: [
+        {
+          column: 7,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 5,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+let foo = 1;
+foo += 1;
+      `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
+          },
+          line: 3,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  bar: string;
 }
-    `,
-    // 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');
-    `,
-    // 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;
+type Bar = 1;
+export = Bar;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  bar: string;
 }
-console.log(Foo);
-    `,
-    `
-import foo from 'foo';
-export interface Bar extends foo.i18n {}
-    `,
-    `
-import foo from 'foo';
-import bar from 'foo';
-export interface Bar extends foo.i18n<bar> {}
-    `,
+type Bar = 1;
+export = Foo;
+      `,
+      errors: [
+        {
+          column: 6,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Bar',
+          },
+          line: 5,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/141
       code: `
-import { TypeA } from './interface';
-export const a = <GenericComponent<TypeA> />;
+namespace Foo {
+  export const foo = 1;
+}
+export namespace Bar {
+  import TheFoo = Foo;
+}
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
+      errors: [
+        {
+          column: 10,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'TheFoo',
           },
+          line: 6,
+          messageId: 'unusedVar',
         },
-      },
+      ],
     },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/160
       code: `
-const text = 'text';
-export function Foo() {
-  return (
-    <div>
-      <input type="search" size={30} placeholder={text} />
-    </div>
-  );
-}
+const foo: number = 1;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
+      errors: [
+        {
+          column: 7,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
           },
+          endColumn: 10,
+          endLine: 2,
+          line: 2,
+          messageId: 'unusedVar',
         },
-      },
+      ],
     },
-    // https://github.com/eslint/typescript-eslint-parser/issues/535
-    `
-import { observable } from 'mobx';
-export default class ListModalStore {
-  @observable
-  orderList: IObservableArray<BizPurchaseOrderTO> = observable([]);
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/122#issuecomment-462008078
-    `
-import { Dec, TypeA, Class } from 'test';
-export default class Foo {
-  constructor(
-    @Dec(Class)
-    private readonly prop: TypeA<Class>,
-  ) {}
-}
-    `,
-    `
-import { Dec, TypeA, Class } from 'test';
-export default class Foo {
-  constructor(
-    @Dec(Class)
-    ...prop: TypeA<Class>
-  ) {
-    prop();
-  }
-}
-    `,
-    `
-export function foo(): void;
-export function foo(): void;
-export function foo(): void {}
-    `,
-    `
-export function foo(a: number): number;
-export function foo(a: string): string;
-export function foo(a: number | string): number | string {
-  return a;
-}
-    `,
-    `
-export function foo<T>(a: number): T;
-export function foo<T>(a: string): T;
-export function foo<T>(a: number | string): T {
-  return a;
-}
-    `,
-    `
-export type T = {
-  new (): T;
-  new (arg: number): T;
-  new <T>(arg: number): T;
-};
-    `,
-    `
-export type T = new () => T;
-export type T = new (arg: number) => T;
-export type T = new <T>(arg: number) => T;
-    `,
-    `
+    {
+      code: `
 enum Foo {
-  a,
-}
-export type T = {
-  [Foo.a]: 1;
-};
-    `,
-    `
-type Foo = string;
-export class Bar {
-  [x: Foo]: any;
-}
-    `,
-    `
-type Foo = string;
-export class Bar {
-  [x: Foo]: Foo;
-}
-    `,
-    `
-namespace Foo {
-  export const Foo = 1;
-}
-
-export { Foo };
-    `,
-    `
-export namespace Foo {
-  export const item: Foo = 1;
-}
-    `,
-    `
-namespace foo.bar {
-  export interface User {
-    name: string;
-  }
-}
-    `,
-    // exported self-referencing types
-    `
-export interface Foo {
-  bar: string;
-  baz: Foo['bar'];
-}
-    `,
-    `
-export type Bar = Array<Bar>;
-    `,
-    // declaration merging
-    `
-function Foo() {}
-
-namespace Foo {
-  export const x = 1;
-}
-
-export { Foo };
-    `,
-    `
-class Foo {}
-
-namespace Foo {
-  export const x = 1;
+  A = 1,
+  B = Foo.A,
 }
+      `,
+      errors: [
+        {
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'Foo',
+          },
+          line: 2,
+          messageId: 'unusedVar',
+        },
+      ],
+    },
 
-export { Foo };
-    `,
-    `
-namespace Foo {}
-
-const Foo = 1;
-
-export { Foo };
-    `,
-    `
-type Foo = {
-  error: Error | null;
-};
-
-export function foo() {
-  return new Promise<Foo>();
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/5152
-    `
-export function foo<T>(value: T): T {
-  return { value };
+    // reportUsedIgnorePattern
+    {
+      code: `
+type _Foo = 1;
+export const x: _Foo = 1;
+      `,
+      errors: [
+        {
+          data: {
+            additional: '. Used vars must not match /^_/u',
+            varName: '_Foo',
+          },
+          line: 2,
+          messageId: 'usedIgnoredVar',
+        },
+      ],
+      options: [{ reportUsedIgnorePattern: true, varsIgnorePattern: '^_' }],
+    },
+    {
+      code: `
+interface _Foo {}
+export const x: _Foo = 1;
+      `,
+      errors: [
+        {
+          data: {
+            additional: '. Used vars must not match /^_/u',
+            varName: '_Foo',
+          },
+          line: 2,
+          messageId: 'usedIgnoredVar',
+        },
+      ],
+      options: [{ reportUsedIgnorePattern: true, varsIgnorePattern: '^_' }],
+    },
+    {
+      code: `
+enum _Foo {
+  A = 1,
 }
-export type Foo<T> = typeof foo<T>;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2331
+export const x = _Foo.A;
+      `,
+      errors: [
+        {
+          data: {
+            additional: '. Used vars must not match /^_/u',
+            varName: '_Foo',
+          },
+          line: 2,
+          messageId: 'usedIgnoredVar',
+        },
+      ],
+      options: [{ reportUsedIgnorePattern: true, varsIgnorePattern: '^_' }],
+    },
     {
       code: `
-export interface Event<T> {
-  (
-    listener: (e: T) => any,
-    thisArgs?: any,
-    disposables?: Disposable[],
-  ): Disposable;
-}
+namespace _Foo {}
+export const x = _Foo;
       `,
-      options: [
+      errors: [
         {
-          args: 'after-used',
-          argsIgnorePattern: '^_',
-          ignoreRestSiblings: true,
-          varsIgnorePattern: '^_$',
+          data: {
+            additional: '. Used vars must not match /^_/u',
+            varName: '_Foo',
+          },
+          line: 2,
+          messageId: 'usedIgnoredVar',
         },
       ],
+      options: [{ reportUsedIgnorePattern: true, varsIgnorePattern: '^_' }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2369
-    `
-export class Test {
-  constructor(@Optional() value: number[] = []) {
-    console.log(value);
-  }
-}
-
-function Optional() {
-  return () => {};
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2417
-    `
-import { FooType } from './fileA';
-
-export abstract class Foo {
-  protected abstract readonly type: FooType;
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2449
-    `
-export type F<A extends unknown[]> = (...a: A) => unknown;
-    `,
-    `
-import { Foo } from './bar';
-export type F<A extends unknown[]> = (...a: Foo<A>) => unknown;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2452
-    `
-type StyledPaymentProps = {
-  isValid: boolean;
-};
+    {
+      code: `
+        const foo: number = 1;
 
-export const StyledPayment = styled.div<StyledPaymentProps>\`\`;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2453
-    `
-import type { foo } from './a';
-export type Bar = typeof foo;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2456
+        export type Foo = typeof foo;
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
+        },
+      ],
+    },
     {
       code: `
-interface Foo {}
-type Bar = {};
-declare class Clazz {}
-declare function func();
-declare enum Enum {}
-declare namespace Name {}
-declare const v1;
-declare var v2;
-declare let v3;
-declare const { v4 };
-declare const { v4: v5 };
-declare const [v6];
+        declare const foo: number;
+
+        export type Foo = typeof foo;
       `,
-      filename: 'foo.d.ts',
+      errors: [
+        {
+          column: 23,
+          data: {
+            action: 'defined',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 26,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
+        },
+      ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2459
-    `
-export type Test<U> = U extends (k: infer I) => void ? I : never;
-    `,
-    `
-export type Test<U> = U extends { [k: string]: infer I } ? I : never;
-    `,
-    `
-export type Test<U> = U extends (arg: {
-  [k: string]: (arg2: infer I) => void;
-}) => void
-  ? I
-  : never;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2455
     {
       code: `
-        import React from 'react';
+        const foo: number = 1;
 
-        export const ComponentFoo: React.FC = () => {
-          return <div>Foo Foo</div>;
-        };
+        export type Foo = typeof foo | string;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
           },
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
         },
-      },
+      ],
     },
     {
       code: `
-        import { h } from 'some-other-jsx-lib';
+        const foo: number = 1;
 
-        export const ComponentFoo: h.FC = () => {
-          return <div>Foo Foo</div>;
-        };
+        export type Foo = (typeof foo | string) & { __brand: 'foo' };
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
           },
-          jsxPragma: 'h',
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
         },
-      },
+      ],
     },
     {
       code: `
-        import { Fragment } from 'react';
+        const foo = {
+          bar: {
+            baz: 123,
+          },
+        };
 
-        export const ComponentFoo: Fragment = () => {
-          return <>Foo Foo</>;
+        export type Bar = typeof foo.bar;
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
+          },
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
+        },
+      ],
+    },
+    {
+      code: `
+        const foo = {
+          bar: {
+            baz: 123,
+          },
         };
+
+        export type Bar = (typeof foo)['bar'];
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
+      errors: [
+        {
+          column: 15,
+          data: {
+            action: 'assigned a value',
+            additional: '',
+            varName: 'foo',
           },
-          jsxFragmentName: 'Fragment',
+          endColumn: 18,
+          endLine: 2,
+          line: 2,
+          messageId: 'usedOnlyAsType',
         },
-      },
+      ],
     },
+  ],
+
+  valid: [
+    `
+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() {}
+}
+    `,
     `
-declare module 'foo' {
-  type Test = 1;
+import { AccessorDecorator } from 'decorators';
+export class Foo {
+  @AccessorDecorator
+  set bar() {}
 }
     `,
     `
-declare module 'foo' {
-  type Test = 1;
-  const x: Test = 1;
-  export = x;
+import { MethodDecoratorFactory } from 'decorators';
+export class Foo {
+  @MethodDecoratorFactory(false)
+  bar() {}
 }
     `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2523
     `
-declare global {
-  interface Foo {}
+import { MethodDecorator } from 'decorators';
+export class Foo {
+  @MethodDecorator
+  static bar() {}
 }
     `,
     `
-declare global {
-  namespace jest {
-    interface Matchers<R> {
-      toBeSeven: () => R;
-    }
+import { ConstructorParameterDecoratorFactory } from 'decorators';
+export class Service {
+  constructor(
+    @ConstructorParameterDecoratorFactory(APP_CONFIG) config: AppConfig,
+  ) {
+    this.title = config.title;
   }
 }
     `,
     `
-export declare namespace Foo {
-  namespace Bar {
-    namespace Baz {
-      namespace Bam {
-        const x = 1;
-      }
-    }
+import { ConstructorParameterDecorator } from 'decorators';
+export class Foo {
+  constructor(@ConstructorParameterDecorator bar) {
+    this.bar = bar;
   }
 }
     `,
     `
-class Foo<T> {
-  value: T;
-}
-class Bar<T> {
-  foo = Foo<T>;
+import { ParameterDecoratorFactory } from 'decorators';
+export class Qux {
+  bar(@ParameterDecoratorFactory(true) baz: number) {
+    console.log(baz);
+  }
 }
-new Bar();
     `,
-    {
-      code: `
-declare namespace A {
-  export interface A {}
-}
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-declare function A(A: string): string;
-      `,
-      filename: 'foo.d.ts',
-    },
-    // 4.1 template literal types
-    {
-      code: noFormat`
-type Color = 'red' | 'blue';
-type Quantity = 'one' | 'two';
-export type SeussFish = \`\${Quantity | Color} fish\`;
-      `,
-    },
-    {
-      code: noFormat`
-type VerticalAlignment = "top" | "middle" | "bottom";
-type HorizontalAlignment = "left" | "center" | "right";
-
-export declare function setAlignment(value: \`\${VerticalAlignment}-\${HorizontalAlignment}\`): void;
-      `,
-    },
-    {
-      code: noFormat`
-type EnthusiasticGreeting<T extends string> = \`\${Uppercase<T>} - \${Lowercase<T>} - \${Capitalize<T>} - \${Uncapitalize<T>}\`;
-export type HELLO = EnthusiasticGreeting<"heLLo">;
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2714
-    {
-      code: `
-interface IItem {
-  title: string;
-  url: string;
-  children?: IItem[];
-}
-      `,
-      // unreported because it's in a decl file, even though it's only self-referenced
-      filename: 'foo.d.ts',
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2648
-    {
-      code: `
-namespace _Foo {
-  export const bar = 1;
-  export const baz = Foo.bar;
-}
-      `,
-      // ignored by pattern, even though it's only self-referenced
-      options: [{ varsIgnorePattern: '^_' }],
-    },
-    {
-      code: `
-interface _Foo {
-  a: string;
-  b: Foo;
-}
-      `,
-      // ignored by pattern, even though it's only self-referenced
-      options: [{ varsIgnorePattern: '^_' }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2844
     `
-/* eslint @rule-tester/collect-unused-vars: "error" */
-declare module 'next-auth' {
-  interface User {
-    id: string;
-    givenName: string;
-    familyName: string;
+import { ParameterDecorator } from 'decorators';
+export class Foo {
+  static greet(@ParameterDecorator name: string) {
+    return name;
   }
 }
     `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2972
-    {
-      code: `
-import { TestGeneric, Test } from 'fake-module';
-
-declare function deco(..._param: any): any;
-export class TestClass {
-  @deco
-  public test(): TestGeneric<Test> {}
+    `
+import { Input, Output, EventEmitter } from 'decorators';
+export class SomeComponent {
+  @Input() data;
+  @Output()
+  click = new EventEmitter();
 }
-      `,
-      languageOptions: { parserOptions: withMetaParserOptions },
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/5577
+    `,
     `
-function foo() {}
+import { configurable } from 'decorators';
+export class A {
+  @configurable(true) static prop1;
 
-export class Foo {
-  constructor() {
-    foo();
-  }
+  @configurable(false)
+  static prop2;
 }
     `,
-    {
-      code: `
-function foo() {}
-
-export class Foo {
-  static {}
+    `
+import { foo, bar } from 'decorators';
+export class B {
+  @foo x;
 
-  constructor() {
-    foo();
-  }
+  @bar
+  y;
 }
-      `,
-    },
+    `,
     `
-interface Foo {
-  bar: string;
-}
-export const Foo = 'bar';
+interface Base {}
+class Thing implements Base {}
+new Thing();
     `,
     `
-export const Foo = 'bar';
-interface Foo {
-  bar: string;
-}
+interface Base {}
+const a: Base = {};
+console.log(a);
     `,
     `
-let foo = 1;
-foo ??= 2;
+import { Foo } from 'foo';
+function bar<T>(): T {}
+bar<Foo>();
     `,
     `
-let foo = 1;
-foo &&= 2;
+import { Foo } from 'foo';
+const bar = function <T>(): T {};
+bar<Foo>();
     `,
     `
-let foo = 1;
-foo ||= 2;
+import { Foo } from 'foo';
+const bar = <T,>(): T => {};
+bar<Foo>();
     `,
     `
-const foo = 1;
-export = foo;
+import { Foo } from 'foo';
+<Foo>(<T,>(): T => {})();
     `,
     `
-const Foo = 1;
-interface Foo {
-  bar: string;
-}
-export = Foo;
+import { Nullable } from 'nullable';
+const a: Nullable<string> = 'hello';
+console.log(a);
     `,
     `
-interface Foo {
-  bar: string;
-}
-export = Foo;
+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);
     `,
     `
-type Foo = 1;
-export = Foo;
+import { Nullable } from 'nullable';
+const a: Nullable[] = 'hello';
+console.log(a);
     `,
     `
-type Foo = 1;
-export = {} as Foo;
+import { Nullable } from 'nullable';
+const a: Array<Nullable[]> = 'hello';
+console.log(a);
     `,
     `
-declare module 'foo' {
-  type Foo = 1;
-  export = Foo;
-}
+import { Nullable } from 'nullable';
+const a: Array<Array<Nullable>> = 'hello';
+console.log(a);
     `,
     `
-namespace Foo {
-  export const foo = 1;
-}
-export namespace Bar {
-  export import TheFoo = Foo;
-}
+import { Nullable } from 'nullable';
+import { SomeOther } from 'other';
+const a: Array<Nullable<SomeOther>> = 'hello';
+console.log(a);
     `,
-    {
-      code: `
-type _Foo = 1;
-export const x: _Foo = 1;
-      `,
-      options: [{ varsIgnorePattern: '^_', reportUsedIgnorePattern: false }],
-    },
     `
-export const foo: number = 1;
+import { Nullable } from 'nullable';
+import { Component } from 'react';
+class Foo implements Component<Nullable> {}
 
-export type Foo = typeof foo;
+new Foo();
     `,
     `
-import { foo } from 'foo';
-
-export type Foo = typeof foo;
-
-export const bar = (): Foo => foo;
+import { Nullable } from 'nullable';
+import { Component } from 'react';
+class Foo extends Component<Nullable, {}> {}
+new Foo();
     `,
     `
-import { SomeType } from 'foo';
-
-export const value = 1234 as typeof SomeType;
+import { Nullable } from 'nullable';
+import { SomeOther } from 'some';
+import { Component } from 'react';
+class Foo extends Component<Nullable<SomeOther>, {}> {}
+new Foo();
     `,
     `
-import { foo } from 'foo';
-
-export type Bar = typeof foo;
-    `,
-  ],
-
-  invalid: [
-    {
-      code: `
-import { ClassDecoratorFactory } from 'decorators';
-export class Foo {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'ClassDecoratorFactory',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          endLine: 2,
-          column: 10,
-          endColumn: 31,
-        },
-      ],
-    },
-    {
-      code: `
-import { Foo, Bar } from 'foo';
-function baz<Foo>(): Foo {}
-baz<Bar>();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
 import { Nullable } from 'nullable';
-const a: string = 'hello';
-console.log(a);
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Nullable',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+import { SomeOther } from 'some';
+import { Component } from 'react';
+class Foo implements Component<Nullable<SomeOther>, {}> {}
+new Foo();
+    `,
+    `
 import { Nullable } from 'nullable';
-import { SomeOther } from 'other';
-const a: Nullable<string> = 'hello';
-console.log(a);
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'SomeOther',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-
-    {
-      code: `
+import { SomeOther } from 'some';
+import { Component, Component2 } from 'react';
+class Foo implements Component<Nullable<SomeOther>, {}>, Component2 {}
+new Foo();
+    `,
+    `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-  do = (a: Nullable) => {
+  do = (a: Nullable<Another>) => {
     console.log(a);
   };
 }
 new A();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Another',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-  do(a: Nullable) {
+  do(a: Nullable<Another>) {
     console.log(a);
   }
 }
 new A();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Another',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-  do(): Nullable {
+  do(): Nullable<Another> {
     return null;
   }
 }
 new A();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Another',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 export interface A {
-  do(a: Nullable);
+  do(a: Nullable<Another>);
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Another',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
-import { Another } from 'some';
-export interface A {
-  other: Nullable;
-}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Another',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+import { Another } from 'some';
+export interface A {
+  other: Nullable<Another>;
+}
+    `,
+    `
 import { Nullable } from 'nullable';
-function foo(a: string) {
+function foo(a: Nullable) {
   console.log(a);
 }
 foo();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Nullable',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
-function foo(): string | null {
+function foo(): Nullable {
   return null;
 }
 foo();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Nullable',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
-import { Another } from 'some';
-class A extends Nullable {
+class A extends Nullable<SomeOther> {
   other: Nullable<Another>;
 }
 new A();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'SomeOther',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
-abstract class A extends Nullable {
-  other: Nullable<Another>;
+class A extends Nullable<SomeOther> {
+  do(a: Nullable<Another>) {
+    console.log(a);
+  }
 }
 new A();
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'SomeOther',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 10,
-        },
-      ],
-    },
-    {
-      code: `
-enum FormFieldIds {
-  PHONE = 'phone',
-  EMAIL = 'email',
+    `,
+    `
+import { Nullable } from 'nullable';
+import { SomeOther } from 'some';
+import { Another } from 'some';
+export interface A extends Nullable<SomeOther> {
+  other: Nullable<Another>;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'FormFieldIds',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 6,
-        },
-      ],
-    },
-    {
-      code: `
-import test from 'test';
-import baz from 'baz';
-export interface Bar extends baz.test {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'test',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: `
-import test from 'test';
-import baz from 'baz';
-export interface Bar extends baz().test {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'test',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: `
-import test from 'test';
-import baz from 'baz';
-export class Bar implements baz.test {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'test',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: `
-import test from 'test';
-import baz from 'baz';
-export class Bar implements baz().test {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'test',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 8,
-        },
-      ],
-    },
-    {
-      code: `
-namespace Foo {}
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 11,
-        },
-      ],
-    },
-    {
-      code: `
-namespace Foo {
-  export const Foo = 1;
+    `,
+    `
+import { Nullable } from 'nullable';
+import { SomeOther } from 'some';
+import { Another } from 'some';
+export interface A extends Nullable<SomeOther> {
+  do(a: Nullable<Another>);
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 11,
-        },
-      ],
-    },
-    {
-      code: `
-namespace Foo {
-  const Foo = 1;
-  console.log(Foo);
+    `,
+    `
+import { Foo } from './types';
+
+class Bar<T extends Foo> {
+  prop: T;
+}
+
+new Bar<number>();
+    `,
+    `
+import { Foo, Bar } from './types';
+
+class Baz<T extends Foo & Bar> {
+  prop: T;
+}
+
+new Baz<any>();
+    `,
+    `
+import { Foo } from './types';
+
+class Bar<T = Foo> {
+  prop: T;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 11,
-        },
-      ],
-    },
-    {
-      code: `
-namespace Foo {
-  export const Bar = 1;
-  console.log(Foo.Bar);
+
+new Bar<number>();
+    `,
+    `
+import { Foo } from './types';
+
+class Foo<T = any> {
+  prop: T;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 11,
-        },
-      ],
-    },
-    {
-      code: `
-namespace Foo {
-  namespace Foo {
-    export const Bar = 1;
-    console.log(Foo.Bar);
-  }
+
+new Foo();
+    `,
+    `
+import { Foo } from './types';
+
+class Foo<T = {}> {
+  prop: T;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 11,
-        },
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 3,
-          column: 13,
-        },
-      ],
-    },
-    // self-referencing types
-    {
-      code: `
-interface Foo {
-  bar: string;
-  baz: Foo['bar'];
+
+new Foo();
+    `,
+    `
+import { Foo } from './types';
+
+class Foo<T extends {} = {}> {
+  prop: T;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 11,
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-type Foo = Array<Foo>;
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 6,
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2455
-    {
-      code: `
-import React from 'react';
-import { Fragment } from 'react';
 
-export const ComponentFoo = () => {
-  return <div>Foo Foo</div>;
-};
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 3,
-          column: 10,
-          data: {
-            varName: 'Fragment',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-import React from 'react';
-import { h } from 'some-other-jsx-lib';
+new Foo();
+    `,
+    `
+type Foo = 'a' | 'b' | 'c';
+type Bar = number;
 
-export const ComponentFoo = () => {
-  return <div>Foo Foo</div>;
+export const map: { [name in Foo]: Bar } = {
+  a: 1,
+  b: 2,
+  c: 3,
 };
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          jsxPragma: 'h',
-        },
-      },
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 8,
-          data: {
-            varName: 'React',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3303
-    {
-      code: `
-import React from 'react';
+    `,
+    // 4.1 remapped mapped type
+    `
+type Foo = 'a' | 'b' | 'c';
+type Bar = number;
 
-export const ComponentFoo = () => {
-  return <div>Foo Foo</div>;
+export const map: { [name in Foo as string]: Bar } = {
+  a: 1,
+  b: 2,
+  c: 3,
 };
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          jsxPragma: null,
-        },
-      },
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 8,
-          data: {
-            varName: 'React',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-declare module 'foo' {
-  type Test = any;
-  const x = 1;
-  export = x;
+    `,
+    `
+import { Nullable } from 'nullable';
+class A<T> {
+  bar: T;
+}
+new A<Nullable>();
+    `,
+    `
+import { Nullable } from 'nullable';
+import { SomeOther } from 'other';
+function foo<T extends Nullable>(): T {}
+foo<SomeOther>();
+    `,
+    `
+import { Nullable } from 'nullable';
+import { SomeOther } from 'other';
+class A<T extends Nullable> {
+  bar: T;
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 3,
-          column: 8,
-          endLine: 3,
-          endColumn: 12,
-          data: {
-            varName: 'Test',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-// not declared
-export namespace Foo {
-  namespace Bar {
-    namespace Baz {
-      namespace Bam {
-        const x = 1;
-      }
-    }
+new A<SomeOther>();
+    `,
+    `
+import { Nullable } from 'nullable';
+import { SomeOther } from 'other';
+interface A<T extends Nullable> {
+  bar: T;
+}
+export const a: A<SomeOther> = {
+  foo: 'bar',
+};
+    `,
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/150
+    `
+export class App {
+  constructor(private logger: Logger) {
+    console.log(this.logger);
   }
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 4,
-          column: 13,
-          data: {
-            varName: 'Bar',
-            action: 'defined',
-            additional: '',
-          },
-        },
-        {
-          messageId: 'unusedVar',
-          line: 5,
-          column: 15,
-          data: {
-            varName: 'Baz',
-            action: 'defined',
-            additional: '',
-          },
-        },
-        {
-          messageId: 'unusedVar',
-          line: 6,
-          column: 17,
-          data: {
-            varName: 'Bam',
-            action: 'defined',
-            additional: '',
-          },
-        },
-        {
-          messageId: 'unusedVar',
-          line: 7,
-          column: 15,
-          data: {
-            varName: 'x',
-            action: 'assigned a value',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-interface Foo {
-  a: string;
+    `,
+    `
+export class App {
+  constructor(bar: string);
+  constructor(private logger: Logger) {
+    console.log(this.logger);
+  }
 }
-interface Foo {
-  b: Foo;
+    `,
+    `
+export class App {
+  constructor(
+    baz: string,
+    private logger: Logger,
+  ) {
+    console.log(baz);
+    console.log(this.logger);
+  }
 }
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 11,
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-let x = null;
-x = foo(x);
-      `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 3,
-          column: 1,
-          endLine: 3,
-          endColumn: 2,
-          data: {
-            varName: 'x',
-            action: 'assigned a value',
-            additional: '',
+    `,
+    `
+export class App {
+  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);
+  }
+}
+    `,
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/126
+    `
+import { Component, Vue } from 'vue-property-decorator';
+import HelloWorld from './components/HelloWorld.vue';
+
+@Component({
+  components: {
+    HelloWorld,
+  },
+})
+export default class App extends Vue {}
+    `,
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/189
+    `
+import firebase, { User } from 'firebase/app';
+// initialize firebase project
+firebase.initializeApp({});
+export function authenticated(cb: (user: User | null) => void): void {
+  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> {
+  prop: T;
+}
+    `,
+    `
+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();
+}
+    `,
+    `
+import { Foo, Bar } from './types';
+export class Baz<F = Foo & Bar> {
+  prop: F;
+}
+    `,
+    `
+// warning 'B' is defined but never used
+export const a: Array<{ b: B }> = [];
+    `,
+    `
+export enum FormFieldIds {
+  PHONE = 'phone',
+  EMAIL = 'email',
+}
+    `,
+    `
+enum FormFieldIds {
+  PHONE = 'phone',
+  EMAIL = 'email',
+}
+export interface IFoo {
+  fieldName: FormFieldIds;
+}
+    `,
+    `
+enum FormFieldIds {
+  PHONE = 'phone',
+  EMAIL = 'email',
+}
+export interface IFoo {
+  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');
+    `,
+    // 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;
+}
+console.log(Foo);
+    `,
+    `
+import foo from 'foo';
+export interface Bar extends foo.i18n {}
+    `,
+    `
+import foo from 'foo';
+import bar from 'foo';
+export interface Bar extends foo.i18n<bar> {}
+    `,
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/141
+      code: `
+import { TypeA } from './interface';
+export const a = <GenericComponent<TypeA> />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
           },
         },
-      ],
+      },
     },
     {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/160
       code: `
-interface Foo {
-  bar: string;
+const text = 'text';
+export function Foo() {
+  return (
+    <div>
+      <input type="search" size={30} placeholder={text} />
+    </div>
+  );
 }
-const Foo = 'bar';
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 5,
-          column: 7,
-          data: {
-            varName: 'Foo',
-            action: 'assigned a value',
-            additional: '',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
           },
         },
-      ],
+      },
     },
+    // https://github.com/eslint/typescript-eslint-parser/issues/535
+    `
+import { observable } from 'mobx';
+export default class ListModalStore {
+  @observable
+  orderList: IObservableArray<BizPurchaseOrderTO> = observable([]);
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/122#issuecomment-462008078
+    `
+import { Dec, TypeA, Class } from 'test';
+export default class Foo {
+  constructor(
+    @Dec(Class)
+    private readonly prop: TypeA<Class>,
+  ) {}
+}
+    `,
+    `
+import { Dec, TypeA, Class } from 'test';
+export default class Foo {
+  constructor(
+    @Dec(Class)
+    ...prop: TypeA<Class>
+  ) {
+    prop();
+  }
+}
+    `,
+    `
+export function foo(): void;
+export function foo(): void;
+export function foo(): void {}
+    `,
+    `
+export function foo(a: number): number;
+export function foo(a: string): string;
+export function foo(a: number | string): number | string {
+  return a;
+}
+    `,
+    `
+export function foo<T>(a: number): T;
+export function foo<T>(a: string): T;
+export function foo<T>(a: number | string): T {
+  return a;
+}
+    `,
+    `
+export type T = {
+  new (): T;
+  new (arg: number): T;
+  new <T>(arg: number): T;
+};
+    `,
+    `
+export type T = new () => T;
+export type T = new (arg: number) => T;
+export type T = new <T>(arg: number) => T;
+    `,
+    `
+enum Foo {
+  a,
+}
+export type T = {
+  [Foo.a]: 1;
+};
+    `,
+    `
+type Foo = string;
+export class Bar {
+  [x: Foo]: any;
+}
+    `,
+    `
+type Foo = string;
+export class Bar {
+  [x: Foo]: Foo;
+}
+    `,
+    `
+namespace Foo {
+  export const Foo = 1;
+}
+
+export { Foo };
+    `,
+    `
+export namespace Foo {
+  export const item: Foo = 1;
+}
+    `,
+    `
+namespace foo.bar {
+  export interface User {
+    name: string;
+  }
+}
+    `,
+    // exported self-referencing types
+    `
+export interface Foo {
+  bar: string;
+  baz: Foo['bar'];
+}
+    `,
+    `
+export type Bar = Array<Bar>;
+    `,
+    // declaration merging
+    `
+function Foo() {}
+
+namespace Foo {
+  export const x = 1;
+}
+
+export { Foo };
+    `,
+    `
+class Foo {}
+
+namespace Foo {
+  export const x = 1;
+}
+
+export { Foo };
+    `,
+    `
+namespace Foo {}
+
+const Foo = 1;
+
+export { Foo };
+    `,
+    `
+type Foo = {
+  error: Error | null;
+};
+
+export function foo() {
+  return new Promise<Foo>();
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/5152
+    `
+export function foo<T>(value: T): T {
+  return { value };
+}
+export type Foo<T> = typeof foo<T>;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2331
     {
       code: `
-let foo = 1;
-foo += 1;
+export interface Event<T> {
+  (
+    listener: (e: T) => any,
+    thisArgs?: any,
+    disposables?: Disposable[],
+  ): Disposable;
+}
       `,
-      errors: [
+      options: [
         {
-          messageId: 'unusedVar',
-          line: 3,
-          column: 1,
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
+          args: 'after-used',
+          argsIgnorePattern: '^_',
+          ignoreRestSiblings: true,
+          varsIgnorePattern: '^_$',
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2369
+    `
+export class Test {
+  constructor(@Optional() value: number[] = []) {
+    console.log(value);
+  }
+}
+
+function Optional() {
+  return () => {};
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2417
+    `
+import { FooType } from './fileA';
+
+export abstract class Foo {
+  protected abstract readonly type: FooType;
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2449
+    `
+export type F<A extends unknown[]> = (...a: A) => unknown;
+    `,
+    `
+import { Foo } from './bar';
+export type F<A extends unknown[]> = (...a: Foo<A>) => unknown;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2452
+    `
+type StyledPaymentProps = {
+  isValid: boolean;
+};
+
+export const StyledPayment = styled.div<StyledPaymentProps>\`\`;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2453
+    `
+import type { foo } from './a';
+export type Bar = typeof foo;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2456
     {
       code: `
-interface Foo {
-  bar: string;
-}
-type Bar = 1;
-export = Bar;
+interface Foo {}
+type Bar = {};
+declare class Clazz {}
+declare function func();
+declare enum Enum {}
+declare namespace Name {}
+declare const v1;
+declare var v2;
+declare let v3;
+declare const { v4 };
+declare const { v4: v5 };
+declare const [v6];
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 2,
-          column: 11,
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-        },
-      ],
+      filename: 'foo.d.ts',
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2459
+    `
+export type Test<U> = U extends (k: infer I) => void ? I : never;
+    `,
+    `
+export type Test<U> = U extends { [k: string]: infer I } ? I : never;
+    `,
+    `
+export type Test<U> = U extends (arg: {
+  [k: string]: (arg2: infer I) => void;
+}) => void
+  ? I
+  : never;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2455
     {
       code: `
-interface Foo {
-  bar: string;
-}
-type Bar = 1;
-export = Foo;
+        import React from 'react';
+
+        export const ComponentFoo: React.FC = () => {
+          return <div>Foo Foo</div>;
+        };
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 5,
-          column: 6,
-          data: {
-            varName: 'Bar',
-            action: 'defined',
-            additional: '',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
           },
         },
-      ],
+      },
     },
     {
       code: `
-namespace Foo {
-  export const foo = 1;
-}
-export namespace Bar {
-  import TheFoo = Foo;
-}
+        import { h } from 'some-other-jsx-lib';
+
+        export const ComponentFoo: h.FC = () => {
+          return <div>Foo Foo</div>;
+        };
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          line: 6,
-          column: 10,
-          data: {
-            varName: 'TheFoo',
-            action: 'defined',
-            additional: '',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
           },
+          jsxPragma: 'h',
         },
-      ],
+      },
     },
     {
       code: `
-const foo: number = 1;
+        import { Fragment } from 'react';
+
+        export const ComponentFoo: Fragment = () => {
+          return <>Foo Foo</>;
+        };
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
           },
-          line: 2,
-          column: 7,
-          endLine: 2,
-          endColumn: 10,
+          jsxFragmentName: 'Fragment',
         },
-      ],
+      },
     },
+    `
+declare module 'foo' {
+  type Test = 1;
+}
+    `,
+    `
+declare module 'foo' {
+  type Test = 1;
+  const x: Test = 1;
+  export = x;
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2523
+    `
+declare global {
+  interface Foo {}
+}
+    `,
+    `
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      toBeSeven: () => R;
+    }
+  }
+}
+    `,
+    `
+export declare namespace Foo {
+  namespace Bar {
+    namespace Baz {
+      namespace Bam {
+        const x = 1;
+      }
+    }
+  }
+}
+    `,
+    `
+class Foo<T> {
+  value: T;
+}
+class Bar<T> {
+  foo = Foo<T>;
+}
+new Bar();
+    `,
     {
       code: `
-enum Foo {
-  A = 1,
-  B = Foo.A,
+declare namespace A {
+  export interface A {}
 }
       `,
-      errors: [
-        {
-          messageId: 'unusedVar',
-          data: {
-            varName: 'Foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-        },
-      ],
+      filename: 'foo.d.ts',
     },
-
-    // reportUsedIgnorePattern
     {
       code: `
-type _Foo = 1;
-export const x: _Foo = 1;
+declare function A(A: string): string;
       `,
-      options: [{ varsIgnorePattern: '^_', reportUsedIgnorePattern: true }],
-      errors: [
-        {
-          messageId: 'usedIgnoredVar',
-          data: {
-            varName: '_Foo',
-            additional: '. Used vars must not match /^_/u',
-          },
-          line: 2,
-        },
-      ],
+      filename: 'foo.d.ts',
     },
+    // 4.1 template literal types
     {
-      code: `
-interface _Foo {}
-export const x: _Foo = 1;
+      code: noFormat`
+type Color = 'red' | 'blue';
+type Quantity = 'one' | 'two';
+export type SeussFish = \`\${Quantity | Color} fish\`;
       `,
-      options: [{ varsIgnorePattern: '^_', reportUsedIgnorePattern: true }],
-      errors: [
-        {
-          messageId: 'usedIgnoredVar',
-          data: {
-            varName: '_Foo',
-            additional: '. Used vars must not match /^_/u',
-          },
-          line: 2,
-        },
-      ],
     },
     {
-      code: `
-enum _Foo {
-  A = 1,
-}
-export const x = _Foo.A;
+      code: noFormat`
+type VerticalAlignment = "top" | "middle" | "bottom";
+type HorizontalAlignment = "left" | "center" | "right";
+
+export declare function setAlignment(value: \`\${VerticalAlignment}-\${HorizontalAlignment}\`): void;
       `,
-      options: [{ varsIgnorePattern: '^_', reportUsedIgnorePattern: true }],
-      errors: [
-        {
-          messageId: 'usedIgnoredVar',
-          data: {
-            varName: '_Foo',
-            additional: '. Used vars must not match /^_/u',
-          },
-          line: 2,
-        },
-      ],
     },
     {
-      code: `
-namespace _Foo {}
-export const x = _Foo;
-      `,
-      options: [{ varsIgnorePattern: '^_', reportUsedIgnorePattern: true }],
-      errors: [
-        {
-          messageId: 'usedIgnoredVar',
-          data: {
-            varName: '_Foo',
-            additional: '. Used vars must not match /^_/u',
-          },
-          line: 2,
-        },
-      ],
+      code: noFormat`
+type EnthusiasticGreeting<T extends string> = \`\${Uppercase<T>} - \${Lowercase<T>} - \${Capitalize<T>} - \${Uncapitalize<T>}\`;
+export type HELLO = EnthusiasticGreeting<"heLLo">;
+      `,
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2714
     {
       code: `
-        const foo: number = 1;
-
-        export type Foo = typeof foo;
+interface IItem {
+  title: string;
+  url: string;
+  children?: IItem[];
+}
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
-          line: 2,
-          column: 15,
-          endLine: 2,
-          endColumn: 18,
-        },
-      ],
+      // unreported because it's in a decl file, even though it's only self-referenced
+      filename: 'foo.d.ts',
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2648
     {
       code: `
-        declare const foo: number;
-
-        export type Foo = typeof foo;
+namespace _Foo {
+  export const bar = 1;
+  export const baz = Foo.bar;
+}
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'defined',
-            additional: '',
-          },
-          line: 2,
-          column: 23,
-          endLine: 2,
-          endColumn: 26,
-        },
-      ],
+      // ignored by pattern, even though it's only self-referenced
+      options: [{ varsIgnorePattern: '^_' }],
     },
     {
       code: `
-        const foo: number = 1;
-
-        export type Foo = typeof foo | string;
+interface _Foo {
+  a: string;
+  b: Foo;
+}
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
-          line: 2,
-          column: 15,
-          endLine: 2,
-          endColumn: 18,
-        },
-      ],
+      // ignored by pattern, even though it's only self-referenced
+      options: [{ varsIgnorePattern: '^_' }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2844
+    `
+/* eslint @rule-tester/collect-unused-vars: "error" */
+declare module 'next-auth' {
+  interface User {
+    id: string;
+    givenName: string;
+    familyName: string;
+  }
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2972
     {
       code: `
-        const foo: number = 1;
+import { TestGeneric, Test } from 'fake-module';
 
-        export type Foo = (typeof foo | string) & { __brand: 'foo' };
+declare function deco(..._param: any): any;
+export class TestClass {
+  @deco
+  public test(): TestGeneric<Test> {}
+}
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
-          line: 2,
-          column: 15,
-          endLine: 2,
-          endColumn: 18,
-        },
-      ],
+      languageOptions: { parserOptions: withMetaParserOptions },
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/5577
+    `
+function foo() {}
+
+export class Foo {
+  constructor() {
+    foo();
+  }
+}
+    `,
     {
       code: `
-        const foo = {
-          bar: {
-            baz: 123,
-          },
-        };
+function foo() {}
 
-        export type Bar = typeof foo.bar;
+export class Foo {
+  static {}
+
+  constructor() {
+    foo();
+  }
+}
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
-          line: 2,
-          column: 15,
-          endLine: 2,
-          endColumn: 18,
-        },
-      ],
     },
+    `
+interface Foo {
+  bar: string;
+}
+export const Foo = 'bar';
+    `,
+    `
+export const Foo = 'bar';
+interface Foo {
+  bar: string;
+}
+    `,
+    `
+let foo = 1;
+foo ??= 2;
+    `,
+    `
+let foo = 1;
+foo &&= 2;
+    `,
+    `
+let foo = 1;
+foo ||= 2;
+    `,
+    `
+const foo = 1;
+export = foo;
+    `,
+    `
+const Foo = 1;
+interface Foo {
+  bar: string;
+}
+export = Foo;
+    `,
+    `
+interface Foo {
+  bar: string;
+}
+export = Foo;
+    `,
+    `
+type Foo = 1;
+export = Foo;
+    `,
+    `
+type Foo = 1;
+export = {} as Foo;
+    `,
+    `
+declare module 'foo' {
+  type Foo = 1;
+  export = Foo;
+}
+    `,
+    `
+namespace Foo {
+  export const foo = 1;
+}
+export namespace Bar {
+  export import TheFoo = Foo;
+}
+    `,
     {
       code: `
-        const foo = {
-          bar: {
-            baz: 123,
-          },
-        };
-
-        export type Bar = (typeof foo)['bar'];
+type _Foo = 1;
+export const x: _Foo = 1;
       `,
-      errors: [
-        {
-          messageId: 'usedOnlyAsType',
-          data: {
-            varName: 'foo',
-            action: 'assigned a value',
-            additional: '',
-          },
-          line: 2,
-          column: 15,
-          endLine: 2,
-          endColumn: 18,
-        },
-      ],
+      options: [{ reportUsedIgnorePattern: false, varsIgnorePattern: '^_' }],
     },
+    `
+export const foo: number = 1;
+
+export type Foo = typeof foo;
+    `,
+    `
+import { foo } from 'foo';
+
+export type Foo = typeof foo;
+
+export const bar = (): Foo => foo;
+    `,
+    `
+import { SomeType } from 'foo';
+
+export const value = 1234 as typeof SomeType;
+    `,
+    `
+import { foo } from 'foo';
+
+export type Bar = typeof foo;
+    `,
   ],
 });
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 c1e0f29bbb31..ff60637746e2 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
@@ -8,1084 +8,1152 @@ const ruleTester = new RuleTester();
 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;
-    `,
-    `
-interface Foo {}
-const x: Foo = {};
-    `,
-    `
-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() {};
-}
-f()?.();
-    `,
-    `
-var a = { b: 5 };
-alert(a?.b);
-    `,
+  invalid: [
     {
       code: `
-a();
-function a() {
-  alert(arguments);
-}
+a++;
+var a = 19;
       `,
-      options: ['nofunc'],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: {
+        parserOptions: { sourceType: 'module' },
+      },
     },
     {
       code: `
-(() => {
-  var a = 42;
-  alert(a);
-})();
+a++;
+var a = 19;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
-    `
-a();
-try {
-  throw new Error();
-} catch (a) {}
-    `,
     {
       code: `
-class A {}
-new A();
+a++;
+var a = 19;
       `,
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
-    `
-var a = 0,
-  b = a;
-    `,
-    { code: 'var { a = 0, b = a } = {};', languageOptions: { parserOptions } },
-    { code: 'var [a = 0, b = a] = {};', languageOptions: { parserOptions } },
-    `
-function foo() {
-  foo();
-}
-    `,
-    `
-var foo = function () {
-  foo();
-};
-    `,
-    `
-var a;
-for (a in a) {
-}
-    `,
     {
       code: `
-var a;
-for (a of a) {
-}
+a();
+var a = function () {};
       `,
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
-
-    // Block-level bindings
     {
       code: `
-'use strict';
-a();
-{
-  function a() {}
-}
+alert(a[1]);
+var a = [1, 3];
       `,
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-'use strict';
-{
+a();
+function a() {
+  alert(b);
+  var b = 10;
   a();
-  function a() {}
 }
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
+    {
+      code: `
+a();
+var a = function () {};
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       options: ['nofunc'],
-      languageOptions: { parserOptions },
     },
     {
       code: `
-switch (foo) {
-  case 1: {
-    a();
-  }
-  default: {
-    let a;
-  }
-}
+(() => {
+  alert(a);
+  var a = 42;
+})();
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-a();
-{
-  let a = function () {};
-}
+(() => a())();
+function a() {}
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
-
-    // object style options
     {
       code: `
 a();
-function a() {
-  alert(arguments);
+try {
+  throw new Error();
+} catch (foo) {
+  var a;
 }
       `,
-      options: [{ functions: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-'use strict';
-{
-  a();
-  function a() {}
-}
+var f = () => a;
+var a;
       `,
-      options: [{ functions: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-function foo() {
-  new A();
-}
+new A();
 class A {}
       `,
-      options: [{ classes: false }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
-
-    // "variables" option
     {
       code: `
 function foo() {
-  bar;
+  new A();
 }
-var bar;
-      `,
-      options: [{ variables: false }],
-    },
-    {
-      code: `
-var foo = () => bar;
-var bar;
+class A {}
       `,
-      options: [{ variables: false }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
-
-    // "typedefs" option
     {
       code: `
-var x: Foo = 2;
-type Foo = string | number;
+new A();
+var A = class {};
       `,
-      options: [{ typedefs: false }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2572
     {
       code: `
-interface Bar {
-  type: typeof Foo;
+function foo() {
+  new A();
 }
-
-const Foo = 2;
+var A = class {};
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-    {
-      code: `
-interface Bar {
-  type: typeof Foo.FOO;
-}
 
-class Foo {
-  public static readonly FOO = '';
-}
-      `,
-      options: [{ ignoreTypeReferences: true }],
-    },
+    // Block-level bindings
     {
       code: `
-interface Bar {
-  type: typeof Foo.Bar.Baz;
+a++;
+{
+  var a;
 }
-
-const Foo = {
-  Bar: {
-    Baz: 1,
-  },
-};
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/141
     {
       code: `
-interface ITest {
-  first: boolean;
-  second: string;
-  third: boolean;
-}
-
-let first = () => console.log('first');
-
-export let second = () => console.log('second');
-
-export namespace Third {
-  export let third = () => console.log('third');
+'use strict';
+{
+  a();
+  function a() {}
 }
       `,
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-    // 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;
-}
-    `,
-    // https://github.com/eslint/typescript-eslint-parser/issues/435
-    `
-interface Foo {
-  bar: string;
-}
-const bar = 'blah';
-    `,
     {
       code: `
-function foo(): Foo {
-  return Foo.FOO;
-}
-
-enum Foo {
-  FOO,
+{
+  a;
+  let a = 1;
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-let foo: Foo;
-
-enum Foo {
-  FOO,
+switch (foo) {
+  case 1:
+    a();
+  default:
+    let a;
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-class Test {
-  foo(args: Foo): Foo {
-    return Foo.FOO;
+if (true) {
+  function foo() {
+    a;
   }
-}
-
-enum Foo {
-  FOO,
+  let a;
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
 
-    // "allowNamedExports" option
+    // object style options
     {
       code: `
-export { a };
-const a = 1;
+a();
+var a = function () {};
       `,
-      options: [{ allowNamedExports: true }],
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ classes: false, functions: false }],
     },
     {
       code: `
-export { a as b };
-const a = 1;
+new A();
+var A = class {};
       `,
-      options: [{ allowNamedExports: true }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
+      options: [{ classes: false }],
     },
     {
       code: `
-export { a, b };
-let a, b;
+function foo() {
+  new A();
+}
+var A = class {};
       `,
-      options: [{ allowNamedExports: true }],
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
+      options: [{ classes: false }],
     },
+
+    // invalid initializers
     {
-      code: `
-export { a };
-var a;
-      `,
-      options: [{ allowNamedExports: true }],
-      languageOptions: { parserOptions },
+      code: 'var a = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
-      code: `
-export { f };
-function f() {}
-      `,
-      options: [{ allowNamedExports: true }],
+      code: 'let a = a + b;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
-      code: `
-export { C };
-class C {}
-      `,
-      options: [{ allowNamedExports: true }],
+      code: 'const a = foo(a);',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'function foo(a = a) {}',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { a = a } = [];',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [a = a] = [];',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { b = a, a } = {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [b = a, a] = {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { a = 0 } = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [a = 0] = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-export { Foo };
-
-enum Foo {
-  BAR,
+for (var a in a) {
 }
       `,
-      options: [{ allowNamedExports: true }],
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
     {
       code: `
-export { Foo };
-
-namespace Foo {
-  export let bar = () => console.log('bar');
+for (var a of a) {
 }
       `,
-      options: [{ allowNamedExports: true }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
+
+    // "ignoreTypeReferences" option
     {
       code: `
-export { Foo, baz };
-
-enum Foo {
-  BAR,
+interface Bar {
+  type: typeof Foo;
 }
 
-let baz: Enum;
-enum Enum {}
+const Foo = 2;
       `,
-      options: [{ allowNamedExports: true }],
-      languageOptions: { parserOptions },
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2502
     {
       code: `
-import * as React from 'react';
+interface Bar {
+  type: typeof Foo.FOO;
+}
 
-<div />;
+class Foo {
+  public static readonly FOO = '';
+}
       `,
-      languageOptions: {
-        parserOptions: {
-          sourceType: 'module',
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
-      },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
-import React from 'react';
+interface Bar {
+  type: typeof Foo.Bar.Baz;
+}
 
-<div />;
+const Foo = {
+  Bar: {
+    Baz: 1,
+  },
+};
       `,
-      languageOptions: {
-        parserOptions: {
-          sourceType: 'module',
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
-      },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
-import { h } from 'preact';
+const foo = {
+  bar: 'bar',
+} satisfies {
+  bar: typeof baz;
+};
 
-<div />;
+const baz = '';
       `,
-      languageOptions: {
-        parserOptions: {
-          sourceType: 'module',
-          jsxPragma: 'h',
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          data: { name: 'baz' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
-      },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
+
+    // "variables" option
     {
       code: `
-const React = require('react');
-
-<div />;
+function foo() {
+  bar;
+  var bar = 1;
+}
+var bar;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          data: { name: 'bar' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
-      },
+      ],
+      languageOptions: { parserOptions },
+      options: [{ variables: false }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2527
-    `
-type T = (value: unknown) => value is Id;
-    `,
-    `
-global.foo = true;
-
-declare global {
-  namespace NodeJS {
-    interface Global {
-      foo?: boolean;
-    }
+    {
+      code: `
+class Test {
+  foo(args: Foo): Foo {
+    return Foo.FOO;
   }
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2824
-    `
-@Directive({
-  selector: '[rcCidrIpPattern]',
-  providers: [
-    {
-      provide: NG_VALIDATORS,
-      useExisting: CidrIpPatternDirective,
-      multi: true,
+
+enum Foo {
+  FOO,
+}
+      `,
+      errors: [
+        {
+          data: { name: 'Foo' },
+          line: 4,
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      options: [{ enums: true }],
     },
-  ],
-})
-export class CidrIpPatternDirective implements Validator {}
-    `,
     {
       code: `
-@Directive({
-  selector: '[rcCidrIpPattern]',
-  providers: [
-    {
-      provide: NG_VALIDATORS,
-      useExisting: CidrIpPatternDirective,
-      multi: true,
-    },
-  ],
-})
-export class CidrIpPatternDirective implements Validator {}
+function foo(): Foo {
+  return Foo.FOO;
+}
+
+enum Foo {
+  FOO,
+}
       `,
-      options: [
+      errors: [
         {
-          classes: false,
+          data: { name: 'Foo' },
+          line: 3,
+          messageId: 'noUseBeforeDefine',
         },
       ],
+      options: [{ enums: true }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2941
-    `
-class A {
-  constructor(printName) {
-    this.printName = printName;
-  }
-
-  openPort(printerName = this.printerName) {
-    this.tscOcx.ActiveXopenport(printerName);
+    {
+      code: `
+const foo = Foo.Foo;
 
-    return this;
-  }
+enum Foo {
+  FOO,
 }
-    `,
+      `,
+      errors: [
+        {
+          data: { name: 'Foo' },
+          line: 2,
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      options: [{ enums: true }],
+    },
+    // "allowNamedExports" option
     {
       code: `
-const obj = {
-  foo: 'foo-value',
-  bar: 'bar-value',
-} satisfies {
-  [key in 'foo' | 'bar']: \`\${key}-value\`;
-};
+export { a };
+const a = 1;
       `,
-      options: [{ ignoreTypeReferences: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-const obj = {
-  foo: 'foo-value',
-  bar: 'bar-value',
-} as {
-  [key in 'foo' | 'bar']: \`\${key}-value\`;
-};
+export { a };
+const a = 1;
       `,
-      options: [{ ignoreTypeReferences: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [{}],
     },
     {
       code: `
-const obj = {
-  foo: {
-    foo: 'foo',
-  } as {
-    [key in 'foo' | 'bar']: key;
-  },
-};
+export { a };
+const a = 1;
       `,
-      options: [{ ignoreTypeReferences: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: false }],
+    },
+    {
+      code: `
+export { a };
+const a = 1;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: ['nofunc'],
     },
     {
       code: `
-const foo = {
-  bar: 'bar',
-} satisfies {
-  bar: typeof baz;
-};
-
-const baz = '';
+export { a as b };
+const a = 1;
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-  ],
-  invalid: [
     {
       code: `
-a++;
-var a = 19;
+export { a, b };
+let a, b;
       `,
-      languageOptions: {
-        parserOptions: { sourceType: 'module' },
-      },
       errors: [
         {
-          messageId: 'noUseBeforeDefine',
           data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
+          messageId: 'noUseBeforeDefine',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'noUseBeforeDefine',
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-a++;
-var a = 19;
+export { a };
+var a;
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
-          messageId: 'noUseBeforeDefine',
           data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
+          messageId: 'noUseBeforeDefine',
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-a++;
-var a = 19;
+export { f };
+function f() {}
       `,
       errors: [
         {
+          data: { name: 'f' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-a();
-var a = function () {};
+export { C };
+class C {}
       `,
       errors: [
         {
+          data: { name: 'C' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-alert(a[1]);
-var a = [1, 3];
+export const foo = a;
+const a = 1;
       `,
       errors: [
         {
-          messageId: 'noUseBeforeDefine',
           data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
+          messageId: 'noUseBeforeDefine',
         },
       ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-a();
-function a() {
-  alert(b);
-  var b = 10;
-  a();
+export function foo() {
+  return a;
 }
+const a = 1;
       `,
       errors: [
         {
-          messageId: 'noUseBeforeDefine',
           data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-        {
           messageId: 'noUseBeforeDefine',
-          data: { name: 'b' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-a();
-var a = function () {};
+export class C {
+  foo() {
+    return a;
+  }
+}
+const a = 1;
       `,
-      options: ['nofunc'],
       errors: [
         {
-          messageId: 'noUseBeforeDefine',
           data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
+          messageId: 'noUseBeforeDefine',
         },
       ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-(() => {
-  alert(a);
-  var a = 42;
-})();
+export { Foo };
+
+enum Foo {
+  BAR,
+}
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'Foo' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-(() => a())();
-function a() {}
+export { Foo };
+
+namespace Foo {
+  export let bar = () => console.log('bar');
+}
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'Foo' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-a();
-try {
-  throw new Error();
-} catch (foo) {
-  var a;
+export { Foo, baz };
+
+enum Foo {
+  BAR,
 }
+
+let baz: Enum;
+enum Enum {}
       `,
       errors: [
         {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+        },
+        {
+          data: { name: 'baz' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: false, ignoreTypeReferences: true }],
     },
     {
       code: `
-var f = () => a;
-var a;
+f();
+function f() {}
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'f' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-new A();
-class A {}
+alert(a);
+var a = 10;
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-function foo() {
-  new A();
+f()?.();
+function f() {
+  return function t() {};
 }
-class A {}
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'f' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-new A();
-var A = class {};
+alert(a?.b);
+var a = { b: 5 };
       `,
-      languageOptions: { parserOptions },
       errors: [
         {
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
+  ],
+  valid: [
+    `
+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);
+}
+    `,
+    'Object.hasOwnProperty.call(a);',
+    `
+function a() {
+  alert(arguments);
+}
+    `,
+    'declare function a();',
+    `
+declare class a {
+  foo();
+}
+    `,
+    'const updatedAt = data?.updatedAt;',
+    `
+function f() {
+  return function t() {};
+}
+f()?.();
+    `,
+    `
+var a = { b: 5 };
+alert(a?.b);
+    `,
     {
       code: `
-function foo() {
-  new A();
+a();
+function a() {
+  alert(arguments);
 }
-var A = class {};
+      `,
+      options: ['nofunc'],
+    },
+    {
+      code: `
+(() => {
+  var a = 42;
+  alert(a);
+})();
+      `,
+      languageOptions: { parserOptions },
+    },
+    `
+a();
+try {
+  throw new Error();
+} catch (a) {}
+    `,
+    {
+      code: `
+class A {}
+new A();
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
-
-    // Block-level bindings
+    `
+var a = 0,
+  b = a;
+    `,
+    { code: 'var { a = 0, b = a } = {};', languageOptions: { parserOptions } },
+    { code: 'var [a = 0, b = a] = {};', languageOptions: { parserOptions } },
+    `
+function foo() {
+  foo();
+}
+    `,
+    `
+var foo = function () {
+  foo();
+};
+    `,
+    `
+var a;
+for (a in a) {
+}
+    `,
     {
       code: `
-a++;
-{
-  var a;
+var a;
+for (a of a) {
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
+
+    // Block-level bindings
     {
       code: `
 'use strict';
+a();
 {
-  a();
   function a() {}
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
+'use strict';
 {
-  a;
-  let a = 1;
+  a();
+  function a() {}
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: ['nofunc'],
     },
     {
       code: `
 switch (foo) {
-  case 1:
+  case 1: {
     a();
-  default:
+  }
+  default: {
     let a;
+  }
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
     {
       code: `
-if (true) {
-  function foo() {
-    a;
-  }
-  let a;
+a();
+{
+  let a = function () {};
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
     },
 
     // object style options
     {
       code: `
 a();
-var a = function () {};
+function a() {
+  alert(arguments);
+}
       `,
-      options: [{ functions: false, classes: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ functions: false }],
     },
     {
       code: `
-new A();
-var A = class {};
+'use strict';
+{
+  a();
+  function a() {}
+}
       `,
-      options: [{ classes: false }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ functions: false }],
     },
     {
       code: `
 function foo() {
   new A();
 }
-var A = class {};
+class A {}
       `,
-      options: [{ classes: false }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'A' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ classes: false }],
     },
 
-    // invalid initializers
-    {
-      code: 'var a = a;',
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'let a = a + b;',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'const a = foo(a);',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'function foo(a = a) {}',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var { a = a } = [];',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var [a = a] = [];',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var { b = a, a } = {};',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var [b = a, a] = {};',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var { a = 0 } = a;',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: 'var [a = 0] = a;',
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
+    // "variables" option
     {
       code: `
-for (var a in a) {
+function foo() {
+  bar;
 }
+var bar;
       `,
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ variables: false }],
     },
     {
       code: `
-for (var a of a) {
-}
+var foo = () => bar;
+var bar;
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ variables: false }],
     },
 
-    // "ignoreTypeReferences" option
+    // "typedefs" option
+    {
+      code: `
+var x: Foo = 2;
+type Foo = string | number;
+      `,
+      options: [{ typedefs: false }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2572
     {
       code: `
 interface Bar {
@@ -1094,14 +1162,7 @@ interface Bar {
 
 const Foo = 2;
       `,
-      options: [{ ignoreTypeReferences: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreTypeReferences: true }],
     },
     {
       code: `
@@ -1113,14 +1174,7 @@ class Foo {
   public static readonly FOO = '';
 }
       `,
-      options: [{ ignoreTypeReferences: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreTypeReferences: true }],
     },
     {
       code: `
@@ -1134,111 +1188,81 @@ const Foo = {
   },
 };
       `,
-      options: [{ ignoreTypeReferences: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ ignoreTypeReferences: true }],
     },
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/141
     {
       code: `
-const foo = {
-  bar: 'bar',
-} satisfies {
-  bar: typeof baz;
-};
+interface ITest {
+  first: boolean;
+  second: string;
+  third: boolean;
+}
 
-const baz = '';
-      `,
-      options: [{ ignoreTypeReferences: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'baz' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
+let first = () => console.log('first');
 
-    // "variables" option
-    {
-      code: `
-function foo() {
-  bar;
-  var bar = 1;
+export let second = () => console.log('second');
+
+export namespace Third {
+  export let third = () => console.log('third');
 }
-var bar;
       `,
-      languageOptions: { parserOptions },
-      options: [{ variables: false }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'bar' },
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: {
+        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;
+}
+    `,
+    // https://github.com/eslint/typescript-eslint-parser/issues/435
+    `
+interface Foo {
+  bar: string;
+}
+const bar = 'blah';
+    `,
     {
       code: `
-class Test {
-  foo(args: Foo): Foo {
-    return Foo.FOO;
-  }
+function foo(): Foo {
+  return Foo.FOO;
 }
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: true }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          line: 4,
-        },
-      ],
+      options: [{ enums: false }],
     },
     {
       code: `
-function foo(): Foo {
-  return Foo.FOO;
-}
+let foo: Foo;
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: true }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          line: 3,
-        },
-      ],
+      options: [{ enums: false }],
     },
     {
       code: `
-const foo = Foo.Foo;
+class Test {
+  foo(args: Foo): Foo {
+    return Foo.FOO;
+  }
+}
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: true }],
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-          line: 2,
-        },
-      ],
+      options: [{ enums: false }],
     },
+
     // "allowNamedExports" option
     {
       code: `
@@ -1246,171 +1270,47 @@ export { a };
 const a = 1;
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
-    },
-    {
-      code: `
-export { a };
-const a = 1;
-      `,
-      options: [{}],
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
-    },
-    {
-      code: `
-export { a };
-const a = 1;
-      `,
-      options: [{ allowNamedExports: false }],
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
-    },
-    {
-      code: `
-export { a };
-const a = 1;
-      `,
-      options: ['nofunc'],
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
 export { a as b };
-const a = 1;
-      `,
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
-    },
-    {
-      code: `
-export { a, b };
-let a, b;
-      `,
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'b' },
-        },
-      ],
-    },
-    {
-      code: `
-export { a };
-var a;
-      `,
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
-    },
-    {
-      code: `
-export { f };
-function f() {}
-      `,
-      languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'f' },
-        },
-      ],
+const a = 1;
+      `,
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { C };
-class C {}
+export { a, b };
+let a, b;
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'C' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export const foo = a;
-const a = 1;
+export { a };
+var a;
       `,
-      options: [{ allowNamedExports: true }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export function foo() {
-  return a;
-}
-const a = 1;
+export { f };
+function f() {}
       `,
-      options: [{ allowNamedExports: true }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export class C {
-  foo() {
-    return a;
-  }
-}
-const a = 1;
+export { C };
+class C {}
       `,
-      options: [{ allowNamedExports: true }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
@@ -1421,12 +1321,7 @@ enum Foo {
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
@@ -1437,12 +1332,7 @@ namespace Foo {
 }
       `,
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-        },
-      ],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
@@ -1455,68 +1345,178 @@ enum Foo {
 let baz: Enum;
 enum Enum {}
       `,
-      options: [{ ignoreTypeReferences: true, allowNamedExports: false }],
       languageOptions: { parserOptions },
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'Foo' },
-        },
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'baz' },
+      options: [{ allowNamedExports: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2502
+    {
+      code: `
+import * as React from 'react';
+
+<div />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          sourceType: 'module',
         },
-      ],
+      },
     },
     {
       code: `
-f();
-function f() {}
+import React from 'react';
+
+<div />;
       `,
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'f' },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          sourceType: 'module',
         },
-      ],
+      },
     },
     {
       code: `
-alert(a);
-var a = 10;
+import { h } from 'preact';
+
+<div />;
       `,
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: 'h',
+          sourceType: 'module',
         },
-      ],
+      },
     },
     {
       code: `
-f()?.();
-function f() {
-  return function t() {};
-}
+const React = require('react');
+
+<div />;
       `,
-      errors: [
-        {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'f' },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
+      },
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2527
+    `
+type T = (value: unknown) => value is Id;
+    `,
+    `
+global.foo = true;
+
+declare global {
+  namespace NodeJS {
+    interface Global {
+      foo?: boolean;
+    }
+  }
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2824
+    `
+@Directive({
+  selector: '[rcCidrIpPattern]',
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      useExisting: CidrIpPatternDirective,
+      multi: true,
     },
+  ],
+})
+export class CidrIpPatternDirective implements Validator {}
+    `,
     {
       code: `
-alert(a?.b);
-var a = { b: 5 };
+@Directive({
+  selector: '[rcCidrIpPattern]',
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      useExisting: CidrIpPatternDirective,
+      multi: true,
+    },
+  ],
+})
+export class CidrIpPatternDirective implements Validator {}
       `,
-      errors: [
+      options: [
         {
-          messageId: 'noUseBeforeDefine',
-          data: { name: 'a' },
+          classes: false,
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2941
+    `
+class A {
+  constructor(printName) {
+    this.printName = printName;
+  }
+
+  openPort(printerName = this.printerName) {
+    this.tscOcx.ActiveXopenport(printerName);
+
+    return this;
+  }
+}
+    `,
+    {
+      code: `
+const obj = {
+  foo: 'foo-value',
+  bar: 'bar-value',
+} satisfies {
+  [key in 'foo' | 'bar']: \`\${key}-value\`;
+};
+      `,
+      options: [{ ignoreTypeReferences: false }],
+    },
+    {
+      code: `
+const obj = {
+  foo: 'foo-value',
+  bar: 'bar-value',
+} as {
+  [key in 'foo' | 'bar']: \`\${key}-value\`;
+};
+      `,
+      options: [{ ignoreTypeReferences: false }],
+    },
+    {
+      code: `
+const obj = {
+  foo: {
+    foo: 'foo',
+  } as {
+    [key in 'foo' | 'bar']: key;
+  },
+};
+      `,
+      options: [{ ignoreTypeReferences: false }],
+    },
+    {
+      code: `
+const foo = {
+  bar: 'bar',
+} satisfies {
+  bar: typeof baz;
+};
+
+const baz = '';
+      `,
+      options: [{ ignoreTypeReferences: true }],
+    },
   ],
 });
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 a49055b6c0d9..de9a26690bf1 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
@@ -11,6 +11,94 @@ const error = {
 };
 
 ruleTester.run('no-useless-constructor', rule, {
+  invalid: [
+    {
+      code: `
+class A {
+  constructor() {}
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor() {
+    super();
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(foo) {
+    super(foo);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(foo, bar) {
+    super(foo, bar);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(...args) {
+    super(...args);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B.C {
+  constructor() {
+    super(...arguments);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(...arguments);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(a, b, ...c);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A {
+  public constructor() {}
+}
+      `,
+      errors: [error],
+    },
+  ],
   valid: [
     'class A {}',
     `
@@ -213,92 +301,4 @@ class A extends Object {
 }
     `,
   ],
-  invalid: [
-    {
-      code: `
-class A {
-  constructor() {}
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor() {
-    super();
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(foo) {
-    super(foo);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(foo, bar) {
-    super(foo, bar);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(...args) {
-    super(...args);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B.C {
-  constructor() {
-    super(...arguments);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(a, b, ...c) {
-    super(...arguments);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(a, b, ...c) {
-    super(a, b, ...c);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A {
-  public constructor() {}
-}
-      `,
-      errors: [error],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts b/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
index f0e37327ba6a..422c01c58185 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
@@ -20,54 +20,6 @@ const error = {
 } as const;
 
 ruleTester.run('no-useless-empty-export', rule, {
-  valid: [
-    "declare module '_'",
-    "import {} from '_';",
-    "import * as _ from '_';",
-    'export = {};',
-    'export = 3;',
-    'export const _ = {};',
-    `
-      const _ = {};
-      export default _;
-    `,
-    `
-      export * from '_';
-      export = {};
-    `,
-    `
-      export {};
-    `,
-    // https://github.com/microsoft/TypeScript/issues/38592
-    {
-      code: `
-        export type A = 1;
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        export declare const a = 2;
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        import type { A } from '_';
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        import { A } from '_';
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-  ],
   invalid: [
     {
       code: `
@@ -166,4 +118,52 @@ import _ = require('_');
       `,
     },
   ],
+  valid: [
+    "declare module '_'",
+    "import {} from '_';",
+    "import * as _ from '_';",
+    'export = {};',
+    'export = 3;',
+    'export const _ = {};',
+    `
+      const _ = {};
+      export default _;
+    `,
+    `
+      export * from '_';
+      export = {};
+    `,
+    `
+      export {};
+    `,
+    // https://github.com/microsoft/TypeScript/issues/38592
+    {
+      code: `
+        export type A = 1;
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        export declare const a = 2;
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        import type { A } from '_';
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        import { A } from '_';
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+  ],
 });
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 ef61110d83a0..741d543ec74c 100644
--- a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
@@ -5,48 +5,14 @@ import rule from '../../src/rules/no-var-requires';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-var-requires', rule, {
-  valid: [
-    "import foo = require('foo');",
-    "require('foo');",
-    "require?.('foo');",
-    `
-import { createRequire } from 'module';
-const require = createRequire('foo');
-const json = require('./some.json');
-    `,
-    {
-      code: "const pkg = require('./package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('data.json');",
-      options: [{ allow: ['\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('some-package');",
-      options: [{ allow: ['^some-package$'] }],
-    },
-    {
-      code: 'const pkg = require(`some-package`);',
-      options: [{ allow: ['^some-package$'] }],
-    },
-  ],
   invalid: [
     {
       code: "var foo = require('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -54,9 +20,9 @@ const json = require('./some.json');
       code: "const foo = require('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -64,9 +30,9 @@ const json = require('./some.json');
       code: "let foo = require('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -74,9 +40,9 @@ const json = require('./some.json');
       code: "let foo = trick(require('foo'));",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 17,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -84,9 +50,9 @@ const json = require('./some.json');
       code: "var foo = require?.('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -94,9 +60,9 @@ const json = require('./some.json');
       code: "const foo = require?.('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -104,9 +70,9 @@ const json = require('./some.json');
       code: "let foo = require?.('foo');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 11,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -114,9 +80,9 @@ const json = require('./some.json');
       code: "let foo = trick(require?.('foo'));",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 17,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -124,9 +90,9 @@ const json = require('./some.json');
       code: "let foo = trick?.(require('foo'));",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 19,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -134,9 +100,9 @@ const json = require('./some.json');
       code: "const foo = require('./foo.json') as Foo;",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -144,9 +110,9 @@ const json = require('./some.json');
       code: "const foo = <Foo>require('./foo.json');",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 18,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -154,9 +120,9 @@ const json = require('./some.json');
       code: "const foo: Foo = require('./foo.json').default;",
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 1,
           column: 18,
+          line: 1,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -168,14 +134,14 @@ configValidator.addSchema(require('./a.json'));
       `,
       errors: [
         {
-          messageId: 'noVarReqs',
-          line: 2,
           column: 39,
+          line: 2,
+          messageId: 'noVarReqs',
         },
         {
-          messageId: 'noVarReqs',
-          line: 3,
           column: 27,
+          line: 3,
+          messageId: 'noVarReqs',
         },
       ],
     },
@@ -183,44 +149,78 @@ configValidator.addSchema(require('./a.json'));
       code: "const pkg = require('./package.json');",
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noVarReqs',
         },
       ],
     },
     {
       code: "const pkg = require('./package.jsonc');",
-      options: [{ allow: ['/package\\.json$'] }],
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noVarReqs',
         },
       ],
+      options: [{ allow: ['/package\\.json$'] }],
     },
     {
       code: "const pkg = require('./package.json');",
-      options: [{ allow: ['^some-package$'] }],
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noVarReqs',
         },
       ],
+      options: [{ allow: ['^some-package$'] }],
     },
     {
       code: 'const pkg = require(`./package.json`);',
-      options: [{ allow: ['^some-package$'] }],
       errors: [
         {
-          line: 1,
           column: 13,
+          line: 1,
           messageId: 'noVarReqs',
         },
       ],
+      options: [{ allow: ['^some-package$'] }],
+    },
+  ],
+  valid: [
+    "import foo = require('foo');",
+    "require('foo');",
+    "require?.('foo');",
+    `
+import { createRequire } from 'module';
+const require = createRequire('foo');
+const json = require('./some.json');
+    `,
+    {
+      code: "const pkg = require('./package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('data.json');",
+      options: [{ allow: ['\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('some-package');",
+      options: [{ allow: ['^some-package$'] }],
+    },
+    {
+      code: 'const pkg = require(`some-package`);',
+      options: [{ allow: ['^some-package$'] }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts b/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
index b98ef17bc9e9..700f415d282a 100644
--- a/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
@@ -6,235 +6,235 @@ import rule from '../../src/rules/no-wrapper-object-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-wrapper-object-types', rule, {
-  valid: [
-    'let value: NumberLike;',
-    'let value: Other;',
-    'let value: bigint;',
-    'let value: boolean;',
-    'let value: never;',
-    'let value: null;',
-    'let value: number;',
-    'let value: symbol;',
-    'let value: undefined;',
-    'let value: unknown;',
-    'let value: void;',
-    'let value: () => void;',
-    'let value: () => () => void;',
-    'let Bigint;',
-    'let Boolean;',
-    'let Never;',
-    'let Null;',
-    'let Number;',
-    'let Symbol;',
-    'let Undefined;',
-    'let Unknown;',
-    'let Void;',
-    'interface Bigint {}',
-    'interface Boolean {}',
-    'interface Never {}',
-    'interface Null {}',
-    'interface Number {}',
-    'interface Symbol {}',
-    'interface Undefined {}',
-    'interface Unknown {}',
-    'interface Void {}',
-    'type Bigint = {};',
-    'type Boolean = {};',
-    'type Never = {};',
-    'type Null = {};',
-    'type Number = {};',
-    'type Symbol = {};',
-    'type Undefined = {};',
-    'type Unknown = {};',
-    'type Void = {};',
-    'class MyClass extends Number {}',
-    `
-      type Number = 0 | 1;
-      let value: Number;
-    `,
-    `
-      type Bigint = 0 | 1;
-      let value: Bigint;
-    `,
-    `
-      type T<Symbol> = Symbol;
-      type U<UU> = UU extends T<infer Function> ? Function : never;
-    `,
-  ],
   invalid: [
     {
       code: 'let value: BigInt;',
-      output: 'let value: bigint;',
       errors: [
         {
-          data: { typeName: 'BigInt', preferred: 'bigint' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'bigint', typeName: 'BigInt' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: bigint;',
     },
     {
       code: 'let value: Boolean;',
-      output: 'let value: boolean;',
       errors: [
         {
-          data: { typeName: 'Boolean', preferred: 'boolean' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'boolean', typeName: 'Boolean' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: boolean;',
     },
     {
       code: 'let value: Number;',
-      output: 'let value: number;',
       errors: [
         {
-          data: { typeName: 'Number', preferred: 'number' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'number', typeName: 'Number' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: number;',
     },
     {
       code: 'let value: Object;',
-      output: 'let value: object;',
       errors: [
         {
-          data: { typeName: 'Object', preferred: 'object' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'object', typeName: 'Object' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: object;',
     },
     {
       code: 'let value: String;',
-      output: 'let value: string;',
       errors: [
         {
-          data: { typeName: 'String', preferred: 'string' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'string', typeName: 'String' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: string;',
     },
     {
       code: 'let value: Symbol;',
-      output: 'let value: symbol;',
       errors: [
         {
-          data: { typeName: 'Symbol', preferred: 'symbol' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'symbol', typeName: 'Symbol' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: symbol;',
     },
     {
       code: 'let value: Number | Symbol;',
-      output: 'let value: number | symbol;',
       errors: [
         {
-          data: { typeName: 'Number', preferred: 'number' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 12,
+          data: { preferred: 'number', typeName: 'Number' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
         {
-          data: { typeName: 'Symbol', preferred: 'symbol' },
-          messageId: 'bannedClassType',
-          line: 1,
           column: 21,
+          data: { preferred: 'symbol', typeName: 'Symbol' },
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: number | symbol;',
     },
     {
       code: 'let value: { property: Number };',
-      output: 'let value: { property: number };',
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 24,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'let value: { property: number };',
     },
     {
       code: '0 as Number;',
-      output: '0 as number;',
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 6,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: '0 as number;',
     },
     {
       code: 'type MyType = Number;',
-      output: 'type MyType = number;',
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 15,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'type MyType = number;',
     },
     {
       code: 'type MyType = [Number];',
-      output: 'type MyType = [number];',
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 16,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'type MyType = [number];',
     },
     {
       code: 'class MyClass implements Number {}',
-      output: null,
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 26,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: null,
     },
     {
       code: 'interface MyInterface extends Number {}',
-      output: null,
       errors: [
         {
-          messageId: 'bannedClassType',
-          line: 1,
           column: 31,
+          line: 1,
+          messageId: 'bannedClassType',
         },
       ],
+      output: null,
     },
     {
       code: 'type MyType = Number & String;',
-      output: 'type MyType = number & string;',
       errors: [
         {
+          column: 15,
           data: { preferred: 'number', typeName: 'Number' },
-          messageId: 'bannedClassType',
           line: 1,
-          column: 15,
+          messageId: 'bannedClassType',
         },
         {
+          column: 24,
           data: { preferred: 'string', typeName: 'String' },
-          messageId: 'bannedClassType',
           line: 1,
-          column: 24,
+          messageId: 'bannedClassType',
         },
       ],
+      output: 'type MyType = number & string;',
     },
   ],
+  valid: [
+    'let value: NumberLike;',
+    'let value: Other;',
+    'let value: bigint;',
+    'let value: boolean;',
+    'let value: never;',
+    'let value: null;',
+    'let value: number;',
+    'let value: symbol;',
+    'let value: undefined;',
+    'let value: unknown;',
+    'let value: void;',
+    'let value: () => void;',
+    'let value: () => () => void;',
+    'let Bigint;',
+    'let Boolean;',
+    'let Never;',
+    'let Null;',
+    'let Number;',
+    'let Symbol;',
+    'let Undefined;',
+    'let Unknown;',
+    'let Void;',
+    'interface Bigint {}',
+    'interface Boolean {}',
+    'interface Never {}',
+    'interface Null {}',
+    'interface Number {}',
+    'interface Symbol {}',
+    'interface Undefined {}',
+    'interface Unknown {}',
+    'interface Void {}',
+    'type Bigint = {};',
+    'type Boolean = {};',
+    'type Never = {};',
+    'type Null = {};',
+    'type Number = {};',
+    'type Symbol = {};',
+    'type Undefined = {};',
+    'type Unknown = {};',
+    'type Void = {};',
+    'class MyClass extends Number {}',
+    `
+      type Number = 0 | 1;
+      let value: Number;
+    `,
+    `
+      type Bigint = 0 | 1;
+      let value: Bigint;
+    `,
+    `
+      type T<Symbol> = Symbol;
+      type U<UU> = UU extends T<infer Function> ? Function : never;
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts b/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
index f8f8bbea79d9..900421f7a6d1 100644
--- a/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
@@ -6,63 +6,13 @@ import { getFixturesRootDir } from '../RuleTester';
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: getFixturesRootDir(),
       project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
     },
   },
 });
 
 ruleTester.run('non-nullable-type-assertion-style', rule, {
-  valid: [
-    `
-declare const original: number | string;
-const cast = original as string;
-    `,
-    `
-declare const original: number | undefined;
-const cast = original as string | number | undefined;
-    `,
-    `
-declare const original: number | any;
-const cast = original as string | number | undefined;
-    `,
-    `
-declare const original: number | undefined;
-const cast = original as any;
-    `,
-    `
-declare const original: number | null | undefined;
-const cast = original as number | null;
-    `,
-    `
-type Type = { value: string };
-declare const original: Type | number;
-const cast = original as Type;
-    `,
-    `
-type T = string;
-declare const x: T | number;
-
-const y = x as NonNullable<T>;
-    `,
-    `
-type T = string | null;
-declare const x: T | number;
-
-const y = x as NonNullable<T>;
-    `,
-    `
-const foo = [] as const;
-    `,
-    `
-const x = 1 as 1;
-    `,
-    `
-declare function foo<T = any>(): T;
-const bar = foo() as number;
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -242,6 +192,56 @@ const b = (a || undefined)!;
       `,
     },
   ],
+
+  valid: [
+    `
+declare const original: number | string;
+const cast = original as string;
+    `,
+    `
+declare const original: number | undefined;
+const cast = original as string | number | undefined;
+    `,
+    `
+declare const original: number | any;
+const cast = original as string | number | undefined;
+    `,
+    `
+declare const original: number | undefined;
+const cast = original as any;
+    `,
+    `
+declare const original: number | null | undefined;
+const cast = original as number | null;
+    `,
+    `
+type Type = { value: string };
+declare const original: Type | number;
+const cast = original as Type;
+    `,
+    `
+type T = string;
+declare const x: T | number;
+
+const y = x as NonNullable<T>;
+    `,
+    `
+type T = string | null;
+declare const x: T | number;
+
+const y = x as NonNullable<T>;
+    `,
+    `
+const foo = [] as const;
+    `,
+    `
+const x = 1 as 1;
+    `,
+    `
+declare function foo<T = any>(): T;
+const bar = foo() as number;
+    `,
+  ],
 });
 
 const ruleTesterWithNoUncheckedIndexAccess = new RuleTester({
@@ -259,6 +259,27 @@ ruleTesterWithNoUncheckedIndexAccess.run(
   'non-nullable-type-assertion-style - noUncheckedIndexedAccess',
   rule,
   {
+    invalid: [
+      {
+        code: `
+function first<T extends string | number>(array: ArrayLike<T>): T | null {
+  return array.length > 0 ? (array[0] as T) : null;
+}
+        `,
+        errors: [
+          {
+            column: 30,
+            line: 3,
+            messageId: 'preferNonNullAssertion',
+          },
+        ],
+        output: `
+function first<T extends string | number>(array: ArrayLike<T>): T | null {
+  return array.length > 0 ? (array[0]!) : null;
+}
+        `,
+      },
+    ],
     valid: [
       `
 function first<T>(array: ArrayLike<T>): T | null {
@@ -290,26 +311,5 @@ function first<T extends A | B | null>(array: ArrayLike<T>): T | null {
 }
       `,
     ],
-    invalid: [
-      {
-        code: `
-function first<T extends string | number>(array: ArrayLike<T>): T | null {
-  return array.length > 0 ? (array[0] as T) : null;
-}
-        `,
-        errors: [
-          {
-            column: 30,
-            line: 3,
-            messageId: 'preferNonNullAssertion',
-          },
-        ],
-        output: `
-function first<T extends string | number>(array: ArrayLike<T>): T | null {
-  return array.length > 0 ? (array[0]!) : null;
-}
-        `,
-      },
-    ],
   },
 );
diff --git a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
index 0ae3f0e00769..5c63874ff9a7 100644
--- a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
+++ b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
@@ -6,135 +6,13 @@ import { getFixturesRootDir } from '../RuleTester';
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: getFixturesRootDir(),
       project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
     },
   },
 });
 
 ruleTester.run('only-throw-error', rule, {
-  valid: [
-    'throw new Error();',
-    "throw new Error('error');",
-    "throw Error('error');",
-    `
-const e = new Error();
-throw e;
-    `,
-    `
-try {
-  throw new Error();
-} catch (e) {
-  throw e;
-}
-    `,
-    `
-function foo() {
-  return new Error();
-}
-throw foo();
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-throw foo.bar;
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-
-throw foo['bar'];
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-
-const bar = 'bar';
-throw foo[bar];
-    `,
-    `
-class CustomError extends Error {}
-throw new CustomError();
-    `,
-    `
-class CustomError1 extends Error {}
-class CustomError2 extends CustomError1 {}
-throw new CustomError2();
-    `,
-    'throw (foo = new Error());',
-    'throw (1, 2, new Error());',
-    "throw 'literal' && new Error();",
-    "throw new Error() || 'literal';",
-    'throw foo ? new Error() : new Error();',
-    `
-function* foo() {
-  let index = 0;
-  throw yield index++;
-}
-    `,
-    `
-async function foo() {
-  throw await bar;
-}
-    `,
-    `
-import { Error } from './missing';
-throw Error;
-    `,
-    `
-class CustomError<T, C> extends Error {}
-throw new CustomError<string, string>();
-    `,
-    `
-class CustomError<T = {}> extends Error {}
-throw new CustomError();
-    `,
-    `
-class CustomError<T extends object> extends Error {}
-throw new CustomError();
-    `,
-    `
-function foo() {
-  throw Object.assign(new Error('message'), { foo: 'bar' });
-}
-    `,
-    `
-const foo: Error | SyntaxError = bar();
-function bar() {
-  throw foo;
-}
-    `,
-    `
-declare const foo: Error | string;
-throw foo as Error;
-    `,
-    'throw new Error() as Error;',
-    `
-declare const nullishError: Error | undefined;
-throw nullishError ?? new Error();
-    `,
-    `
-declare const nullishError: Error | undefined;
-throw nullishError || new Error();
-    `,
-    `
-declare const nullishError: Error | undefined;
-throw nullishError ? nullishError : new Error();
-    `,
-    `
-function fun(value: any) {
-  throw value;
-}
-    `,
-    `
-function fun(value: unknown) {
-  throw value;
-}
-    `,
-  ],
   invalid: [
     {
       code: 'throw undefined;',
@@ -352,9 +230,9 @@ throw new Error();
       `,
       errors: [
         {
-          messageId: 'object',
-          line: 3,
           column: 7,
+          line: 3,
+          messageId: 'object',
         },
       ],
     },
@@ -365,9 +243,9 @@ throw new CustomError();
       `,
       errors: [
         {
-          messageId: 'object',
-          line: 3,
           column: 7,
+          line: 3,
+          messageId: 'object',
         },
       ],
     },
@@ -380,9 +258,9 @@ function foo<T>() {
       `,
       errors: [
         {
-          messageId: 'object',
-          line: 4,
           column: 9,
+          line: 4,
+          messageId: 'object',
         },
       ],
     },
@@ -396,9 +274,9 @@ function foo<T>(fn: () => Promise<T>) {
       `,
       errors: [
         {
-          messageId: 'object',
-          line: 5,
           column: 9,
+          line: 5,
+          messageId: 'object',
         },
       ],
     },
@@ -469,4 +347,126 @@ function fun(value: unknown) {
       ],
     },
   ],
+  valid: [
+    'throw new Error();',
+    "throw new Error('error');",
+    "throw Error('error');",
+    `
+const e = new Error();
+throw e;
+    `,
+    `
+try {
+  throw new Error();
+} catch (e) {
+  throw e;
+}
+    `,
+    `
+function foo() {
+  return new Error();
+}
+throw foo();
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+throw foo.bar;
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+
+throw foo['bar'];
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+
+const bar = 'bar';
+throw foo[bar];
+    `,
+    `
+class CustomError extends Error {}
+throw new CustomError();
+    `,
+    `
+class CustomError1 extends Error {}
+class CustomError2 extends CustomError1 {}
+throw new CustomError2();
+    `,
+    'throw (foo = new Error());',
+    'throw (1, 2, new Error());',
+    "throw 'literal' && new Error();",
+    "throw new Error() || 'literal';",
+    'throw foo ? new Error() : new Error();',
+    `
+function* foo() {
+  let index = 0;
+  throw yield index++;
+}
+    `,
+    `
+async function foo() {
+  throw await bar;
+}
+    `,
+    `
+import { Error } from './missing';
+throw Error;
+    `,
+    `
+class CustomError<T, C> extends Error {}
+throw new CustomError<string, string>();
+    `,
+    `
+class CustomError<T = {}> extends Error {}
+throw new CustomError();
+    `,
+    `
+class CustomError<T extends object> extends Error {}
+throw new CustomError();
+    `,
+    `
+function foo() {
+  throw Object.assign(new Error('message'), { foo: 'bar' });
+}
+    `,
+    `
+const foo: Error | SyntaxError = bar();
+function bar() {
+  throw foo;
+}
+    `,
+    `
+declare const foo: Error | string;
+throw foo as Error;
+    `,
+    'throw new Error() as Error;',
+    `
+declare const nullishError: Error | undefined;
+throw nullishError ?? new Error();
+    `,
+    `
+declare const nullishError: Error | undefined;
+throw nullishError || new Error();
+    `,
+    `
+declare const nullishError: Error | undefined;
+throw nullishError ? nullishError : new Error();
+    `,
+    `
+function fun(value: any) {
+  throw value;
+}
+    `,
+    `
+function fun(value: unknown) {
+  throw value;
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
index 72cccf1180ec..74ab71267250 100644
--- a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
+++ b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
@@ -5,43 +5,23 @@ import rule from '../../src/rules/parameter-properties';
 const ruleTester = new RuleTester();
 
 ruleTester.run('parameter-properties', rule, {
-  valid: [
-    `
-class Foo {
-  constructor(name: string) {}
-}
-    `,
-    {
-      code: `
-class Foo {
-  constructor(name: string) {}
-}
-      `,
-      options: [{ prefer: 'class-property' }],
-    },
-    `
-class Foo {
-  constructor(...name: string[]) {}
-}
-    `,
-    `
-class Foo {
-  constructor(name: string, age: number) {}
-}
-    `,
-    `
-class Foo {
-  constructor(name: string) {}
-  constructor(name: string, age?: number) {}
-}
-    `,
+  invalid: [
     {
       code: `
 class Foo {
   constructor(readonly name: string) {}
 }
       `,
-      options: [{ allow: ['readonly'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -49,7 +29,16 @@ class Foo {
   constructor(private name: string) {}
 }
       `,
-      options: [{ allow: ['private'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -57,7 +46,16 @@ class Foo {
   constructor(protected name: string) {}
 }
       `,
-      options: [{ allow: ['protected'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -65,7 +63,16 @@ class Foo {
   constructor(public name: string) {}
 }
       `,
-      options: [{ allow: ['public'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -73,7 +80,16 @@ class Foo {
   constructor(private readonly name: string) {}
 }
       `,
-      options: [{ allow: ['private readonly'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -81,7 +97,16 @@ class Foo {
   constructor(protected readonly name: string) {}
 }
       `,
-      options: [{ allow: ['protected readonly'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
@@ -89,270 +114,226 @@ class Foo {
   constructor(public readonly name: string) {}
 }
       `,
-      options: [{ allow: ['public readonly'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
   constructor(
-    readonly name: string,
-    private age: number,
+    public name: string,
+    age: number,
   ) {}
 }
       `,
-      options: [{ allow: ['readonly', 'private'] }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 4,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
   constructor(
-    public readonly name: string,
+    private name: string,
     private age: number,
   ) {}
 }
       `,
-      options: [{ allow: ['public readonly', 'private'] }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 4,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
-    // Semantically invalid test case
-    `
-class Foo {
-  constructor(private ...name: string[]) {}
-}
-    `,
-    // Semantically invalid test case
-    `
-class Foo {
-  constructor(private [test]: [string]) {}
-}
-    `,
     {
       code: `
 class Foo {
-  constructor(private name: string[]) {}
+  constructor(
+    protected name: string,
+    protected age: number,
+  ) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 4,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  constructor(...name: string[]) {}
+  constructor(
+    public name: string,
+    public age: number,
+  ) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 4,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  constructor(age: string, ...name: string[]) {}
+  constructor(name: string) {}
+  constructor(
+    private name: string,
+    age?: number,
+  ) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
+  constructor(private name: string) {}
   constructor(
-    private age: string,
-    ...name: string[]
+    private name: string,
+    age?: number,
   ) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+      ],
     },
     {
       code: `
 class Foo {
-  public age: number;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age = '';
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: string;
-  constructor(age) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: string;
-  constructor(age: string) {
-    console.log('unrelated');
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  other: string;
-  constructor(age: string) {
-    this.other = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  age: string;
-  constructor(age: string) {
-    this.age = '';
-    console.log(age);
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  age() {
-    return '';
-  }
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['public'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public readonly age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['public readonly'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  protected age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['protected'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  protected readonly age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [
-        { allow: ['protected readonly'], prefer: 'parameter-property' },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  private age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['private'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  private readonly age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['private readonly'], prefer: 'parameter-property' }],
-    },
-  ],
-  invalid: [
-    {
-      code: `
-class Foo {
-  constructor(readonly name: string) {}
+  constructor(private name: string) {}
+  constructor(
+    private name: string,
+    private age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
+  constructor(name: string) {}
+  constructor(
+    protected name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
-          column: 15,
+          line: 5,
+          messageId: 'preferClassProperty',
         },
       ],
     },
@@ -360,488 +341,446 @@ class Foo {
       code: `
 class Foo {
   constructor(protected name: string) {}
+  constructor(
+    protected name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
         },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  constructor(public name: string) {}
-}
-      `,
-      errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
-          column: 15,
+          line: 5,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(private readonly name: string) {}
+  constructor(protected name: string) {}
+  constructor(
+    protected name: string,
+    protected age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(protected readonly name: string) {}
+  constructor(name: string) {}
+  constructor(
+    public name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
-          column: 15,
+          line: 5,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(public readonly name: string) {}
+  constructor(public name: string) {}
+  constructor(
+    public name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
         },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  constructor(
-    public name: string,
-    age: number,
-  ) {}
-}
-      `,
-      errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 4,
-          column: 5,
+          line: 5,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
+  constructor(public name: string) {}
   constructor(
-    private name: string,
-    private age: number,
+    public name: string,
+    public age?: number,
   ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 4,
-          column: 5,
-        },
-        {
+          line: 3,
           messageId: 'preferClassProperty',
-          data: {
-            parameter: 'age',
-          },
-          line: 5,
-          column: 5,
         },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  constructor(
-    protected name: string,
-    protected age: number,
-  ) {}
-}
-      `,
-      errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 4,
-          column: 5,
+          line: 5,
+          messageId: 'preferClassProperty',
         },
         {
-          messageId: 'preferClassProperty',
+          column: 5,
           data: {
             parameter: 'age',
           },
-          line: 5,
-          column: 5,
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
     },
+
     {
       code: `
 class Foo {
-  constructor(
-    public name: string,
-    public age: number,
-  ) {}
+  constructor(readonly name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 4,
-          column: 5,
-        },
-        {
+          line: 3,
           messageId: 'preferClassProperty',
-          data: {
-            parameter: 'age',
-          },
-          line: 5,
-          column: 5,
         },
       ],
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
-  constructor(name: string) {}
-  constructor(
-    private name: string,
-    age?: number,
-  ) {}
+  constructor(private name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 5,
-          column: 5,
+          line: 3,
+          messageId: 'preferClassProperty',
         },
       ],
+      options: [{ allow: ['readonly'] }],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
-  constructor(
-    private name: string,
-    age?: number,
-  ) {}
+  constructor(protected name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
         },
+      ],
+      options: [
         {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          column: 5,
+          allow: ['readonly', 'private', 'public', 'protected readonly'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
-  constructor(
-    private name: string,
-    private age?: number,
-  ) {}
+  constructor(public name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
-        },
-        {
           messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          column: 5,
         },
+      ],
+      options: [
         {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'age',
-          },
-          line: 6,
-          column: 5,
+          allow: [
+            'readonly',
+            'private',
+            'protected',
+            'protected readonly',
+            'public readonly',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(name: string) {}
-  constructor(
-    protected name: string,
-    age?: number,
-  ) {}
+  constructor(private readonly name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 5,
-          column: 5,
+          line: 3,
+          messageId: 'preferClassProperty',
         },
       ],
+      options: [{ allow: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
-  constructor(protected name: string) {}
-  constructor(
-    protected name: string,
-    age?: number,
-  ) {}
+  constructor(protected readonly name: string) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 15,
           data: {
             parameter: 'name',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferClassProperty',
         },
+      ],
+      options: [
         {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          column: 5,
+          allow: [
+            'readonly',
+            'protected',
+            'private readonly',
+            'public readonly',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(protected name: string) {}
+  constructor(private name: string) {}
   constructor(
-    protected name: string,
+    private name: string,
     protected age?: number,
   ) {}
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
           column: 5,
-        },
-        {
-          messageId: 'preferClassProperty',
           data: {
             parameter: 'age',
           },
           line: 6,
-          column: 5,
+          messageId: 'preferClassProperty',
         },
       ],
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
-  constructor(name: string) {}
-  constructor(
-    public name: string,
-    age?: number,
-  ) {}
+  member: string;
+
+  constructor(member: string) {
+    this.member = member;
+  }
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 3,
           data: {
-            parameter: 'name',
+            parameter: 'member',
           },
-          line: 5,
-          column: 5,
+          line: 3,
+          messageId: 'preferParameterProperty',
         },
       ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(public name: string) {}
-  constructor(
-    public name: string,
-    age?: number,
-  ) {}
+  constructor(member: string) {
+    this.member = member;
+  }
+
+  member: string;
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-        {
-          messageId: 'preferClassProperty',
+          column: 3,
           data: {
-            parameter: 'name',
+            parameter: 'member',
           },
-          line: 5,
-          column: 5,
+          line: 7,
+          messageId: 'preferParameterProperty',
         },
       ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(public name: string) {}
-  constructor(
-    public name: string,
-    public age?: number,
-  ) {}
+  member;
+  constructor(member) {
+    this.member = member;
+  }
 }
       `,
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 3,
           data: {
-            parameter: 'name',
+            parameter: 'member',
           },
           line: 3,
-          column: 15,
-        },
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          column: 5,
-        },
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'age',
-          },
-          line: 6,
-          column: 5,
+          messageId: 'preferParameterProperty',
         },
       ],
+      options: [{ prefer: 'parameter-property' }],
     },
-
     {
       code: `
 class Foo {
-  constructor(readonly name: string) {}
+  public member: string;
+  constructor(member: string) {
+    this.member = member;
+  }
 }
       `,
-      options: [{ allow: ['private'] }],
       errors: [
         {
-          messageId: 'preferClassProperty',
+          column: 3,
           data: {
-            parameter: 'name',
+            parameter: 'member',
           },
           line: 3,
-          column: 15,
+          messageId: 'preferParameterProperty',
+        },
+      ],
+      options: [
+        {
+          allow: ['protected', 'private', 'readonly'],
+          prefer: 'parameter-property',
         },
       ],
     },
+  ],
+  valid: [
+    `
+class Foo {
+  constructor(name: string) {}
+}
+    `,
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
+  constructor(name: string) {}
+}
+      `,
+      options: [{ prefer: 'class-property' }],
+    },
+    `
+class Foo {
+  constructor(...name: string[]) {}
+}
+    `,
+    `
+class Foo {
+  constructor(name: string, age: number) {}
+}
+    `,
+    `
+class Foo {
+  constructor(name: string) {}
+  constructor(name: string, age?: number) {}
+}
+    `,
+    {
+      code: `
+class Foo {
+  constructor(readonly name: string) {}
 }
       `,
       options: [{ allow: ['readonly'] }],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-      ],
+    },
+    {
+      code: `
+class Foo {
+  constructor(private name: string) {}
+}
+      `,
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
@@ -849,21 +788,7 @@ class Foo {
   constructor(protected name: string) {}
 }
       `,
-      options: [
-        {
-          allow: ['readonly', 'private', 'public', 'protected readonly'],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-      ],
+      options: [{ allow: ['protected'] }],
     },
     {
       code: `
@@ -871,27 +796,7 @@ class Foo {
   constructor(public name: string) {}
 }
       `,
-      options: [
-        {
-          allow: [
-            'readonly',
-            'private',
-            'protected',
-            'protected readonly',
-            'public readonly',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-      ],
+      options: [{ allow: ['public'] }],
     },
     {
       code: `
@@ -899,17 +804,7 @@ class Foo {
   constructor(private readonly name: string) {}
 }
       `,
-      options: [{ allow: ['readonly', 'private'] }],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-      ],
+      options: [{ allow: ['private readonly'] }],
     },
     {
       code: `
@@ -917,139 +812,244 @@ class Foo {
   constructor(protected readonly name: string) {}
 }
       `,
-      options: [
-        {
-          allow: [
-            'readonly',
-            'protected',
-            'private readonly',
-            'public readonly',
-          ],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          column: 15,
-        },
-      ],
+      options: [{ allow: ['protected readonly'] }],
+    },
+    {
+      code: `
+class Foo {
+  constructor(public readonly name: string) {}
+}
+      `,
+      options: [{ allow: ['public readonly'] }],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
   constructor(
-    private name: string,
-    protected age?: number,
+    readonly name: string,
+    private age: number,
   ) {}
 }
       `,
-      options: [{ allow: ['private'] }],
-      errors: [
-        {
-          messageId: 'preferClassProperty',
-          data: {
-            parameter: 'age',
-          },
-          line: 6,
-          column: 5,
-        },
-      ],
+      options: [{ allow: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
-  member: string;
-
-  constructor(member: string) {
-    this.member = member;
+  constructor(
+    public readonly name: string,
+    private age: number,
+  ) {}
+}
+      `,
+      options: [{ allow: ['public readonly', 'private'] }],
+    },
+    // Semantically invalid test case
+    `
+class Foo {
+  constructor(private ...name: string[]) {}
+}
+    `,
+    // Semantically invalid test case
+    `
+class Foo {
+  constructor(private [test]: [string]) {}
+}
+    `,
+    {
+      code: `
+class Foo {
+  constructor(private name: string[]) {}
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  constructor(...name: string[]) {}
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  constructor(age: string, ...name: string[]) {}
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  constructor(
+    private age: string,
+    ...name: string[]
+  ) {}
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: number;
+  constructor(age: string) {
+    this.age = age;
   }
 }
       `,
-      errors: [
-        {
-          messageId: 'preferParameterProperty',
-          data: {
-            parameter: 'member',
-          },
-          line: 3,
-          column: 3,
-        },
-      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(member: string) {
-    this.member = member;
+  public age = '';
+  constructor(age: string) {
+    this.age = age;
   }
-
-  member: string;
 }
       `,
-      errors: [
-        {
-          messageId: 'preferParameterProperty',
-          data: {
-            parameter: 'member',
-          },
-          line: 7,
-          column: 3,
-        },
-      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  member;
-  constructor(member) {
-    this.member = member;
+  public age;
+  constructor(age: string) {
+    this.age = age;
   }
 }
       `,
-      errors: [
-        {
-          messageId: 'preferParameterProperty',
-          data: {
-            parameter: 'member',
-          },
-          line: 3,
-          column: 3,
-        },
-      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  public member: string;
-  constructor(member: string) {
-    this.member = member;
+  public age: string;
+  constructor(age) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: string;
+  constructor(age: string) {
+    console.log('unrelated');
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  other: string;
+  constructor(age: string) {
+    this.other = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  age: string;
+  constructor(age: string) {
+    this.age = '';
+    console.log(age);
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  age() {
+    return '';
+  }
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['public'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public readonly age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['public readonly'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  protected age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['protected'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  protected readonly age: string;
+  constructor(age: string) {
+    this.age = age;
   }
 }
       `,
-      errors: [
-        {
-          messageId: 'preferParameterProperty',
-          data: {
-            parameter: 'member',
-          },
-          line: 3,
-          column: 3,
-        },
-      ],
       options: [
-        {
-          allow: ['protected', 'private', 'readonly'],
-          prefer: 'parameter-property',
-        },
+        { allow: ['protected readonly'], prefer: 'parameter-property' },
       ],
     },
+    {
+      code: `
+class Foo {
+  private age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['private'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  private readonly age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['private readonly'], prefer: 'parameter-property' }],
+    },
   ],
 });
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 eb56e9b22871..e2edb2fe0349 100644
--- a/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
@@ -5,120 +5,36 @@ import rule from '../../src/rules/prefer-as-const';
 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 = <bar>'bar';",
-    "let foo = <string>'bar';",
-    "let foo = 'bar' as string;",
-    'let foo = `bar` as `bar`;',
-    'let foo = `bar` as `foo`;',
-    "let foo = `bar` as 'bar';",
-    "let foo: string = 'bar';",
-    'let foo: number = 1;',
-    "let foo: 'bar' = baz;",
-    "let foo = 'bar';",
-    "let foo: 'bar';",
-    'let foo = { bar };',
-    "let foo: 'baz' = 'baz' as const;",
-    `
-      class foo {
-        bar = 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar;
-      }
-    `,
-    `
-      class foo {
-        bar = <baz>'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: string = 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: number = 1;
-      }
-    `,
-    `
-      class foo {
-        bar = 'baz' as const;
-      }
-    `,
-    `
-      class foo {
-        bar = 2 as const;
-      }
-    `,
-    `
-      class foo {
-        get bar(): 'bar' {}
-        set bar(bar: 'bar') {}
-      }
-    `,
-    `
-      class foo {
-        bar = () => 'bar' as const;
-      }
-    `,
-    `
-      type BazFunction = () => 'baz';
-      class foo {
-        bar: BazFunction = () => 'bar';
-      }
-    `,
-    `
-      class foo {
-        bar(): void {}
-      }
-    `,
-  ],
   invalid: [
     {
       code: "let foo = { bar: 'baz' as 'baz' };",
-      output: "let foo = { bar: 'baz' as const };",
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 27,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: "let foo = { bar: 'baz' as const };",
     },
     {
       code: 'let foo = { bar: 1 as 1 };',
-      output: 'let foo = { bar: 1 as const };',
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 23,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: 'let foo = { bar: 1 as const };',
     },
     {
       code: "let []: 'bar' = 'bar';",
-      output: null,
       errors: [
         {
-          messageId: 'variableConstAssertion',
-          line: 1,
           column: 9,
+          line: 1,
+          messageId: 'variableConstAssertion',
           suggestions: [
             {
               messageId: 'variableSuggest',
@@ -127,15 +43,15 @@ ruleTester.run('prefer-as-const', rule, {
           ],
         },
       ],
+      output: null,
     },
     {
       code: "let foo: 'bar' = 'bar';",
-      output: null,
       errors: [
         {
-          messageId: 'variableConstAssertion',
-          line: 1,
           column: 10,
+          line: 1,
+          messageId: 'variableConstAssertion',
           suggestions: [
             {
               messageId: 'variableSuggest',
@@ -144,15 +60,15 @@ ruleTester.run('prefer-as-const', rule, {
           ],
         },
       ],
+      output: null,
     },
     {
       code: 'let foo: 2 = 2;',
-      output: null,
       errors: [
         {
-          messageId: 'variableConstAssertion',
-          line: 1,
           column: 10,
+          line: 1,
+          messageId: 'variableConstAssertion',
           suggestions: [
             {
               messageId: 'variableSuggest',
@@ -161,61 +77,62 @@ ruleTester.run('prefer-as-const', rule, {
           ],
         },
       ],
+      output: null,
     },
     {
       code: "let foo: 'bar' = 'bar' as 'bar';",
-      output: "let foo: 'bar' = 'bar' as const;",
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 27,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: "let foo: 'bar' = 'bar' as const;",
     },
     {
       code: "let foo = <'bar'>'bar';",
-      output: "let foo = <const>'bar';",
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: "let foo = <const>'bar';",
     },
     {
       code: 'let foo = <4>4;',
-      output: 'let foo = <const>4;',
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 12,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: 'let foo = <const>4;',
     },
     {
       code: "let foo = 'bar' as 'bar';",
-      output: "let foo = 'bar' as const;",
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 20,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: "let foo = 'bar' as const;",
     },
     {
       code: 'let foo = 5 as 5;',
-      output: 'let foo = 5 as const;',
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 1,
           column: 16,
+          line: 1,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: 'let foo = 5 as const;',
     },
     {
       code: `
@@ -223,12 +140,11 @@ class foo {
   bar: 'baz' = 'baz';
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'variableConstAssertion',
-          line: 3,
           column: 8,
+          line: 3,
+          messageId: 'variableConstAssertion',
           suggestions: [
             {
               messageId: 'variableSuggest',
@@ -241,6 +157,7 @@ class foo {
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -248,12 +165,11 @@ class foo {
   bar: 2 = 2;
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'variableConstAssertion',
-          line: 3,
           column: 8,
+          line: 3,
+          messageId: 'variableConstAssertion',
           suggestions: [
             {
               messageId: 'variableSuggest',
@@ -266,63 +182,147 @@ class foo {
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
 class foo {
   foo = <'bar'>'bar';
-}
-      `,
-      output: `
-class foo {
-  foo = <const>'bar';
 }
       `,
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: `
+class foo {
+  foo = <const>'bar';
+}
+      `,
     },
     {
       code: `
 class foo {
   foo = 'bar' as 'bar';
-}
-      `,
-      output: `
-class foo {
-  foo = 'bar' as const;
 }
       `,
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 3,
           column: 18,
+          line: 3,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: `
+class foo {
+  foo = 'bar' as const;
+}
+      `,
     },
     {
       code: `
 class foo {
   foo = 5 as 5;
-}
-      `,
-      output: `
-class foo {
-  foo = 5 as const;
 }
       `,
       errors: [
         {
-          messageId: 'preferConstAssertion',
-          line: 3,
           column: 14,
+          line: 3,
+          messageId: 'preferConstAssertion',
         },
       ],
+      output: `
+class foo {
+  foo = 5 as const;
+}
+      `,
     },
   ],
+  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 = <bar>'bar';",
+    "let foo = <string>'bar';",
+    "let foo = 'bar' as string;",
+    'let foo = `bar` as `bar`;',
+    'let foo = `bar` as `foo`;',
+    "let foo = `bar` as 'bar';",
+    "let foo: string = 'bar';",
+    'let foo: number = 1;',
+    "let foo: 'bar' = baz;",
+    "let foo = 'bar';",
+    "let foo: 'bar';",
+    'let foo = { bar };',
+    "let foo: 'baz' = 'baz' as const;",
+    `
+      class foo {
+        bar = 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar;
+      }
+    `,
+    `
+      class foo {
+        bar = <baz>'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: string = 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: number = 1;
+      }
+    `,
+    `
+      class foo {
+        bar = 'baz' as const;
+      }
+    `,
+    `
+      class foo {
+        bar = 2 as const;
+      }
+    `,
+    `
+      class foo {
+        get bar(): 'bar' {}
+        set bar(bar: 'bar') {}
+      }
+    `,
+    `
+      class foo {
+        bar = () => 'bar' as const;
+      }
+    `,
+    `
+      type BazFunction = () => 'baz';
+      class foo {
+        bar: BazFunction = () => 'bar';
+      }
+    `,
+    `
+      class foo {
+        bar(): void {}
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
index b4486e06ec7d..5c90b135fd24 100644
--- a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
@@ -9,278 +9,365 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-destructuring', rule, {
-  valid: [
-    // type annotated
-    `
-      declare const object: { foo: string };
-      var foo: string = object.foo;
-    `,
-    `
-      declare const array: number[];
-      const bar: number = array[0];
-    `,
+  invalid: [
     // enforceForDeclarationWithTypeAnnotation: true
     {
-      code: `
-        declare const object: { foo: string };
-        var { foo } = object;
-      `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      code: 'var foo: string = object.foo;',
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
-    },
-    {
-      code: `
-        declare const object: { foo: string };
-        var { foo }: { foo: number } = object;
-      `,
       options: [
         { object: true },
         { enforceForDeclarationWithTypeAnnotation: true },
       ],
+      output: null,
     },
     {
-      code: `
-        declare const array: number[];
-        var [foo] = array;
-      `,
+      code: 'var foo: string = array[0];',
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
       options: [
         { array: true },
         { enforceForDeclarationWithTypeAnnotation: true },
       ],
+      output: null,
     },
     {
-      code: `
-        declare const array: number[];
-        var [foo]: [foo: number] = array;
-      `,
+      code: 'var foo: unknown = object.bar;',
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
       options: [
         { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+        {
+          enforceForDeclarationWithTypeAnnotation: true,
+          enforceForRenamedProperties: true,
+        },
       ],
+      output: null,
     },
+
+    // numeric property for iterable / non-iterable
     {
       code: `
-        declare const object: { bar: string };
-        var foo: unknown = object.bar;
+        let x: { [Symbol.iterator]: unknown };
+        let y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { foo: string };
-        var { foo: bar } = object;
+        let x: { [Symbol.iterator]: unknown };
+        y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { foo: boolean };
-        var { foo: bar }: { foo: boolean } = object;
+        let x: [1, 2, 3];
+        let y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare class Foo {
-          foo: string;
-        }
-
-        class Bar extends Foo {
-          static foo() {
-            var foo: any = super.foo;
-          }
-        }
+        let x: [1, 2, 3];
+        y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
-
-    // numeric property for iterable / non-iterable
-    `
-      let x: { 0: unknown };
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown };
-      y = x[0];
-    `,
-    `
-      let x: unknown;
-      let y = x[0];
-    `,
-    `
-      let x: unknown;
-      y = x[0];
-    `,
-    `
-      let x: { 0: unknown } | unknown[];
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown } | unknown[];
-      y = x[0];
-    `,
-    `
-      let x: { 0: unknown } & (() => void);
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown } & (() => void);
-      y = x[0];
-    `,
-    `
-      let x: Record<number, unknown>;
-      let y = x[0];
-    `,
-    `
-      let x: Record<number, unknown>;
-      y = x[0];
-    `,
     {
       code: `
-        let x: { 0: unknown };
-        let { 0: y } = x;
+        function* it() {
+          yield 1;
+        }
+        let y = it()[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
-        ({ 0: y } = x);
+        function* it() {
+          yield 1;
+        }
+        y = it()[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: any;
         let y = x[0];
       `,
-      options: [{ array: true }, { enforceForRenamedProperties: true }],
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: any;
         y = x[0];
       `,
-      options: [{ array: true }, { enforceForRenamedProperties: true }],
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: string[] | { [Symbol.iterator]: unknown };
         let y = x[0];
       `,
-      options: [
+      errors: [
         {
-          VariableDeclarator: { array: true, object: false },
-          AssignmentExpression: { array: true, object: true },
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
         },
-        { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: string[] | { [Symbol.iterator]: unknown };
         y = x[0];
       `,
-      options: [
+      errors: [
         {
-          VariableDeclarator: { array: true, object: true },
-          AssignmentExpression: { array: true, object: false },
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
         },
-        { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
-        let i: number = 0;
-        y = x[i];
+        let x: object & unknown[];
+        let y = x[0];
       `,
-      options: [
-        { object: false, array: true },
-        { enforceForRenamedProperties: true },
-      ],
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
-        let i: 0 = 0;
-        y = x[i];
+        let x: object & unknown[];
+        y = x[0];
+      `,
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+        let x: { 0: string };
+        let y = x[0];
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let x: { 0: string };
+        y = x[0];
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let x: { 0: string };
+        let y = x[0];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
       options: [
-        { object: false, array: true },
+        {
+          AssignmentExpression: { array: false, object: false },
+          VariableDeclarator: { array: false, object: true },
+        },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
-        let i: 0 | 1 | 2 = 0;
-        y = x[i];
+        let x: { 0: string };
+        y = x[0];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: false, array: true },
+        {
+          AssignmentExpression: { array: false, object: true },
+          VariableDeclarator: { array: false, object: false },
+        },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: unknown[];
+        let x: Record<number, unknown>;
         let i: number = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: false, array: true },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: unknown[];
+        let x: Record<number, unknown>;
         let i: 0 = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: false, array: true },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: unknown[];
+        let x: Record<number, unknown>;
         let i: 0 | 1 | 2 = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: false, array: true },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -288,486 +375,454 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: number = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: true, array: true },
-        { enforceForRenamedProperties: false },
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
-        y += x[0];
+        let x: unknown[];
+        let i: 0 = 0;
+        y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: true, array: true },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        class Bar {
-          public [0]: unknown;
-        }
-        class Foo extends Bar {
-          static foo() {
-            let y = super[0];
-          }
-        }
+        let x: unknown[];
+        let i: 0 | 1 | 2 = 0;
+        y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { object: true, array: true },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        class Bar {
-          public [0]: unknown;
-        }
-        class Foo extends Bar {
-          static foo() {
-            y = super[0];
-          }
-        }
+        let x: { 0: unknown } | unknown[];
+        let y = x[0];
       `,
-      options: [
-        { object: true, array: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let x: { 0: unknown } | unknown[];
+        y = x[0];
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
 
-    // already destructured
-    `
-      let xs: unknown[] = [1];
-      let [x] = xs;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      const { x } = obj;
-    `,
-    `
-      var obj: { x: unknown } = { x: 1 };
-      var { x: y } = obj;
-    `,
-    `
-      let obj: { x: unknown } = { x: 1 };
-      let key: 'x' = 'x';
-      let { [key]: foo } = obj;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      let x: unknown;
-      ({ x } = obj);
-    `,
-
-    // valid unless enforceForRenamedProperties is true
-    `
-      let obj: { x: unknown } = { x: 1 };
-      let y = obj.x;
-    `,
-    `
-      var obj: { x: unknown } = { x: 1 };
-      var y: unknown;
-      y = obj.x;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      const y = obj['x'];
-    `,
-    `
-      let obj: Record<string, unknown> = {};
-      let key = 'abc';
-      var y = obj[key];
-    `,
-
-    // shorthand operators shouldn't be reported;
-    `
-      let obj: { x: number } = { x: 1 };
-      let x = 10;
-      x += obj.x;
-    `,
-    `
-      let obj: { x: boolean } = { x: false };
-      let x = true;
-      x ||= obj.x;
-    `,
-    `
-      const xs: number[] = [1];
-      let x = 3;
-      x *= xs[0];
-    `,
-
-    // optional chaining shouldn't be reported
-    `
-      let xs: unknown[] | undefined;
-      let x = xs?.[0];
-    `,
-    `
-      let obj: Record<string, unknown> | undefined;
-      let x = obj?.x;
-    `,
-
-    // private identifiers
-    `
-      class C {
-        #foo: string;
-
-        method() {
-          const foo: unknown = this.#foo;
-        }
-      }
-    `,
-    `
-      class C {
-        #foo: string;
-
-        method() {
-          let foo: unknown;
-          foo = this.#foo;
-        }
-      }
-    `,
+    // auto fixes
     {
       code: `
-        class C {
-          #foo: string;
-
-          method() {
-            const bar: unknown = this.#foo;
-          }
-        }
+        let obj = { foo: 'bar' };
+        const foo = obj.foo;
       `,
-      options: [
-        { object: true, array: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
-    },
-    {
-      code: `
-        class C {
-          #foo: string;
-
-          method(another: C) {
-            let bar: unknown;
-            bar: unknown = another.#foo;
-          }
-        }
+      output: `
+        let obj = { foo: 'bar' };
+        const {foo} = obj;
       `,
-      options: [
-        { object: true, array: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
     },
     {
       code: `
-        class C {
-          #foo: string;
-
-          method() {
-            const foo: unknown = this.#foo;
-          }
-        }
+        let obj = { foo: 'bar' };
+        var x: null = null;
+        const foo = (x, obj).foo;
       `,
-      options: [
-        { object: true, array: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
-    },
-  ],
-  invalid: [
-    // enforceForDeclarationWithTypeAnnotation: true
-    {
-      code: 'var foo: string = object.foo;',
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
-      output: null,
       errors: [
         {
-          messageId: 'preferDestructuring',
           data: { type: 'object' },
+          messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      output: `
+        let obj = { foo: 'bar' };
+        var x: null = null;
+        const {foo} = (x, obj);
+      `,
     },
     {
-      code: 'var foo: string = array[0];',
-      options: [
-        { array: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
-      output: null,
+      code: 'const call = (() => null).call;',
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      output: 'const {call} = () => null;',
     },
     {
-      code: 'var foo: unknown = object.bar;',
-      options: [
-        { object: true },
-        {
-          enforceForDeclarationWithTypeAnnotation: true,
-          enforceForRenamedProperties: true,
-        },
-      ],
-      output: null,
+      code: `
+        const obj = { foo: 'bar' };
+        let a: any;
+        var foo = (a = obj).foo;
+      `,
       errors: [
         {
-          messageId: 'preferDestructuring',
           data: { type: 'object' },
+          messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      output: `
+        const obj = { foo: 'bar' };
+        let a: any;
+        var {foo} = a = obj;
+      `,
     },
-
-    // numeric property for iterable / non-iterable
     {
       code: `
-        let x: { [Symbol.iterator]: unknown };
-        let y = x[0];
+        const obj = { asdf: { qwer: null } };
+        const qwer = obj.asdf.qwer;
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      output: `
+        const obj = { asdf: { qwer: null } };
+        const {qwer} = obj.asdf;
+      `,
     },
     {
       code: `
-        let x: { [Symbol.iterator]: unknown };
-        y = x[0];
+        const obj = { foo: 100 };
+        const /* comment */ foo = obj.foo;
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.AssignmentExpression,
+          type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      output: `
+        const obj = { foo: 100 };
+        const /* comment */ {foo} = obj;
+      `,
     },
+
+    // enforceForRenamedProperties: true
     {
       code: `
-        let x: [1, 2, 3];
-        let y = x[0];
+        let obj = { foo: 'bar' };
+        const x = obj.foo;
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        let x: [1, 2, 3];
-        y = x[0];
+        let obj = { foo: 'bar' };
+        let x: unknown;
+        x = obj.foo;
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.AssignmentExpression,
         },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        function* it() {
-          yield 1;
-        }
-        let y = it()[0];
+        let obj: Record<string, unknown>;
+        let key = 'abc';
+        const x = obj[key];
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        function* it() {
-          yield 1;
-        }
-        y = it()[0];
+        let obj: Record<string, unknown>;
+        let key = 'abc';
+        let x: unknown;
+        x = obj[key];
       `,
-      output: null,
       errors: [
         {
+          data: { type: 'object' },
           messageId: 'preferDestructuring',
-          data: { type: 'array' },
           type: AST_NODE_TYPES.AssignmentExpression,
         },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
+  ],
+  valid: [
+    // type annotated
+    `
+      declare const object: { foo: string };
+      var foo: string = object.foo;
+    `,
+    `
+      declare const array: number[];
+      const bar: number = array[0];
+    `,
+    // enforceForDeclarationWithTypeAnnotation: true
     {
       code: `
-        let x: any;
-        let y = x[0];
+        declare const object: { foo: string };
+        var { foo } = object;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: any;
-        y = x[0];
+        declare const object: { foo: string };
+        var { foo }: { foo: number } = object;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: string[] | { [Symbol.iterator]: unknown };
-        let y = x[0];
+        declare const array: number[];
+        var [foo] = array;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: string[] | { [Symbol.iterator]: unknown };
-        y = x[0];
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+        declare const array: number[];
+        var [foo]: [foo: number] = array;
+      `,
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: object & unknown[];
-        let y = x[0];
+        declare const object: { bar: string };
+        var foo: unknown = object.bar;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: object & unknown[];
-        y = x[0];
+        declare const object: { foo: string };
+        var { foo: bar } = object;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'array' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: { 0: string };
-        let y = x[0];
+        declare const object: { foo: boolean };
+        var { foo: bar }: { foo: boolean } = object;
       `,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let x: { 0: string };
-        y = x[0];
+        declare class Foo {
+          foo: string;
+        }
+
+        class Bar extends Foo {
+          static foo() {
+            var foo: any = super.foo;
+          }
+        }
       `,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
+
+    // numeric property for iterable / non-iterable
+    `
+      let x: { 0: unknown };
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown };
+      y = x[0];
+    `,
+    `
+      let x: unknown;
+      let y = x[0];
+    `,
+    `
+      let x: unknown;
+      y = x[0];
+    `,
+    `
+      let x: { 0: unknown } | unknown[];
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown } | unknown[];
+      y = x[0];
+    `,
+    `
+      let x: { 0: unknown } & (() => void);
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown } & (() => void);
+      y = x[0];
+    `,
+    `
+      let x: Record<number, unknown>;
+      let y = x[0];
+    `,
+    `
+      let x: Record<number, unknown>;
+      y = x[0];
+    `,
     {
       code: `
-        let x: { 0: string };
-        let y = x[0];
+        let x: { 0: unknown };
+        let { 0: y } = x;
       `,
       options: [
-        {
-          VariableDeclarator: { object: true, array: false },
-          AssignmentExpression: { object: false, array: false },
-        },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+    },
+    {
+      code: `
+        let x: { 0: unknown };
+        ({ 0: y } = x);
+      `,
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
     },
     {
       code: `
-        let x: { 0: string };
+        let x: { 0: unknown };
+        let y = x[0];
+      `,
+      options: [{ array: true }, { enforceForRenamedProperties: true }],
+    },
+    {
+      code: `
+        let x: { 0: unknown };
         y = x[0];
       `,
+      options: [{ array: true }, { enforceForRenamedProperties: true }],
+    },
+    {
+      code: `
+        let x: { 0: unknown };
+        let y = x[0];
+      `,
       options: [
         {
-          VariableDeclarator: { object: false, array: false },
-          AssignmentExpression: { object: true, array: false },
+          AssignmentExpression: { array: true, object: true },
+          VariableDeclarator: { array: true, object: false },
         },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
+    },
+    {
+      code: `
+        let x: { 0: unknown };
+        y = x[0];
+      `,
+      options: [
         {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
+          AssignmentExpression: { array: true, object: false },
+          VariableDeclarator: { array: true, object: true },
         },
+        { enforceForRenamedProperties: true },
       ],
     },
     {
@@ -777,17 +832,9 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
@@ -796,17 +843,9 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
@@ -815,17 +854,9 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
@@ -834,17 +865,9 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
@@ -853,17 +876,9 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
@@ -872,214 +887,199 @@ ruleTester.run('prefer-destructuring', rule, {
         y = x[i];
       `,
       options: [
-        { object: true, array: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
     },
     {
       code: `
-        let x: { 0: unknown } | unknown[];
-        let y = x[0];
+        let x: unknown[];
+        let i: number = 0;
+        y = x[i];
       `,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: false },
       ],
     },
     {
       code: `
-        let x: { 0: unknown } | unknown[];
-        y = x[0];
+        let x: { 0: unknown };
+        y += x[0];
       `,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
-    },
-
-    // auto fixes
-    {
-      code: `
-        let obj = { foo: 'bar' };
-        const foo = obj.foo;
-      `,
-      output: `
-        let obj = { foo: 'bar' };
-        const {foo} = obj;
-      `,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-    },
-    {
-      code: `
-        let obj = { foo: 'bar' };
-        var x: null = null;
-        const foo = (x, obj).foo;
-      `,
-      output: `
-        let obj = { foo: 'bar' };
-        var x: null = null;
-        const {foo} = (x, obj);
-      `,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-    },
-    {
-      code: 'const call = (() => null).call;',
-      output: 'const {call} = () => null;',
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-    },
-    {
-      code: `
-        const obj = { foo: 'bar' };
-        let a: any;
-        var foo = (a = obj).foo;
-      `,
-      output: `
-        const obj = { foo: 'bar' };
-        let a: any;
-        var {foo} = a = obj;
-      `,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
     },
     {
       code: `
-        const obj = { asdf: { qwer: null } };
-        const qwer = obj.asdf.qwer;
-      `,
-      output: `
-        const obj = { asdf: { qwer: null } };
-        const {qwer} = obj.asdf;
+        class Bar {
+          public [0]: unknown;
+        }
+        class Foo extends Bar {
+          static foo() {
+            let y = super[0];
+          }
+        }
       `,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
     },
     {
       code: `
-        const obj = { foo: 100 };
-        const /* comment */ foo = obj.foo;
-      `,
-      output: `
-        const obj = { foo: 100 };
-        const /* comment */ {foo} = obj;
+        class Bar {
+          public [0]: unknown;
+        }
+        class Foo extends Bar {
+          static foo() {
+            y = super[0];
+          }
+        }
       `,
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
     },
 
-    // enforceForRenamedProperties: true
-    {
-      code: `
-        let obj = { foo: 'bar' };
-        const x = obj.foo;
-      `,
-      output: null,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-    },
+    // already destructured
+    `
+      let xs: unknown[] = [1];
+      let [x] = xs;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      const { x } = obj;
+    `,
+    `
+      var obj: { x: unknown } = { x: 1 };
+      var { x: y } = obj;
+    `,
+    `
+      let obj: { x: unknown } = { x: 1 };
+      let key: 'x' = 'x';
+      let { [key]: foo } = obj;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      let x: unknown;
+      ({ x } = obj);
+    `,
+
+    // valid unless enforceForRenamedProperties is true
+    `
+      let obj: { x: unknown } = { x: 1 };
+      let y = obj.x;
+    `,
+    `
+      var obj: { x: unknown } = { x: 1 };
+      var y: unknown;
+      y = obj.x;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      const y = obj['x'];
+    `,
+    `
+      let obj: Record<string, unknown> = {};
+      let key = 'abc';
+      var y = obj[key];
+    `,
+
+    // shorthand operators shouldn't be reported;
+    `
+      let obj: { x: number } = { x: 1 };
+      let x = 10;
+      x += obj.x;
+    `,
+    `
+      let obj: { x: boolean } = { x: false };
+      let x = true;
+      x ||= obj.x;
+    `,
+    `
+      const xs: number[] = [1];
+      let x = 3;
+      x *= xs[0];
+    `,
+
+    // optional chaining shouldn't be reported
+    `
+      let xs: unknown[] | undefined;
+      let x = xs?.[0];
+    `,
+    `
+      let obj: Record<string, unknown> | undefined;
+      let x = obj?.x;
+    `,
+
+    // private identifiers
+    `
+      class C {
+        #foo: string;
+
+        method() {
+          const foo: unknown = this.#foo;
+        }
+      }
+    `,
+    `
+      class C {
+        #foo: string;
+
+        method() {
+          let foo: unknown;
+          foo = this.#foo;
+        }
+      }
+    `,
     {
       code: `
-        let obj = { foo: 'bar' };
-        let x: unknown;
-        x = obj.foo;
+        class C {
+          #foo: string;
+
+          method() {
+            const bar: unknown = this.#foo;
+          }
+        }
       `,
-      output: null,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let obj: Record<string, unknown>;
-        let key = 'abc';
-        const x = obj[key];
+        class C {
+          #foo: string;
+
+          method(another: C) {
+            let bar: unknown;
+            bar: unknown = another.#foo;
+          }
+        }
       `,
-      output: null,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
     {
       code: `
-        let obj: Record<string, unknown>;
-        let key = 'abc';
-        let x: unknown;
-        x = obj[key];
+        class C {
+          #foo: string;
+
+          method() {
+            const foo: unknown = this.#foo;
+          }
+        }
       `,
-      output: null,
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      errors: [
-        {
-          messageId: 'preferDestructuring',
-          data: { type: 'object' },
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts b/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts
index f1d15c548e42..bec7e8f9b91f 100644
--- a/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts
@@ -38,9 +38,9 @@ enum Direction {
       `,
       errors: [
         {
-          messageId: 'defineInitializer',
           data: { name: 'Up' },
           line: 3,
+          messageId: 'defineInitializer',
           suggestions: [
             {
               messageId: 'defineInitializerSuggestion',
@@ -79,9 +79,9 @@ enum Direction {
       `,
       errors: [
         {
-          messageId: 'defineInitializer',
           data: { name: 'Up' },
           line: 3,
+          messageId: 'defineInitializer',
           suggestions: [
             {
               messageId: 'defineInitializerSuggestion',
@@ -113,9 +113,9 @@ enum Direction {
           ],
         },
         {
-          messageId: 'defineInitializer',
           data: { name: 'Down' },
           line: 4,
+          messageId: 'defineInitializer',
           suggestions: [
             {
               messageId: 'defineInitializerSuggestion',
@@ -157,9 +157,9 @@ enum Direction {
       `,
       errors: [
         {
-          messageId: 'defineInitializer',
           data: { name: 'Down' },
           line: 4,
+          messageId: 'defineInitializer',
           suggestions: [
             {
               messageId: 'defineInitializerSuggestion',
@@ -201,9 +201,9 @@ enum Direction {
       `,
       errors: [
         {
-          messageId: 'defineInitializer',
           data: { name: 'Up' },
           line: 3,
+          messageId: 'defineInitializer',
           suggestions: [
             {
               messageId: 'defineInitializerSuggestion',
diff --git a/packages/eslint-plugin/tests/rules/prefer-find.test.ts b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
index f3c6ba1bb869..310f4abe0940 100644
--- a/packages/eslint-plugin/tests/rules/prefer-find.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
@@ -8,77 +8,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('prefer-find', rule, {
-  valid: [
-    `
-      interface JerkCode<T> {
-        filter(predicate: (item: T) => boolean): JerkCode<T>;
-      }
-
-      declare const jerkCode: JerkCode<string>;
-
-      jerkCode.filter(item => item === 'aha')[0];
-    `,
-    `
-      declare const arr: readonly string[];
-      arr.filter(item => item === 'aha')[1];
-    `,
-    `
-      declare const arr: string[];
-      arr.filter(item => item === 'aha').at(1);
-    `,
-    `
-      declare const notNecessarilyAnArray: unknown[] | undefined | null | string;
-      notNecessarilyAnArray?.filter(item => true)[0];
-    `,
-    // Be sure that we don't try to mess with this case, since the member access
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter(() => true)?.[0];',
-    // Be sure that we don't try to mess with this case, since the member access
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter(() => true)?.at?.(0);',
-    // Be sure that we don't try to mess with this case, since the function call
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter?.(() => true)[0];',
-    '[1, 2, 3].filter(x => x > 0).at(-Infinity);',
-    `
-      declare const arr: string[];
-      declare const cond: Parameters<Array<string>['filter']>[0];
-      const a = { arr };
-      a?.arr.filter(cond).at(1);
-    `,
-    "['Just', 'a', 'filter'].filter(x => x.length > 4);",
-    "['Just', 'a', 'find'].find(x => x.length > 4);",
-    'undefined.filter(x => x)[0];',
-    'null?.filter(x => x)[0];',
-    // Should not throw. See https://github.com/typescript-eslint/typescript-eslint/issues/8386
-    `
-      declare function foo(param: any): any;
-      foo(Symbol.for('foo'));
-    `,
-    // Specifically need to test Symbol.for(), not just Symbol(), since only
-    // Symbol.for() creates a static value that the rule inspects.
-    `
-      declare const arr: string[];
-      const s = Symbol.for("Don't throw!");
-      arr.filter(item => item === 'aha').at(s);
-    `,
-    "[1, 2, 3].filter(x => x)[Symbol('0')];",
-    "[1, 2, 3].filter(x => x)[Symbol.for('0')];",
-    '(Math.random() < 0.5 ? [1, 2, 3].filter(x => true) : [1, 2, 3])[0];',
-    `
-      (Math.random() < 0.5
-        ? [1, 2, 3].find(x => true)
-        : [1, 2, 3].filter(x => true))[0];
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -729,4 +665,68 @@ declare const spreadArgs: [(x: unknown) => boolean];
       ],
     },
   ],
+
+  valid: [
+    `
+      interface JerkCode<T> {
+        filter(predicate: (item: T) => boolean): JerkCode<T>;
+      }
+
+      declare const jerkCode: JerkCode<string>;
+
+      jerkCode.filter(item => item === 'aha')[0];
+    `,
+    `
+      declare const arr: readonly string[];
+      arr.filter(item => item === 'aha')[1];
+    `,
+    `
+      declare const arr: string[];
+      arr.filter(item => item === 'aha').at(1);
+    `,
+    `
+      declare const notNecessarilyAnArray: unknown[] | undefined | null | string;
+      notNecessarilyAnArray?.filter(item => true)[0];
+    `,
+    // Be sure that we don't try to mess with this case, since the member access
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter(() => true)?.[0];',
+    // Be sure that we don't try to mess with this case, since the member access
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter(() => true)?.at?.(0);',
+    // Be sure that we don't try to mess with this case, since the function call
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter?.(() => true)[0];',
+    '[1, 2, 3].filter(x => x > 0).at(-Infinity);',
+    `
+      declare const arr: string[];
+      declare const cond: Parameters<Array<string>['filter']>[0];
+      const a = { arr };
+      a?.arr.filter(cond).at(1);
+    `,
+    "['Just', 'a', 'filter'].filter(x => x.length > 4);",
+    "['Just', 'a', 'find'].find(x => x.length > 4);",
+    'undefined.filter(x => x)[0];',
+    'null?.filter(x => x)[0];',
+    // Should not throw. See https://github.com/typescript-eslint/typescript-eslint/issues/8386
+    `
+      declare function foo(param: any): any;
+      foo(Symbol.for('foo'));
+    `,
+    // Specifically need to test Symbol.for(), not just Symbol(), since only
+    // Symbol.for() creates a static value that the rule inspects.
+    `
+      declare const arr: string[];
+      const s = Symbol.for("Don't throw!");
+      arr.filter(item => item === 'aha').at(s);
+    `,
+    "[1, 2, 3].filter(x => x)[Symbol('0')];",
+    "[1, 2, 3].filter(x => x)[Symbol.for('0')];",
+    '(Math.random() < 0.5 ? [1, 2, 3].filter(x => true) : [1, 2, 3])[0];',
+    `
+      (Math.random() < 0.5
+        ? [1, 2, 3].find(x => true)
+        : [1, 2, 3].filter(x => true))[0];
+    `,
+  ],
 });
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 781020b933e5..f44352bc3bcf 100644
--- a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
@@ -5,191 +5,6 @@ import rule from '../../src/rules/prefer-for-of';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-for-of', rule, {
-  valid: [
-    `
-for (let i = 0; i < arr1.length; i++) {
-  const x = arr1[i] === arr2[i];
-}
-    `,
-    `
-for (let i = 0; i < arr.length; i++) {
-  arr[i] = 0;
-}
-    `,
-    `
-for (var c = 0; c < arr.length; c++) {
-  doMath(c);
-}
-    `,
-    `
-for (var d = 0; d < arr.length; d++) doMath(d);
-    `,
-    `
-for (var e = 0; e < arr.length; e++) {
-  if (e > 5) {
-    doMath(e);
-  }
-  console.log(arr[e]);
-}
-    `,
-    `
-for (var f = 0; f <= 40; f++) {
-  doMath(f);
-}
-    `,
-    `
-for (var g = 0; g <= 40; g++) doMath(g);
-    `,
-    `
-for (var h = 0, len = arr.length; h < len; h++) {}
-    `,
-    `
-for (var i = 0, len = arr.length; i < len; i++) arr[i];
-    `,
-    `
-var m = 0;
-for (;;) {
-  if (m > 3) break;
-  console.log(m);
-  m++;
-}
-    `,
-    `
-var n = 0;
-for (; n < 9; n++) {
-  console.log(n);
-}
-    `,
-    `
-var o = 0;
-for (; o < arr.length; o++) {
-  console.log(arr[o]);
-}
-    `,
-    `
-for (; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; ; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; ) {}
-    `,
-    `
-for (let x = 0; NOTX < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; NOTX++) {}
-    `,
-    `
-for (let NOTX = 0; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; x--) {}
-    `,
-    `
-for (let x = 0; x <= arr.length; x++) {}
-    `,
-    `
-for (let x = 1; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length(); x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; x += 11) {}
-    `,
-    `
-for (let x = arr.length; x > 1; x -= 1) {}
-    `,
-    `
-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++;
-}
-    `,
-    `
-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];
-}
-    `,
-    `
-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 c = 0; c < arr.length; c++) {
-  doMath?.(c);
-}
-    `,
-    `
-for (var d = 0; d < arr.length; d++) doMath?.(d);
-    `,
-    `
-for (let i = 0; i < test.length; ++i) {
-  this[i];
-}
-    `,
-    `
-for (let i = 0; i < this.length; ++i) {
-  yield this[i];
-}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -399,4 +214,189 @@ for (let i = 0; i < this.array.length; ++i) {
       ],
     },
   ],
+  valid: [
+    `
+for (let i = 0; i < arr1.length; i++) {
+  const x = arr1[i] === arr2[i];
+}
+    `,
+    `
+for (let i = 0; i < arr.length; i++) {
+  arr[i] = 0;
+}
+    `,
+    `
+for (var c = 0; c < arr.length; c++) {
+  doMath(c);
+}
+    `,
+    `
+for (var d = 0; d < arr.length; d++) doMath(d);
+    `,
+    `
+for (var e = 0; e < arr.length; e++) {
+  if (e > 5) {
+    doMath(e);
+  }
+  console.log(arr[e]);
+}
+    `,
+    `
+for (var f = 0; f <= 40; f++) {
+  doMath(f);
+}
+    `,
+    `
+for (var g = 0; g <= 40; g++) doMath(g);
+    `,
+    `
+for (var h = 0, len = arr.length; h < len; h++) {}
+    `,
+    `
+for (var i = 0, len = arr.length; i < len; i++) arr[i];
+    `,
+    `
+var m = 0;
+for (;;) {
+  if (m > 3) break;
+  console.log(m);
+  m++;
+}
+    `,
+    `
+var n = 0;
+for (; n < 9; n++) {
+  console.log(n);
+}
+    `,
+    `
+var o = 0;
+for (; o < arr.length; o++) {
+  console.log(arr[o]);
+}
+    `,
+    `
+for (; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; ; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; ) {}
+    `,
+    `
+for (let x = 0; NOTX < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; NOTX++) {}
+    `,
+    `
+for (let NOTX = 0; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; x--) {}
+    `,
+    `
+for (let x = 0; x <= arr.length; x++) {}
+    `,
+    `
+for (let x = 1; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length(); x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; x += 11) {}
+    `,
+    `
+for (let x = arr.length; x > 1; x -= 1) {}
+    `,
+    `
+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++;
+}
+    `,
+    `
+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];
+}
+    `,
+    `
+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 c = 0; c < arr.length; c++) {
+  doMath?.(c);
+}
+    `,
+    `
+for (var d = 0; d < arr.length; d++) doMath?.(d);
+    `,
+    `
+for (let i = 0; i < test.length; ++i) {
+  this[i];
+}
+    `,
+    `
+for (let i = 0; i < this.length; ++i) {
+  yield this[i];
+}
+    `,
+  ],
 });
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 3312f54970f9..792377467b90 100644
--- a/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
@@ -6,42 +6,6 @@ import rule, { phrases } from '../../src/rules/prefer-function-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-function-type', rule, {
-  valid: [
-    `
-interface Foo {
-  (): void;
-  bar: number;
-}
-    `,
-    `
-type Foo = {
-  (): void;
-  bar: number;
-};
-    `,
-    `
-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: [
     {
       code: `
@@ -51,11 +15,11 @@ interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -72,11 +36,11 @@ export default interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: null,
@@ -90,11 +54,11 @@ interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -111,11 +75,11 @@ export interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -132,11 +96,11 @@ export interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -152,11 +116,11 @@ function foo(bar: { /* comment */ (s: string): number } | undefined): number {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -173,11 +137,11 @@ type Foo = {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -192,11 +156,11 @@ function foo(bar: { (s: string): number }): number {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -213,11 +177,11 @@ function foo(bar: { (s: string): number } | undefined): number {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -234,11 +198,11 @@ interface Foo extends Function {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -253,11 +217,11 @@ interface Foo<T> {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -272,11 +236,11 @@ interface Foo<T> {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -289,11 +253,11 @@ type Foo<T> = { (this: string): T };
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -306,16 +270,16 @@ interface Foo {
   (arg: this): void;
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'unexpectedThisOnFunctionOnlyInterface',
-          type: AST_NODE_TYPES.TSThisType,
           data: {
             interfaceName: 'Foo',
           },
+          messageId: 'unexpectedThisOnFunctionOnlyInterface',
+          type: AST_NODE_TYPES.TSThisType,
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -323,16 +287,16 @@ interface Foo {
   (arg: number): this | undefined;
 }
       `,
-      output: null,
       errors: [
         {
-          messageId: 'unexpectedThisOnFunctionOnlyInterface',
-          type: AST_NODE_TYPES.TSThisType,
           data: {
             interfaceName: 'Foo',
           },
+          messageId: 'unexpectedThisOnFunctionOnlyInterface',
+          type: AST_NODE_TYPES.TSThisType,
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -351,11 +315,11 @@ interface Foo {
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSInterfaceDeclaration],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -377,11 +341,11 @@ type X = {} | { (): void; }
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -394,11 +358,11 @@ type X = {} & { (): void; };
       `,
       errors: [
         {
-          messageId: 'functionTypeOverCallableType',
-          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
           data: {
             literalOrInterface: phrases[AST_NODE_TYPES.TSTypeLiteral],
           },
+          messageId: 'functionTypeOverCallableType',
+          type: AST_NODE_TYPES.TSCallSignatureDeclaration,
         },
       ],
       output: `
@@ -406,4 +370,40 @@ type X = {} & (() => void);
       `,
     },
   ],
+
+  valid: [
+    `
+interface Foo {
+  (): void;
+  bar: number;
+}
+    `,
+    `
+type Foo = {
+  (): void;
+  bar: number;
+};
+    `,
+    `
+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;
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
index e22cd65be1aa..0dd67d146c14 100644
--- a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
@@ -8,96 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-includes', rule, {
-  valid: [
-    `
-      function f(a: string): void {
-        a.indexOf(b);
-      }
-    `,
-    `
-      function f(a: string): void {
-        a.indexOf(b) + 0;
-      }
-    `,
-    `
-      function f(a: string | { value: string }): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any): number; // don't have 'includes'
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes(x: any): boolean; // different parameters
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes(x: any, fromIndex: number): boolean; // different parameters
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes: boolean; // different type
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      function f(a: string): void {
-        /bar/i.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /ba[rz]/.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /foo|bar/.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /bar/.test();
-      }
-    `,
-    `
-      function f(a: string): void {
-        something.test(a);
-      }
-    `,
-    `
-      const pattern = new RegExp('bar');
-      function f(a) {
-        return pattern.test(a);
-      }
-    `,
-  ],
   invalid: [
     // positive
     {
@@ -106,12 +23,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -119,12 +36,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) != -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -132,12 +49,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) > -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -145,12 +62,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) >= 0;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
 
     // negative
@@ -160,12 +77,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) === -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           !a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -173,12 +90,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) == -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           !a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -186,12 +103,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) <= -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           !a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -199,12 +116,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) < 0;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: string): void {
           !a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -212,8 +129,8 @@ ruleTester.run('prefer-includes', rule, {
           a?.indexOf(b) === -1;
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferIncludes' }],
+      output: null,
     },
     {
       code: `
@@ -221,8 +138,8 @@ ruleTester.run('prefer-includes', rule, {
           a?.indexOf(b) !== -1;
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferIncludes' }],
+      output: null,
     },
 
     // RegExp#test
@@ -232,12 +149,12 @@ ruleTester.run('prefer-includes', rule, {
           /bar/.test(a);
         }
       `,
+      errors: [{ messageId: 'preferStringIncludes' }],
       output: `
         function f(a: string): void {
           a.includes('bar');
         }
       `,
-      errors: [{ messageId: 'preferStringIncludes' }],
     },
     // test SequenceExpression
     {
@@ -246,12 +163,12 @@ ruleTester.run('prefer-includes', rule, {
           /bar/.test((1 + 1, a));
         }
       `,
+      errors: [{ messageId: 'preferStringIncludes' }],
       output: `
         function f(a: string): void {
           (1 + 1, a).includes('bar');
         }
       `,
-      errors: [{ messageId: 'preferStringIncludes' }],
     },
     {
       code: `
@@ -259,12 +176,12 @@ ruleTester.run('prefer-includes', rule, {
           /\\0'\\\\\\n\\r\\v\\t\\f/.test(a);
         }
       `,
+      errors: [{ messageId: 'preferStringIncludes' }],
       output: `
         function f(a: string): void {
           a.includes('\\0\\'\\\\\\n\\r\\v\\t\\f');
         }
       `,
-      errors: [{ messageId: 'preferStringIncludes' }],
     },
     {
       code: `
@@ -273,13 +190,13 @@ ruleTester.run('prefer-includes', rule, {
           pattern.test(a);
         }
       `,
+      errors: [{ messageId: 'preferStringIncludes' }],
       output: `
         const pattern = new RegExp('bar');
         function f(a: string): void {
           a.includes('bar');
         }
       `,
-      errors: [{ messageId: 'preferStringIncludes' }],
     },
     {
       code: `
@@ -288,13 +205,13 @@ ruleTester.run('prefer-includes', rule, {
           pattern.test(a + b);
         }
       `,
+      errors: [{ messageId: 'preferStringIncludes' }],
       output: `
         const pattern = /bar/;
         function f(a: string, b: string): void {
           (a + b).includes('bar');
         }
       `,
-      errors: [{ messageId: 'preferStringIncludes' }],
     },
 
     // type variation
@@ -304,12 +221,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: any[]): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -317,12 +234,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: ReadonlyArray<any>): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -330,12 +247,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Int8Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -343,12 +260,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Int16Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -356,12 +273,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Int32Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -369,12 +286,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Uint8Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -382,12 +299,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Uint16Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -395,12 +312,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Uint32Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -408,12 +325,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Float32Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -421,12 +338,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Float64Array): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -434,12 +351,12 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f<T>(a: T[] | ReadonlyArray<T>): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -460,6 +377,7 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f<
           T,
@@ -478,7 +396,6 @@ ruleTester.run('prefer-includes', rule, {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -490,6 +407,7 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         type UserDefined = {
           indexOf(x: any): number;
@@ -499,7 +417,6 @@ ruleTester.run('prefer-includes', rule, {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
     {
       code: `
@@ -507,12 +424,95 @@ ruleTester.run('prefer-includes', rule, {
           a.indexOf(b) !== -1;
         }
       `,
+      errors: [{ messageId: 'preferIncludes' }],
       output: `
         function f(a: Readonly<any[]>): void {
           a.includes(b);
         }
       `,
-      errors: [{ messageId: 'preferIncludes' }],
     },
   ],
+  valid: [
+    `
+      function f(a: string): void {
+        a.indexOf(b);
+      }
+    `,
+    `
+      function f(a: string): void {
+        a.indexOf(b) + 0;
+      }
+    `,
+    `
+      function f(a: string | { value: string }): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any): number; // don't have 'includes'
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes(x: any): boolean; // different parameters
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes(x: any, fromIndex: number): boolean; // different parameters
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes: boolean; // different type
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/i.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /ba[rz]/.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /foo|bar/.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/.test();
+      }
+    `,
+    `
+      function f(a: string): void {
+        something.test(a);
+      }
+    `,
+    `
+      const pattern = new RegExp('bar');
+      function f(a) {
+        return pattern.test(a);
+      }
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts b/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
index 48a181618bed..0bfdc11ae56e 100644
--- a/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
@@ -5,116 +5,6 @@ import rule from '../../src/rules/prefer-literal-enum-member';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-literal-enum-member', rule, {
-  valid: [
-    `
-enum ValidRegex {
-  A = /test/,
-}
-    `,
-    `
-enum ValidString {
-  A = 'test',
-}
-    `,
-    `
-enum ValidLiteral {
-  A = \`test\`,
-}
-    `,
-    `
-enum ValidNumber {
-  A = 42,
-}
-    `,
-    `
-enum ValidNumber {
-  A = -42,
-}
-    `,
-    `
-enum ValidNumber {
-  A = +42,
-}
-    `,
-    `
-enum ValidNull {
-  A = null,
-}
-    `,
-    `
-enum ValidPlain {
-  A,
-}
-    `,
-    `
-enum ValidQuotedKey {
-  'a',
-}
-    `,
-    `
-enum ValidQuotedKeyWithAssignment {
-  'a' = 1,
-}
-    `,
-    noFormat`
-enum ValidKeyWithComputedSyntaxButNoComputedKey {
-  ['a'],
-}
-    `,
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = 1 >>> 0,
-  D = 1 | 0,
-  E = 1 & 0,
-  F = 1 ^ 0,
-  G = ~1,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = A | B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = Foo.A | Foo.B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = Foo['A'] | B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  ['A-1'] = 1 << 0,
-  C = ~Foo['A-1'],
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -124,9 +14,9 @@ enum InvalidObject {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -138,9 +28,9 @@ enum InvalidArray {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -152,9 +42,9 @@ enum InvalidTemplateLiteral {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -166,9 +56,9 @@ enum InvalidConstructor {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -180,9 +70,9 @@ enum InvalidExpression {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -198,29 +88,29 @@ enum InvalidExpression {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 6,
           column: 3,
+          line: 6,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 7,
           column: 3,
+          line: 7,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -236,9 +126,9 @@ enum InvalidVariable {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 7,
           column: 3,
+          line: 7,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -251,9 +141,9 @@ enum InvalidEnumMember {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -267,9 +157,9 @@ enum InvalidObjectMember {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -285,9 +175,9 @@ enum InvalidEnumMember {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 7,
           column: 3,
+          line: 7,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -301,9 +191,9 @@ enum InvalidSpread {
       `,
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
       ],
     },
@@ -319,44 +209,44 @@ enum Foo {
   G = ~1,
 }
       `,
-      options: [{ allowBitwiseExpressions: false }],
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 6,
           column: 3,
+          line: 6,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 7,
           column: 3,
+          line: 7,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 8,
           column: 3,
+          line: 8,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 9,
           column: 3,
+          line: 9,
+          messageId: 'notLiteral',
         },
       ],
+      options: [{ allowBitwiseExpressions: false }],
     },
     {
       code: `
@@ -371,44 +261,44 @@ enum Foo {
   G = ~x,
 }
       `,
-      options: [{ allowBitwiseExpressions: true }],
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 4,
           column: 3,
+          line: 4,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 6,
           column: 3,
+          line: 6,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 7,
           column: 3,
+          line: 7,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 8,
           column: 3,
+          line: 8,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 9,
           column: 3,
+          line: 9,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 10,
           column: 3,
+          line: 10,
+          messageId: 'notLiteral',
         },
       ],
+      options: [{ allowBitwiseExpressions: true }],
     },
     {
       code: `
@@ -419,19 +309,129 @@ enum Foo {
   C = x >> A,
 }
       `,
-      options: [{ allowBitwiseExpressions: true }],
       errors: [
         {
-          messageId: 'notLiteral',
-          line: 5,
           column: 3,
+          line: 5,
+          messageId: 'notLiteral',
         },
         {
-          messageId: 'notLiteral',
-          line: 6,
           column: 3,
+          line: 6,
+          messageId: 'notLiteral',
         },
       ],
+      options: [{ allowBitwiseExpressions: true }],
+    },
+  ],
+  valid: [
+    `
+enum ValidRegex {
+  A = /test/,
+}
+    `,
+    `
+enum ValidString {
+  A = 'test',
+}
+    `,
+    `
+enum ValidLiteral {
+  A = \`test\`,
+}
+    `,
+    `
+enum ValidNumber {
+  A = 42,
+}
+    `,
+    `
+enum ValidNumber {
+  A = -42,
+}
+    `,
+    `
+enum ValidNumber {
+  A = +42,
+}
+    `,
+    `
+enum ValidNull {
+  A = null,
+}
+    `,
+    `
+enum ValidPlain {
+  A,
+}
+    `,
+    `
+enum ValidQuotedKey {
+  'a',
+}
+    `,
+    `
+enum ValidQuotedKeyWithAssignment {
+  'a' = 1,
+}
+    `,
+    noFormat`
+enum ValidKeyWithComputedSyntaxButNoComputedKey {
+  ['a'],
+}
+    `,
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = 1 >>> 0,
+  D = 1 | 0,
+  E = 1 & 0,
+  F = 1 ^ 0,
+  G = ~1,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = A | B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = Foo.A | Foo.B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = Foo['A'] | B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  ['A-1'] = 1 << 0,
+  C = ~Foo['A-1'],
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
     },
   ],
 });
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 46ed3c4b7f4e..0ceb95d77cb5 100644
--- a/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
@@ -5,59 +5,59 @@ import rule from '../../src/rules/prefer-namespace-keyword';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-namespace-keyword', rule, {
-  valid: [
-    "declare module 'foo';",
-    "declare module 'foo' {}",
-    'namespace foo {}',
-    'declare namespace foo {}',
-    'declare global {}',
-  ],
   invalid: [
     {
       code: 'module foo {}',
-      output: 'namespace foo {}',
       errors: [
         {
-          messageId: 'useNamespace',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'useNamespace',
         },
       ],
+      output: 'namespace foo {}',
     },
     {
       code: 'declare module foo {}',
-      output: 'declare namespace foo {}',
       errors: [
         {
-          messageId: 'useNamespace',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'useNamespace',
         },
       ],
+      output: 'declare namespace foo {}',
     },
     {
       code: `
 declare module foo {
   declare module bar {}
-}
-      `,
-      output: `
-declare namespace foo {
-  declare namespace bar {}
 }
       `,
       errors: [
         {
-          messageId: 'useNamespace',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'useNamespace',
         },
         {
-          messageId: 'useNamespace',
-          line: 3,
           column: 3,
+          line: 3,
+          messageId: 'useNamespace',
         },
       ],
+      output: `
+declare namespace foo {
+  declare namespace bar {}
+}
+      `,
     },
   ],
+  valid: [
+    "declare module 'foo';",
+    "declare module 'foo' {}",
+    'namespace foo {}',
+    'declare namespace foo {}',
+    'declare global {}',
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts b/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
index da54f2881104..2988d9d7c0d5 100644
--- a/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
@@ -1,15 +1,16 @@
-import * as path from 'node:path';
-
 import type {
   InvalidTestCase,
   ValidTestCase,
 } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
+import * as path from 'node:path';
 
 import type {
   MessageIds,
   Options,
 } from '../../src/rules/prefer-nullish-coalescing';
+
 import rule from '../../src/rules/prefer-nullish-coalescing';
 import { getFixturesRootDir } from '../RuleTester';
 
@@ -18,8 +19,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -61,124 +62,390 @@ function nullishTypeInvalidTest(
 }
 
 ruleTester.run('prefer-nullish-coalescing', rule, {
-  valid: [
-    ...typeValidTest(
-      type => `
-declare const x: ${type};
+  invalid: [
+    ...nullishTypeInvalidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
 x || 'foo';
       `,
-    ),
-    ...nullishTypeValidTest(
-      (nullish, type) => `
+      errors: [
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
 declare const x: ${type} | ${nullish};
 x ?? 'foo';
       `,
-    ),
+            },
+          ],
+        },
+      ],
+      output: null,
+    })),
+
+    ...[
+      'x !== undefined && x !== null ? x : y;',
+      'x !== null && x !== undefined ? x : y;',
+      'x === undefined || x === null ? y : x;',
+      'x === null || x === undefined ? y : x;',
+      'undefined !== x && x !== null ? x : y;',
+      'null !== x && x !== undefined ? x : y;',
+      'undefined === x || x === null ? y : x;',
+      'null === x || x === undefined ? y : x;',
+      'x !== undefined && null !== x ? x : y;',
+      'x !== null && undefined !== x ? x : y;',
+      'x === undefined || null === x ? y : x;',
+      'x === null || undefined === x ? y : x;',
+      'undefined !== x && null !== x ? x : y;',
+      'null !== x && undefined !== x ? x : y;',
+      'undefined === x || null === x ? y : x;',
+      'null === x || undefined === x ? y : x;',
+      'x != undefined && x != null ? x : y;',
+      'x == undefined || x == null ? y : x;',
+      'x != undefined && x !== null ? x : y;',
+      'x == undefined || x === null ? y : x;',
+      'x !== undefined && x != null ? x : y;',
+      'undefined != x ? x : y;',
+      'null != x ? x : y;',
+      'undefined == x ? y : x;',
+      'null == x ? y : x;',
+      'x != undefined ? x : y;',
+      'x != null ? x : y;',
+      'x == undefined  ? y : x;',
+      'x == null ? y : x;',
+    ].flatMap(code => [
+      {
+        code,
+        errors: [
+          {
+            column: 1,
+            endColumn: code.length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x ?? y;',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+      {
+        code: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]'),
+        errors: [
+          {
+            column: 1,
+            endColumn: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]')
+              .length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x.z[1][this[this.o]]["3"][a.b.c] ?? y;',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+      {
+        code: code.replaceAll('y', '(z = y)'),
+        errors: [
+          {
+            column: 1,
+            endColumn: code.replaceAll('y', '(z = y)').length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x ?? (z = y);',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+    ]),
 
     {
-      code: 'x !== undefined && x !== null ? x : y;',
-      options: [{ ignoreTernaryTests: true }],
+      code: 'this != undefined ? this : y;',
+      errors: [
+        {
+          column: 1,
+          endColumn: 29,
+          endLine: 1,
+          line: 1,
+          messageId: 'preferNullishOverTernary' as const,
+          suggestions: [
+            {
+              messageId: 'suggestNullish' as const,
+              output: 'this ?? y;',
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreTernaryTests: false }] as const,
+      output: null,
     },
 
     ...[
-      'x !== undefined && x !== null ? "foo" : "bar";',
-      'x !== null && x !== undefined && x !== 5 ? x : y',
-      'x === null || x === undefined || x === 5 ? x : y',
-      'x === undefined && x !== null ? x : y;',
-      'x === undefined && x === null ? x : y;',
-      'x !== undefined && x === null ? x : y;',
-      'x === undefined || x !== null ? x : y;',
-      'x === undefined || x === null ? x : y;',
-      'x !== undefined || x === null ? x : y;',
-      'x !== undefined || x === null ? y : x;',
-      'x === null || x === null ? y : x;',
-      'x === undefined || x === undefined ? y : x;',
-      'x == null ? x : y;',
-      'undefined == null ? x : y;',
-      'undefined != z ? x : y;',
-      'x == undefined ? x : y;',
-      'x != null ? y : x;',
-      'x != undefined ? y : x;',
-      'null == x ? x : y;',
-      'undefined == x ? x : y;',
-      'null != x ? y : x;',
-      'undefined != x ? y : x;',
       `
-declare const x: string;
-x === null ? x : y;
+declare const x: string | undefined;
+x !== undefined ? x : y;
       `,
       `
 declare const x: string | undefined;
-x === null ? x : y;
+undefined !== x ? x : y;
       `,
       `
-declare const x: string | null;
-x === undefined ? x : y;
+declare const x: string | undefined;
+x === undefined ? y : x;
       `,
       `
-declare const x: string | undefined | null;
-x !== undefined ? x : y;
+declare const x: string | undefined;
+undefined === x ? y : x;
       `,
       `
-declare const x: string | undefined | null;
+declare const x: string | null;
 x !== null ? x : y;
       `,
       `
-declare const x: string | null | any;
-x === null ? x : y;
+declare const x: string | null;
+null !== x ? x : y;
       `,
       `
-declare const x: string | null | unknown;
-x === null ? x : y;
+declare const x: string | null;
+x === null ? y : x;
+      `,
+      `
+declare const x: string | null;
+null === x ? y : x;
       `,
     ].map(code => ({
       code,
+      errors: [
+        {
+          column: 1,
+          endColumn: code.split('\n')[2].length,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverTernary' as const,
+          suggestions: [
+            {
+              messageId: 'suggestNullish' as const,
+              output: `
+${code.split('\n')[1]}
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [{ ignoreTernaryTests: false }] as const,
+      output: null,
     })),
 
-    // ignoreConditionalTests
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-x || 'foo' ? null : null;
-      `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
+    // noStrictNullCheck
+    {
       code: `
-declare const x: ${type} | ${nullish};
-if (x || 'foo') {}
+declare const x: string[] | null;
+if (x) {
+}
       `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      output: null,
+    },
+
+    // ignoreConditionalTests
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-do {} while (x || 'foo')
+x || 'foo' ? null : null;
       `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
+      errors: [
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+x ?? 'foo' ? null : null;
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreConditionalTests: false }],
+      output: null,
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+if (x || 'foo') {}
+      `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+if (x ?? 'foo') {}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreConditionalTests: false }],
+      output: null,
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+do {} while (x || 'foo')
+      `,
+      errors: [
+        {
+          column: 16,
+          endColumn: 18,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+do {} while (x ?? 'foo')
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreConditionalTests: false }],
+      output: null,
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
 for (;x || 'foo';) {}
       `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+for (;x ?? 'foo';) {}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreConditionalTests: false }],
+      output: null,
     })),
-    ...nullishTypeValidTest((nullish, type) => ({
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
 while (x || 'foo') {}
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+while (x ?? 'foo') {}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreConditionalTests: false }],
+      output: null,
     })),
 
     // ignoreMixedLogicalExpressions
-    ...nullishTypeValidTest((nullish, type) => ({
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const a: ${type} | ${nullish};
 declare const b: ${type} | ${nullish};
 declare const c: ${type} | ${nullish};
 a || b && c;
       `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 5,
+          line: 5,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+a ?? b && c;
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreMixedLogicalExpressions: false }],
     })),
-    ...nullishTypeValidTest((nullish, type) => ({
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const a: ${type} | ${nullish};
 declare const b: ${type} | ${nullish};
@@ -186,771 +453,509 @@ declare const c: ${type} | ${nullish};
 declare const d: ${type} | ${nullish};
 a || b || c && d;
       `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
+      errors: [
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 6,
+          line: 6,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
 declare const a: ${type} | ${nullish};
 declare const b: ${type} | ${nullish};
 declare const c: ${type} | ${nullish};
 declare const d: ${type} | ${nullish};
-a && b || c || d;
-      `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: ${type} | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: { [type]: true } }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: ${type} | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: true }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: (${type} & { __brand?: any }) | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: { [type]: true } }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: (${type} & { __brand?: any }) | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: true }],
-    })),
-    `
-      declare const x: any;
-      declare const y: number;
-      x || y;
-    `,
-    `
-      declare const x: unknown;
-      declare const y: number;
-      x || y;
-    `,
-    `
-      declare const x: never;
-      declare const y: number;
-      x || y;
-    `,
-    {
-      code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
-x || y;
+(a ?? b) || c && d;
       `,
-      options: [
+            },
+          ],
+        },
         {
-          ignorePrimitives: {
-            string: true,
-            number: false,
-            boolean: true,
-            bigint: true,
-          },
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a || b ?? c && d;
+      `,
+            },
+          ],
         },
       ],
-    },
-    {
+      options: [{ ignoreMixedLogicalExpressions: false }],
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
-x || y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c || d;
       `,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: true,
-            boolean: true,
-            bigint: false,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-declare const x: 0 | 'foo' | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            number: true,
-            string: true,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-declare const x: 0 | 'foo' | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            number: true,
-            string: false,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            number: true,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum.A | Enum.B | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            number: true,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-          },
-        },
-      ],
-    },
-    {
-      code: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum.A | Enum.B | undefined;
-x || y;
-      `,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-          },
-        },
-      ],
-    },
-  ],
-  invalid: [
-    ...nullishTypeInvalidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-x || 'foo';
-      `,
-      output: null,
-      errors: [
+      errors: [
         {
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 3,
-          endLine: 3,
-          endColumn: 5,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-x ?? 'foo';
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && (b ?? c) || d;
       `,
             },
-          ],
-        },
-      ],
-    })),
-
-    ...[
-      'x !== undefined && x !== null ? x : y;',
-      'x !== null && x !== undefined ? x : y;',
-      'x === undefined || x === null ? y : x;',
-      'x === null || x === undefined ? y : x;',
-      'undefined !== x && x !== null ? x : y;',
-      'null !== x && x !== undefined ? x : y;',
-      'undefined === x || x === null ? y : x;',
-      'null === x || x === undefined ? y : x;',
-      'x !== undefined && null !== x ? x : y;',
-      'x !== null && undefined !== x ? x : y;',
-      'x === undefined || null === x ? y : x;',
-      'x === null || undefined === x ? y : x;',
-      'undefined !== x && null !== x ? x : y;',
-      'null !== x && undefined !== x ? x : y;',
-      'undefined === x || null === x ? y : x;',
-      'null === x || undefined === x ? y : x;',
-      'x != undefined && x != null ? x : y;',
-      'x == undefined || x == null ? y : x;',
-      'x != undefined && x !== null ? x : y;',
-      'x == undefined || x === null ? y : x;',
-      'x !== undefined && x != null ? x : y;',
-      'undefined != x ? x : y;',
-      'null != x ? x : y;',
-      'undefined == x ? y : x;',
-      'null == x ? y : x;',
-      'x != undefined ? x : y;',
-      'x != null ? x : y;',
-      'x == undefined  ? y : x;',
-      'x == null ? y : x;',
-    ].flatMap(code => [
-      {
-        code,
-        output: null,
-        options: [{ ignoreTernaryTests: false }] as const,
-        errors: [
-          {
-            messageId: 'preferNullishOverTernary' as const,
-            line: 1,
-            column: 1,
-            endLine: 1,
-            endColumn: code.length,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x ?? y;',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]'),
-        output: null,
-        options: [{ ignoreTernaryTests: false }] as const,
-        errors: [
-          {
-            messageId: 'preferNullishOverTernary' as const,
-            line: 1,
-            column: 1,
-            endLine: 1,
-            endColumn: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]')
-              .length,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x.z[1][this[this.o]]["3"][a.b.c] ?? y;',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: code.replaceAll('y', '(z = y)'),
-        output: null,
-        options: [{ ignoreTernaryTests: false }] as const,
-        errors: [
-          {
-            messageId: 'preferNullishOverTernary' as const,
-            line: 1,
-            column: 1,
-            endLine: 1,
-            endColumn: code.replaceAll('y', '(z = y)').length,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x ?? (z = y);',
-              },
-            ],
-          },
-        ],
-      },
-    ]),
-
-    {
-      code: 'this != undefined ? this : y;',
-      output: null,
-      options: [{ ignoreTernaryTests: false }] as const,
-      errors: [
-        {
-          messageId: 'preferNullishOverTernary' as const,
-          line: 1,
-          column: 1,
-          endLine: 1,
-          endColumn: 29,
-          suggestions: [
-            {
-              messageId: 'suggestNullish' as const,
-              output: 'this ?? y;',
-            },
-          ],
-        },
-      ],
-    },
-
-    ...[
-      `
-declare const x: string | undefined;
-x !== undefined ? x : y;
-      `,
-      `
-declare const x: string | undefined;
-undefined !== x ? x : y;
-      `,
-      `
-declare const x: string | undefined;
-x === undefined ? y : x;
-      `,
-      `
-declare const x: string | undefined;
-undefined === x ? y : x;
-      `,
-      `
-declare const x: string | null;
-x !== null ? x : y;
-      `,
-      `
-declare const x: string | null;
-null !== x ? x : y;
-      `,
-      `
-declare const x: string | null;
-x === null ? y : x;
-      `,
-      `
-declare const x: string | null;
-null === x ? y : x;
-      `,
-    ].map(code => ({
-      code,
-      output: null,
-      options: [{ ignoreTernaryTests: false }] as const,
-      errors: [
+          ],
+        },
         {
-          messageId: 'preferNullishOverTernary' as const,
-          line: 3,
-          column: 1,
-          endLine: 3,
-          endColumn: code.split('\n')[2].length,
+          column: 13,
+          endColumn: 15,
+          endLine: 6,
+          line: 6,
+          messageId: 'preferNullishOverOr',
           suggestions: [
             {
-              messageId: 'suggestNullish' as const,
+              messageId: 'suggestNullish',
               output: `
-${code.split('\n')[1]}
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c ?? d;
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreMixedLogicalExpressions: false }],
     })),
 
-    // noStrictNullCheck
-    {
+    // should not false positive for functions inside conditional tests
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: string[] | null;
-if (x) {
-}
+declare const x: ${type} | ${nullish};
+if (() => x || 'foo') {}
       `,
-      output: null,
       errors: [
         {
-          messageId: 'noStrictNullCheck',
-          line: 0,
-          column: 1,
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: ${type} | ${nullish};
+if (() => x ?? 'foo') {}
+      `,
+            },
+          ],
         },
       ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
-    },
-
-    // ignoreConditionalTests
+      output: null,
+    })),
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-x || 'foo' ? null : null;
+if (function werid() { return x || 'foo' }) {}
       `,
-      output: null,
-      options: [{ ignoreConditionalTests: false }],
       errors: [
         {
-          messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 3,
+          column: 33,
+          endColumn: 35,
           endLine: 3,
-          endColumn: 5,
+          line: 3,
+          messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
 declare const x: ${type} | ${nullish};
-x ?? 'foo' ? null : null;
+if (function werid() { return x ?? 'foo' }) {}
       `,
             },
           ],
         },
       ],
+      output: null,
     })),
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1290
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: ${type} | ${nullish};
-if (x || 'foo') {}
+declare const a: ${type} | ${nullish};
+declare const b: ${type};
+declare const c: ${type};
+a || b || c;
       `,
-      output: null,
-      options: [{ ignoreConditionalTests: false }],
       errors: [
         {
+          column: 3,
+          endColumn: 5,
+          endLine: 5,
+          line: 5,
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 7,
-          endLine: 3,
-          endColumn: 9,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-if (x ?? 'foo') {}
+declare const a: ${type} | ${nullish};
+declare const b: ${type};
+declare const c: ${type};
+(a ?? b) || c;
       `,
             },
           ],
         },
       ],
+      output: null,
     })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    // default for missing option
+    {
       code: `
-declare const x: ${type} | ${nullish};
-do {} while (x || 'foo')
+declare const x: string | undefined;
+x || y;
       `,
-      output: null,
-      options: [{ ignoreConditionalTests: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 16,
-          endLine: 3,
-          endColumn: 18,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-do {} while (x ?? 'foo')
+declare const x: string | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: { bigint: true, boolean: true, number: true },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const x: ${type} | ${nullish};
-for (;x || 'foo';) {}
+declare const x: number | undefined;
+x || y;
       `,
-      output: null,
-      options: [{ ignoreConditionalTests: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 9,
-          endLine: 3,
-          endColumn: 11,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-for (;x ?? 'foo';) {}
+declare const x: number | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: { bigint: true, boolean: true, string: true },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const x: ${type} | ${nullish};
-while (x || 'foo') {}
+declare const x: boolean | undefined;
+x || y;
       `,
-      output: null,
-      options: [{ ignoreConditionalTests: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 10,
-          endLine: 3,
-          endColumn: 12,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-while (x ?? 'foo') {}
+declare const x: boolean | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-
-    // ignoreMixedLogicalExpressions
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: { bigint: true, number: true, string: true },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-a || b && c;
+declare const x: bigint | undefined;
+x || y;
       `,
-      options: [{ ignoreMixedLogicalExpressions: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 5,
-          column: 3,
-          endLine: 5,
-          endColumn: 5,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-a ?? b && c;
+declare const x: bigint | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: { boolean: true, number: true, string: true },
+        },
+      ],
+      output: null,
+    },
+    // falsy
+    {
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a || b || c && d;
+declare const x: '' | undefined;
+x || y;
       `,
-      options: [{ ignoreMixedLogicalExpressions: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 6,
-          column: 3,
-          endLine: 6,
-          endColumn: 5,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-(a ?? b) || c && d;
+declare const x: '' | undefined;
+x ?? y;
       `,
             },
           ],
         },
+      ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: \`\` | undefined;
+x || y;
+      `,
+      errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 6,
-          column: 8,
-          endLine: 6,
-          endColumn: 10,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a || b ?? c && d;
+declare const x: \`\` | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && b || c || d;
+declare const x: 0 | undefined;
+x || y;
       `,
-      options: [{ ignoreMixedLogicalExpressions: false }],
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 6,
-          column: 8,
-          endLine: 6,
-          endColumn: 10,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && (b ?? c) || d;
+declare const x: 0 | undefined;
+x ?? y;
       `,
             },
           ],
         },
+      ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
+          },
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 0n | undefined;
+x || y;
+      `,
+      errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 6,
-          column: 13,
-          endLine: 6,
-          endColumn: 15,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && b || c ?? d;
+declare const x: 0n | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-
-    // should not false positive for functions inside conditional tests
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: false,
+            boolean: true,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const x: ${type} | ${nullish};
-if (() => x || 'foo') {}
+declare const x: false | undefined;
+x || y;
       `,
-      output: null,
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 13,
-          endLine: 3,
-          endColumn: 15,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-if (() => x ?? 'foo') {}
+declare const x: false | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: false,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+      output: null,
+    },
+    // truthy
+    {
       code: `
-declare const x: ${type} | ${nullish};
-if (function werid() { return x || 'foo' }) {}
+declare const x: 'a' | undefined;
+x || y;
       `,
-      output: null,
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 3,
-          column: 33,
-          endLine: 3,
-          endColumn: 35,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: ${type} | ${nullish};
-if (function werid() { return x ?? 'foo' }) {}
+declare const x: 'a' | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1290
-    ...nullishTypeInvalidTest((nullish, type) => ({
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
+        },
+      ],
+      output: null,
+    },
+    {
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type};
-declare const c: ${type};
-a || b || c;
+declare const x: \`hello\${'string'}\` | undefined;
+x || y;
       `,
-      output: null,
       errors: [
         {
           messageId: 'preferNullishOverOr',
-          line: 5,
-          column: 3,
-          endLine: 5,
-          endColumn: 5,
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type};
-declare const c: ${type};
-(a ?? b) || c;
+declare const x: \`hello\${'string'}\` | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-    })),
-    // default for missing option
-    {
-      code: `
-declare const x: string | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
-          ignorePrimitives: { number: true, boolean: true, bigint: true },
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 1 | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -958,25 +963,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: string | undefined;
+declare const x: 1 | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
+          },
+        },
+      ],
+      output: null,
     },
     {
       code: `
-declare const x: number | undefined;
+declare const x: 1n | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: { string: true, boolean: true, bigint: true },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -984,25 +994,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: number | undefined;
+declare const x: 1n | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: false,
+            boolean: true,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+      output: null,
     },
     {
       code: `
-declare const x: boolean | undefined;
+declare const x: true | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: { string: true, number: true, bigint: true },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1010,25 +1025,31 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: boolean | undefined;
+declare const x: true | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: false,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+      output: null,
     },
+    // Unions of same primitive
     {
       code: `
-declare const x: bigint | undefined;
+declare const x: 'a' | 'b' | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: { string: true, number: true, boolean: true },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1036,31 +1057,61 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: bigint | undefined;
+declare const x: 'a' | 'b' | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
+        },
+      ],
+      output: null,
     },
-    // falsy
     {
       code: `
-declare const x: '' | undefined;
+declare const x: 'a' | \`b\` | undefined;
 x || y;
       `,
-      output: null,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: 'a' | \`b\` | undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           ignorePrimitives: {
-            string: false,
-            number: true,
-            boolean: true,
             bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 0 | 1 | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1068,30 +1119,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: '' | undefined;
+declare const x: 0 | 1 | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: \`\` | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: false,
-            number: true,
-            boolean: true,
             bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 1 | 2 | 3 | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1099,30 +1150,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: \`\` | undefined;
+declare const x: 1 | 2 | 3 | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: 0 | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
-            number: false,
-            boolean: true,
             bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 0n | 1n | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1130,30 +1181,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0 | undefined;
+declare const x: 0n | 1n | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: 0n | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
-            number: true,
-            boolean: true,
             bigint: false,
+            boolean: true,
+            number: true,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: 1n | 2n | 3n | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1161,30 +1212,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0n | undefined;
+declare const x: 1n | 2n | 3n | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: false | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
+            bigint: false,
+            boolean: true,
             number: true,
-            boolean: false,
-            bigint: true,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: true | false | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1192,31 +1243,31 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: false | undefined;
+declare const x: true | false | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    // truthy
-    {
-      code: `
-declare const x: 'a' | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: false,
-            number: true,
-            boolean: true,
             bigint: true,
+            boolean: false,
+            number: true,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    // Mixed unions
+    {
+      code: `
+declare const x: 0 | 1 | 0n | 1n | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1224,30 +1275,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | undefined;
+declare const x: 0 | 1 | 0n | 1n | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: \`hello\${'string'}\` | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: false,
-            number: true,
+            bigint: false,
             boolean: true,
-            bigint: true,
+            number: false,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: true | false | null | undefined;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1255,30 +1306,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: \`hello\${'string'}\` | undefined;
+declare const x: true | false | null | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-declare const x: 1 | undefined;
-x || y;
-      `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
-            number: false,
-            boolean: true,
             bigint: true,
+            boolean: false,
+            number: true,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: null;
+x || y;
+      `,
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1286,30 +1337,20 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1 | undefined;
+declare const x: null;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 1n | undefined;
+const x = undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: true,
-            boolean: true,
-            bigint: false,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1317,30 +1358,19 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1n | undefined;
+const x = undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: true | undefined;
-x || y;
+null || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: true,
-            boolean: false,
-            bigint: true,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1348,31 +1378,18 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: true | undefined;
-x ?? y;
+null ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
-    // Unions of same primitive
     {
       code: `
-declare const x: 'a' | 'b' | undefined;
-x || y;
+undefined || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: false,
-            number: true,
-            boolean: true,
-            bigint: true,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1380,30 +1397,24 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | 'b' | undefined;
-x ?? y;
+undefined ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 'a' | \`b\` | undefined;
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: false,
-            number: true,
-            boolean: true,
-            bigint: true,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1411,30 +1422,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | \`b\` | undefined;
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 0 | 1 | undefined;
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: false,
-            boolean: true,
-            bigint: true,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1442,30 +1453,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0 | 1 | undefined;
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum.A | Enum.B | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 1 | 2 | 3 | undefined;
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: false,
-            boolean: true,
-            bigint: true,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1473,30 +1484,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1 | 2 | 3 | undefined;
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 0n | 1n | undefined;
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      output: null,
-      options: [
-        {
-          ignorePrimitives: {
-            string: true,
-            number: true,
-            boolean: true,
-            bigint: false,
-          },
-        },
-      ],
       errors: [
         {
           messageId: 'preferNullishOverOr',
@@ -1504,218 +1515,260 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0n | 1n | undefined;
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum.A | Enum.B | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      output: null,
+    },
+  ],
+  valid: [
+    ...typeValidTest(
+      type => `
+declare const x: ${type};
+x || 'foo';
+      `,
+    ),
+    ...nullishTypeValidTest(
+      (nullish, type) => `
+declare const x: ${type} | ${nullish};
+x ?? 'foo';
+      `,
+    ),
+
+    {
+      code: 'x !== undefined && x !== null ? x : y;',
+      options: [{ ignoreTernaryTests: true }],
     },
+
+    ...[
+      'x !== undefined && x !== null ? "foo" : "bar";',
+      'x !== null && x !== undefined && x !== 5 ? x : y',
+      'x === null || x === undefined || x === 5 ? x : y',
+      'x === undefined && x !== null ? x : y;',
+      'x === undefined && x === null ? x : y;',
+      'x !== undefined && x === null ? x : y;',
+      'x === undefined || x !== null ? x : y;',
+      'x === undefined || x === null ? x : y;',
+      'x !== undefined || x === null ? x : y;',
+      'x !== undefined || x === null ? y : x;',
+      'x === null || x === null ? y : x;',
+      'x === undefined || x === undefined ? y : x;',
+      'x == null ? x : y;',
+      'undefined == null ? x : y;',
+      'undefined != z ? x : y;',
+      'x == undefined ? x : y;',
+      'x != null ? y : x;',
+      'x != undefined ? y : x;',
+      'null == x ? x : y;',
+      'undefined == x ? x : y;',
+      'null != x ? y : x;',
+      'undefined != x ? y : x;',
+      `
+declare const x: string;
+x === null ? x : y;
+      `,
+      `
+declare const x: string | undefined;
+x === null ? x : y;
+      `,
+      `
+declare const x: string | null;
+x === undefined ? x : y;
+      `,
+      `
+declare const x: string | undefined | null;
+x !== undefined ? x : y;
+      `,
+      `
+declare const x: string | undefined | null;
+x !== null ? x : y;
+      `,
+      `
+declare const x: string | null | any;
+x === null ? x : y;
+      `,
+      `
+declare const x: string | null | unknown;
+x === null ? x : y;
+      `,
+    ].map(code => ({
+      code,
+      options: [{ ignoreTernaryTests: false }] as const,
+    })),
+
+    // ignoreConditionalTests
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+x || 'foo' ? null : null;
+      `,
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+if (x || 'foo') {}
+      `,
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+do {} while (x || 'foo')
+      `,
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+for (;x || 'foo';) {}
+      `,
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const x: ${type} | ${nullish};
+while (x || 'foo') {}
+      `,
+    })),
+
+    // ignoreMixedLogicalExpressions
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+a || b && c;
+      `,
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a || b || c && d;
+      `,
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c || d;
+      `,
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: ${type} | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: { [type]: true } }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: ${type} | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: true }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: (${type} & { __brand?: any }) | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: { [type]: true } }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: (${type} & { __brand?: any }) | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: true }],
+    })),
+    `
+      declare const x: any;
+      declare const y: number;
+      x || y;
+    `,
+    `
+      declare const x: unknown;
+      declare const y: number;
+      x || y;
+    `,
+    `
+      declare const x: never;
+      declare const y: number;
+      x || y;
+    `,
     {
       code: `
-declare const x: 1n | 2n | 3n | undefined;
+declare const x: 0 | 1 | 0n | 1n | undefined;
 x || y;
       `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
-            number: true,
+            bigint: true,
             boolean: true,
-            bigint: false,
+            number: false,
+            string: true,
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: 1n | 2n | 3n | undefined;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-declare const x: true | false | undefined;
+declare const x: 0 | 1 | 0n | 1n | undefined;
 x || y;
       `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
+            bigint: false,
+            boolean: true,
             number: true,
-            boolean: false,
-            bigint: true,
+            string: true,
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: true | false | undefined;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
     },
-    // Mixed unions
     {
       code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
+declare const x: 0 | 'foo' | undefined;
 x || y;
       `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
+            number: true,
             string: true,
-            number: false,
-            boolean: true,
-            bigint: false,
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-declare const x: true | false | null | undefined;
+declare const x: 0 | 'foo' | undefined;
 x || y;
       `,
-      output: null,
       options: [
         {
           ignorePrimitives: {
-            string: true,
             number: true,
-            boolean: false,
-            bigint: true,
+            string: false,
           },
         },
       ],
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: true | false | null | undefined;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const x: null;
-x || y;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: null;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-const x = undefined;
-x || y;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-const x = undefined;
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-null || y;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-null ?? y;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-undefined || y;
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-undefined ?? y;
-      `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
@@ -1727,24 +1780,11 @@ enum Enum {
 declare const x: Enum | undefined;
 x || y;
       `,
-      output: null,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum | undefined;
-x ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            number: true,
+          },
         },
       ],
     },
@@ -1758,24 +1798,11 @@ enum Enum {
 declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      output: null,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum.A | Enum.B | undefined;
-x ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            number: true,
+          },
         },
       ],
     },
@@ -1789,24 +1816,11 @@ enum Enum {
 declare const x: Enum | undefined;
 x || y;
       `,
-      output: null,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum | undefined;
-x ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            string: true,
+          },
         },
       ],
     },
@@ -1820,24 +1834,11 @@ enum Enum {
 declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      output: null,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum.A | Enum.B | undefined;
-x ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            string: true,
+          },
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/prefer-optional-chain/base-cases.ts b/packages/eslint-plugin/tests/rules/prefer-optional-chain/base-cases.ts
index 6cd8dd1a6945..e5883c31219d 100644
--- a/packages/eslint-plugin/tests/rules/prefer-optional-chain/base-cases.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-optional-chain/base-cases.ts
@@ -7,12 +7,12 @@ import type {
 
 type MutateFn = (c: string) => string;
 type BaseCaseCreator = (args: {
-  operator: '&&' | '||';
   mutateCode?: MutateFn;
-  mutateOutput?: MutateFn;
   mutateDeclaration?: MutateFn;
-  useSuggestionFixer?: true;
+  mutateOutput?: MutateFn;
+  operator: '&&' | '||';
   skipIds?: number[];
+  useSuggestionFixer?: true;
 }) => InvalidTestCase<
   PreferOptionalChainMessageIds,
   [PreferOptionalChainOptions]
@@ -22,220 +22,220 @@ const RawBaseCases = (operator: '&&' | '||') =>
   [
     // chained members
     {
-      id: 1,
-      declaration: 'declare const foo: {bar: number} | null | undefined;',
       chain: `foo ${operator} foo.bar;`,
+      declaration: 'declare const foo: {bar: number} | null | undefined;',
+      id: 1,
       outputChain: 'foo?.bar;',
     },
     {
-      id: 2,
+      chain: `foo.bar ${operator} foo.bar.baz;`,
       declaration:
         'declare const foo: {bar: {baz: number} | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar.baz;`,
+      id: 2,
       outputChain: 'foo.bar?.baz;',
     },
     {
-      id: 3,
-      declaration: 'declare const foo: (() => number) | null | undefined;',
       chain: `foo ${operator} foo();`,
+      declaration: 'declare const foo: (() => number) | null | undefined;',
+      id: 3,
       outputChain: 'foo?.();',
     },
     {
-      id: 4,
+      chain: `foo.bar ${operator} foo.bar();`,
       declaration:
         'declare const foo: {bar: (() => number) | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar();`,
+      id: 4,
       outputChain: 'foo.bar?.();',
     },
     {
-      id: 5,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number} | null | undefined} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
+      id: 5,
       outputChain: 'foo?.bar?.baz?.buzz;',
     },
     {
-      id: 6,
+      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number} | null | undefined} | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
+      id: 6,
       outputChain: 'foo.bar?.baz?.buzz;',
     },
     // case with a jump (i.e. a non-nullish prop)
     {
-      id: 7,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number}} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz;`,
+      id: 7,
       outputChain: 'foo?.bar?.baz.buzz;',
     },
     {
-      id: 8,
+      chain: `foo.bar ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number}} | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar.baz.buzz;`,
+      id: 8,
       outputChain: 'foo.bar?.baz.buzz;',
     },
     // case where for some reason there is a doubled up expression
     {
-      id: 9,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number} | null | undefined} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
+      id: 9,
       outputChain: 'foo?.bar?.baz?.buzz;',
     },
     {
-      id: 10,
+      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: number} | null | undefined} | null | undefined} | null | undefined;',
-      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz;`,
+      id: 10,
       outputChain: 'foo.bar?.baz?.buzz;',
     },
     // chained members with element access
     {
-      id: 11,
+      chain: `foo ${operator} foo[bar] ${operator} foo[bar].baz ${operator} foo[bar].baz.buzz;`,
       declaration: [
         'declare const bar: string;',
         'declare const foo: {[k: string]: {baz: {buzz: number} | null | undefined} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo[bar] ${operator} foo[bar].baz ${operator} foo[bar].baz.buzz;`,
+      id: 11,
       outputChain: 'foo?.[bar]?.baz?.buzz;',
     },
     {
       id: 12,
       // case with a jump (i.e. a non-nullish prop)
+      chain: `foo ${operator} foo[bar].baz ${operator} foo[bar].baz.buzz;`,
       declaration: [
         'declare const bar: string;',
         'declare const foo: {[k: string]: {baz: {buzz: number} | null | undefined} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo[bar].baz ${operator} foo[bar].baz.buzz;`,
       outputChain: 'foo?.[bar].baz?.buzz;',
     },
     // case with a property access in computed property
     {
-      id: 13,
+      chain: `foo ${operator} foo[bar.baz] ${operator} foo[bar.baz].buzz;`,
       declaration: [
         'declare const bar: {baz: string};',
         'declare const foo: {[k: string]: {buzz: number} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo[bar.baz] ${operator} foo[bar.baz].buzz;`,
+      id: 13,
       outputChain: 'foo?.[bar.baz]?.buzz;',
     },
     // chained calls
     {
-      id: 14,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: () => number} | null | undefined} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz();`,
+      id: 14,
       outputChain: 'foo?.bar?.baz?.buzz();',
     },
     {
-      id: 15,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: (() => number) | null | undefined} | null | undefined} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
+      id: 15,
       outputChain: 'foo?.bar?.baz?.buzz?.();',
     },
     {
-      id: 16,
+      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: (() => number) | null | undefined} | null | undefined} | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
+      id: 16,
       outputChain: 'foo.bar?.baz?.buzz?.();',
     },
     // case with a jump (i.e. a non-nullish prop)
     {
-      id: 17,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: () => number}} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz();`,
+      id: 17,
       outputChain: 'foo?.bar?.baz.buzz();',
     },
     {
-      id: 18,
+      chain: `foo.bar ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: () => number}} | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar.baz.buzz();`,
+      id: 18,
       outputChain: 'foo.bar?.baz.buzz();',
     },
     {
       id: 19,
       // case with a jump (i.e. a non-nullish prop)
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
       declaration:
         'declare const foo: {bar: {baz: {buzz: (() => number) | null | undefined}} | null | undefined} | null | undefined;',
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz.buzz ${operator} foo.bar.baz.buzz();`,
       outputChain: 'foo?.bar?.baz.buzz?.();',
     },
     {
       id: 20,
       // case with a call expr inside the chain for some inefficient reason
+      chain: `foo.bar ${operator} foo.bar() ${operator} foo.bar().baz ${operator} foo.bar().baz.buzz ${operator} foo.bar().baz.buzz();`,
       declaration:
         'declare const foo: {bar: () => ({baz: {buzz: (() => number) | null | undefined} | null | undefined}) | null | undefined};',
-      chain: `foo.bar ${operator} foo.bar() ${operator} foo.bar().baz ${operator} foo.bar().baz.buzz ${operator} foo.bar().baz.buzz();`,
       outputChain: 'foo.bar?.()?.baz?.buzz?.();',
     },
     // chained calls with element access
     {
-      id: 21,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz[buzz]();`,
       declaration: [
         'declare const buzz: string;',
         'declare const foo: {bar: {baz: {[k: string]: () => number} | null | undefined} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz[buzz]();`,
+      id: 21,
       outputChain: 'foo?.bar?.baz?.[buzz]();',
     },
     {
-      id: 22,
+      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz[buzz] ${operator} foo.bar.baz[buzz]();`,
       declaration: [
         'declare const buzz: string;',
         'declare const foo: {bar: {baz: {[k: string]: (() => number) | null | undefined} | null | undefined} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo.bar ${operator} foo.bar.baz ${operator} foo.bar.baz[buzz] ${operator} foo.bar.baz[buzz]();`,
+      id: 22,
       outputChain: 'foo?.bar?.baz?.[buzz]?.();',
     },
     // (partially) pre-optional chained
     {
-      id: 23,
+      chain: `foo ${operator} foo?.bar ${operator} foo?.bar.baz ${operator} foo?.bar.baz[buzz] ${operator} foo?.bar.baz[buzz]();`,
       declaration: [
         'declare const buzz: string;',
         'declare const foo: {bar: {baz: {[k: string]: (() => number) | null | undefined} | null | undefined} | null | undefined} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo?.bar ${operator} foo?.bar.baz ${operator} foo?.bar.baz[buzz] ${operator} foo?.bar.baz[buzz]();`,
+      id: 23,
       outputChain: 'foo?.bar?.baz?.[buzz]?.();',
     },
     {
-      id: 24,
+      chain: `foo ${operator} foo?.bar.baz ${operator} foo?.bar.baz[buzz];`,
       declaration: [
         'declare const buzz: string;',
         'declare const foo: {bar: {baz: {[k: string]: number} | null | undefined}} | null | undefined;',
       ].join('\n'),
-      chain: `foo ${operator} foo?.bar.baz ${operator} foo?.bar.baz[buzz];`,
+      id: 24,
       outputChain: 'foo?.bar.baz?.[buzz];',
     },
     {
-      id: 25,
+      chain: `foo ${operator} foo?.() ${operator} foo?.().bar;`,
       declaration:
         'declare const foo: (() => ({bar: number} | null | undefined)) | null | undefined;',
-      chain: `foo ${operator} foo?.() ${operator} foo?.().bar;`,
+      id: 25,
       outputChain: 'foo?.()?.bar;',
     },
     {
-      id: 26,
+      chain: `foo.bar ${operator} foo.bar?.() ${operator} foo.bar?.().baz;`,
       declaration:
         'declare const foo: {bar: () => ({baz: number} | null | undefined)};',
-      chain: `foo.bar ${operator} foo.bar?.() ${operator} foo.bar?.().baz;`,
+      id: 26,
       outputChain: 'foo.bar?.()?.baz;',
     },
   ] as const;
 
 export const identity: MutateFn = c => c;
 export const BaseCases: BaseCaseCreator = ({
-  operator,
   mutateCode = identity,
-  mutateOutput = mutateCode,
   mutateDeclaration = identity,
-  useSuggestionFixer = false,
+  mutateOutput = mutateCode,
+  operator,
   skipIds = [],
+  useSuggestionFixer = false,
 }) => {
   const skipIdsSet = new Set(skipIds);
   const skipSpecifiedIds: (
@@ -249,9 +249,9 @@ export const BaseCases: BaseCaseCreator = ({
     .filter(skipSpecifiedIds)
     .map(
       ({
-        id,
-        declaration: originalDeclaration,
         chain,
+        declaration: originalDeclaration,
+        id,
         outputChain,
       }): InvalidTestCase<
         PreferOptionalChainMessageIds,
@@ -263,7 +263,6 @@ export const BaseCases: BaseCaseCreator = ({
 
         return {
           code,
-          output: useSuggestionFixer ? null : output,
           errors: [
             {
               messageId: 'preferOptionalChain',
@@ -277,6 +276,7 @@ export const BaseCases: BaseCaseCreator = ({
                   ],
             },
           ],
+          output: useSuggestionFixer ? null : output,
         };
       },
     );
diff --git a/packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts b/packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts
index 592ca2337513..c05f6218b24c 100644
--- a/packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts
@@ -16,58 +16,14 @@ const ruleTester = new RuleTester({
 
 describe('|| {}', () => {
   ruleTester.run('prefer-optional-chain', rule, {
-    valid: [
-      'foo || {};',
-      'foo || ({} as any);',
-      '(foo || {})?.bar;',
-      '(foo || { bar: 1 }).bar;',
-      '(undefined && (foo || {})).bar;',
-      'foo ||= bar || {};',
-      'foo ||= bar?.baz || {};',
-      '(foo1 ? foo2 : foo3 || {}).foo4;',
-      '(foo = 2 || {}).bar;',
-      'func(foo || {}).bar;',
-      'foo ?? {};',
-      '(foo ?? {})?.bar;',
-      'foo ||= bar ?? {};',
-      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
-      `
-        const a = null;
-        const b = 0;
-        a === undefined || b === null || b === undefined;
-      `,
-      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
-      `
-        const a = 0;
-        const b = 0;
-        a === undefined || b === undefined || b === null;
-      `,
-      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
-      `
-        const a = 0;
-        const b = 0;
-        b === null || a === undefined || b === undefined;
-      `,
-      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
-      `
-        const b = 0;
-        b === null || b === undefined;
-      `,
-      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
-      `
-        const a = 0;
-        const b = 0;
-        b != null && a !== null && a !== undefined;
-      `,
-    ],
     invalid: [
       {
         code: '(foo || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 16,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo?.bar;' },
             ],
@@ -78,9 +34,9 @@ describe('|| {}', () => {
         code: noFormat`(foo || ({})).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 18,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo?.bar;' },
             ],
@@ -91,9 +47,9 @@ describe('|| {}', () => {
         code: noFormat`(await foo || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 22,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -107,9 +63,9 @@ describe('|| {}', () => {
         code: '(foo1?.foo2 || {}).foo3;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 24,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -123,9 +79,9 @@ describe('|| {}', () => {
         code: noFormat`(foo1?.foo2 || ({})).foo3;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 26,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -139,9 +95,9 @@ describe('|| {}', () => {
         code: '((() => foo())() || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 28,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -155,9 +111,9 @@ describe('|| {}', () => {
         code: 'const foo = (bar || {}).baz;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 13,
             endColumn: 28,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -171,9 +127,9 @@ describe('|| {}', () => {
         code: '(foo.bar || {})[baz];',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 21,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo.bar?.[baz];' },
             ],
@@ -184,9 +140,9 @@ describe('|| {}', () => {
         code: '((foo1 || {}).foo2 || {}).foo3;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 31,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -195,9 +151,9 @@ describe('|| {}', () => {
             ],
           },
           {
-            messageId: 'preferOptionalChain',
             column: 2,
             endColumn: 19,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -225,9 +181,9 @@ describe('|| {}', () => {
         code: '(foo() || bar || {}).baz;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 25,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -241,9 +197,9 @@ describe('|| {}', () => {
         code: '((foo1 ? foo2 : foo3) || {}).foo4;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 34,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -261,9 +217,9 @@ describe('|| {}', () => {
         `,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 13,
             endColumn: 28,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -285,9 +241,9 @@ describe('|| {}', () => {
         `,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 15,
             endColumn: 30,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -305,9 +261,9 @@ describe('|| {}', () => {
         code: noFormat`(undefined && foo || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 29,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -321,9 +277,9 @@ describe('|| {}', () => {
         code: '(foo ?? {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 16,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo?.bar;' },
             ],
@@ -334,9 +290,9 @@ describe('|| {}', () => {
         code: noFormat`(foo ?? ({})).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 18,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo?.bar;' },
             ],
@@ -347,9 +303,9 @@ describe('|| {}', () => {
         code: noFormat`(await foo ?? {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 22,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -363,9 +319,9 @@ describe('|| {}', () => {
         code: '(foo1?.foo2 ?? {}).foo3;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 24,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -379,9 +335,9 @@ describe('|| {}', () => {
         code: '((() => foo())() ?? {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 28,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -395,9 +351,9 @@ describe('|| {}', () => {
         code: 'const foo = (bar ?? {}).baz;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 13,
             endColumn: 28,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -411,9 +367,9 @@ describe('|| {}', () => {
         code: '(foo.bar ?? {})[baz];',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 21,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: 'foo.bar?.[baz];' },
             ],
@@ -424,9 +380,9 @@ describe('|| {}', () => {
         code: '((foo1 ?? {}).foo2 ?? {}).foo3;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 31,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -435,9 +391,9 @@ describe('|| {}', () => {
             ],
           },
           {
-            messageId: 'preferOptionalChain',
             column: 2,
             endColumn: 19,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -465,9 +421,9 @@ describe('|| {}', () => {
         code: '(foo() ?? bar ?? {}).baz;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 25,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -481,9 +437,9 @@ describe('|| {}', () => {
         code: '((foo1 ? foo2 : foo3) ?? {}).foo4;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 34,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -497,9 +453,9 @@ describe('|| {}', () => {
         code: noFormat`if (foo) { (foo ?? {}).bar; }`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 12,
             endColumn: 27,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -513,9 +469,9 @@ describe('|| {}', () => {
         code: noFormat`if ((foo ?? {}).bar) { foo.bar; }`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 5,
             endColumn: 20,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -529,9 +485,9 @@ describe('|| {}', () => {
         code: noFormat`(undefined && foo ?? {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 29,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -545,9 +501,9 @@ describe('|| {}', () => {
         code: '(a > b || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 18,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(a > b)?.bar;' },
             ],
@@ -558,9 +514,9 @@ describe('|| {}', () => {
         code: noFormat`(((typeof x) as string) || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 35,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -574,9 +530,9 @@ describe('|| {}', () => {
         code: '(void foo() || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 23,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -590,9 +546,9 @@ describe('|| {}', () => {
         code: '((a ? b : c) || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 24,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -606,9 +562,9 @@ describe('|| {}', () => {
         code: noFormat`((a instanceof Error) || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 33,
+            messageId: 'preferOptionalChain',
             suggestions: [
               {
                 messageId: 'optionalChainSuggest',
@@ -622,9 +578,9 @@ describe('|| {}', () => {
         code: noFormat`((a << b) || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 21,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(a << b)?.bar;' },
             ],
@@ -635,9 +591,9 @@ describe('|| {}', () => {
         code: noFormat`((foo ** 2) || {}).bar;`,
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 23,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(foo ** 2)?.bar;' },
             ],
@@ -648,9 +604,9 @@ describe('|| {}', () => {
         code: '(foo ** 2 || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 21,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(foo ** 2)?.bar;' },
             ],
@@ -661,9 +617,9 @@ describe('|| {}', () => {
         code: '(foo++ || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 18,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(foo++)?.bar;' },
             ],
@@ -674,9 +630,9 @@ describe('|| {}', () => {
         code: '(+foo || {}).bar;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 17,
+            messageId: 'preferOptionalChain',
             suggestions: [
               { messageId: 'optionalChainSuggest', output: '(+foo)?.bar;' },
             ],
@@ -695,264 +651,71 @@ describe('|| {}', () => {
         ],
       },
     ],
+    valid: [
+      'foo || {};',
+      'foo || ({} as any);',
+      '(foo || {})?.bar;',
+      '(foo || { bar: 1 }).bar;',
+      '(undefined && (foo || {})).bar;',
+      'foo ||= bar || {};',
+      'foo ||= bar?.baz || {};',
+      '(foo1 ? foo2 : foo3 || {}).foo4;',
+      '(foo = 2 || {}).bar;',
+      'func(foo || {}).bar;',
+      'foo ?? {};',
+      '(foo ?? {})?.bar;',
+      'foo ||= bar ?? {};',
+      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
+      `
+        const a = null;
+        const b = 0;
+        a === undefined || b === null || b === undefined;
+      `,
+      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
+      `
+        const a = 0;
+        const b = 0;
+        a === undefined || b === undefined || b === null;
+      `,
+      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
+      `
+        const a = 0;
+        const b = 0;
+        b === null || a === undefined || b === undefined;
+      `,
+      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
+      `
+        const b = 0;
+        b === null || b === undefined;
+      `,
+      // https://github.com/typescript-eslint/typescript-eslint/issues/8380
+      `
+        const a = 0;
+        const b = 0;
+        b != null && a !== null && a !== undefined;
+      `,
+    ],
   });
 });
 
 describe('hand-crafted cases', () => {
   ruleTester.run('prefer-optional-chain', rule, {
-    valid: [
-      '!a || !b;',
-      '!a || a.b;',
-      '!a && a.b;',
-      '!a && !a.b;',
-      '!a.b || a.b?.();',
-      '!a.b || a.b();',
-      'foo ||= bar;',
-      'foo ||= bar?.baz;',
-      'foo ||= bar?.baz?.buzz;',
-      '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;',
-      "typeof foo === 'number' && foo.toFixed();",
-      "foo === 'undefined' && foo.length;",
-      'foo == bar && foo.bar == null;',
-      'foo === 1 && foo.toFixed();',
-      // call arguments are considered
-      'foo.bar(a) && foo.bar(a, b).baz;',
-      // type parameters are considered
-      'foo.bar<a>() && foo.bar<a, b>().baz;',
-      // array elements are considered
-      '[1, 2].length && [1, 2, 3].length.toFixed();',
-      noFormat`[1,].length && [1, 2].length.toFixed();`,
-      // short-circuiting chains are considered
-      '(foo?.a).b && foo.a.b.c;',
-      '(foo?.a)() && foo.a().b;',
-      '(foo?.a)() && foo.a()();',
-      // looks like a chain, but isn't actually a chain - just a pair of strict nullish checks
-      'foo !== null && foo !== undefined;',
-      "x['y'] !== undefined && x['y'] !== null;",
-      // private properties
-      'this.#a && this.#b;',
-      '!this.#a || !this.#b;',
-      'a.#foo?.bar;',
-      '!a.#foo?.bar;',
-      '!foo().#a || a;',
-      '!a.b.#a || a;',
-      '!new A().#b || a;',
-      '!(await a).#b || a;',
-      "!(foo as any).bar || 'anything';",
-      // computed properties should be interrogated and correctly ignored
-      '!foo[1 + 1] || !foo[1 + 2];',
-      '!foo[1 + 1] || !foo[1 + 2].foo;',
-      // currently do not handle 'this' as the first part of a chain
-      'this && this.foo;',
-      '!this || !this.foo;',
-      '!entity.__helper!.__initialized || options.refresh;',
-      'import.meta || true;',
-      'import.meta || import.meta.foo;',
-      '!import.meta && false;',
-      '!import.meta && !import.meta.foo;',
-      'new.target || new.target.length;',
-      '!new.target || true;',
-      // Do not handle direct optional chaining on private properties because this TS limitation (https://github.com/microsoft/TypeScript/issues/42734)
-      'foo && foo.#bar;',
-      '!foo || !foo.#bar;',
-      // weird non-constant cases are ignored
-      '({}) && {}.toString();',
-      '[] && [].length;',
-      '(() => {}) && (() => {}).name;',
-      '(function () {}) && function () {}.name;',
-      '(class Foo {}) && class Foo {}.constructor;',
-      "new Map().get('a') && new Map().get('a').what;",
-      // https://github.com/typescript-eslint/typescript-eslint/issues/7654
-      'data && data.value !== null;',
+    invalid: [
+      // two  errors
       {
-        code: '<div /> && (<div />).wtf;',
-        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
-        filename: 'react.tsx',
+        code: noFormat`foo && foo.bar && foo.bar.baz || baz && baz.bar && baz.bar.foo`,
+        errors: [
+          { messageId: 'preferOptionalChain', suggestions: null },
+          { messageId: 'preferOptionalChain', suggestions: null },
+        ],
+        output: 'foo?.bar?.baz || baz?.bar?.foo',
       },
-      {
-        code: '<></> && (<></>).wtf;',
-        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
-        filename: 'react.tsx',
-      },
-      'foo[x++] && foo[x++].bar;',
-      'foo[yield x] && foo[yield x].bar;',
-      'a = b && (a = b).wtf;',
-      // TODO - should we handle this?
-      '(x || y) != null && (x || y).foo;',
-      // TODO - should we handle this?
-      '(await foo) && (await foo).bar;',
-      {
-        code: `
-          declare const x: string;
-          x && x.length;
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo: string;
-          foo && foo.toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const x: string | number | boolean | object;
-          x && x.toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo: { bar: string };
-          foo && foo.bar && foo.bar.toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo: string;
-          foo && foo.toString() && foo.toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo: { bar: string };
-          foo && foo.bar && foo.bar.toString() && foo.bar.toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo1: { bar: string | null };
-          foo1 && foo1.bar;
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const foo: string;
-          (foo || {}).toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-
-      {
-        code: `
-          declare const foo: string | null;
-          (foo || 'a' || {}).toString();
-        `,
-        options: [{ requireNullish: true }],
-      },
-      {
-        code: `
-          declare const x: any;
-          x && x.length;
-        `,
-        options: [{ checkAny: false }],
-      },
-      {
-        code: `
-          declare const x: bigint;
-          x && x.length;
-        `,
-        options: [{ checkBigInt: false }],
-      },
-      {
-        code: `
-          declare const x: boolean;
-          x && x.length;
-        `,
-        options: [{ checkBoolean: false }],
-      },
-      {
-        code: `
-          declare const x: number;
-          x && x.length;
-        `,
-        options: [{ checkNumber: false }],
-      },
-      {
-        code: `
-          declare const x: string;
-          x && x.length;
-        `,
-        options: [{ checkString: false }],
-      },
-      {
-        code: `
-          declare const x: unknown;
-          x && x.length;
-        `,
-        options: [{ checkUnknown: false }],
-      },
-      '(x = {}) && (x.y = true) != null && x.y.toString();',
-      "('x' as `${'x'}`) && ('x' as `${'x'}`).length;",
-      '`x` && `x`.length;',
-      '`x${a}` && `x${a}`.length;',
-
-      // falsy unions should be ignored
-      `
-        declare const x: false | { a: string };
-        x && x.a;
-      `,
-      `
-        declare const x: false | { a: string };
-        !x || x.a;
-      `,
-      `
-        declare const x: '' | { a: string };
-        x && x.a;
-      `,
-      `
-        declare const x: '' | { a: string };
-        !x || x.a;
-      `,
-      `
-        declare const x: 0 | { a: string };
-        x && x.a;
-      `,
-      `
-        declare const x: 0 | { a: string };
-        !x || x.a;
-      `,
-      `
-        declare const x: 0n | { a: string };
-        x && x.a;
-      `,
-      `
-        declare const x: 0n | { a: string };
-        !x || x.a;
-      `,
-      "typeof globalThis !== 'undefined' && globalThis.Array();",
-    ],
-    invalid: [
-      // two  errors
-      {
-        code: noFormat`foo && foo.bar && foo.bar.baz || baz && baz.bar && baz.bar.foo`,
-        output: 'foo?.bar?.baz || baz?.bar?.foo',
-        errors: [
-          { messageId: 'preferOptionalChain', suggestions: null },
-          { messageId: 'preferOptionalChain', suggestions: null },
-        ],
-      },
-      // case with inconsistent checks should "break" the chain
+      // case with inconsistent checks should "break" the chain
       {
         code: 'foo && foo.bar != null && foo.bar.baz !== undefined && foo.bar.baz.buzz;',
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output:
           'foo?.bar != null && foo.bar.baz !== undefined && foo.bar.baz.buzz;',
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
@@ -961,77 +724,77 @@ describe('hand-crafted cases', () => {
             foo.bar.baz.qux !== undefined &&
             foo.bar.baz.qux.buzz;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           foo.bar?.baz != null &&
             foo.bar.baz.qux !== undefined &&
             foo.bar.baz.qux.buzz;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // ensure essential whitespace isn't removed
       {
         code: 'foo && foo.bar(baz => <This Requires Spaces />);',
-        output: 'foo?.bar(baz => <This Requires Spaces />);',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
-        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+        output: 'foo?.bar(baz => <This Requires Spaces />);',
       },
       {
         code: 'foo && foo.bar(baz => typeof baz);',
-        output: 'foo?.bar(baz => typeof baz);',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar(baz => typeof baz);',
       },
       {
         code: "foo && foo['some long string'] && foo['some long string'].baz;",
-        output: "foo?.['some long string']?.baz;",
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        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', suggestions: null }],
+        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', suggestions: null }],
+        output: 'foo?.[`some ${long} string`]?.baz;',
       },
       // complex computed properties should be handled correctly
       {
         code: 'foo && foo[bar as string] && foo[bar as string].baz;',
-        output: 'foo?.[bar as string]?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.[bar as string]?.baz;',
       },
       {
         code: 'foo && foo[1 + 2] && foo[1 + 2].baz;',
-        output: 'foo?.[1 + 2]?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.[1 + 2]?.baz;',
       },
       {
         code: 'foo && foo[typeof bar] && foo[typeof bar].baz;',
-        output: 'foo?.[typeof bar]?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.[typeof bar]?.baz;',
       },
       {
         code: 'foo && foo.bar(a) && foo.bar(a, b).baz;',
-        output: 'foo?.bar(a) && foo.bar(a, b).baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar(a) && foo.bar(a, b).baz;',
       },
       {
         code: 'foo() && foo()(bar);',
-        output: 'foo()?.(bar);',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo()?.(bar);',
       },
       // type parameters are considered
       {
         code: 'foo && foo<string>() && foo<string>().bar;',
-        output: 'foo?.<string>()?.bar;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.<string>()?.bar;',
       },
       {
         code: 'foo && foo<string>() && foo<string, number>().bar;',
-        output: 'foo?.<string>() && foo<string, number>().bar;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.<string>() && foo<string, number>().bar;',
       },
       // should preserve comments in a call expression
       {
@@ -1040,95 +803,95 @@ describe('hand-crafted cases', () => {
             // comment2
             b, );
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           foo?.bar(/* comment */a,
             // comment2
             b, );
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // ensure binary expressions that are the last expression do not get removed
       // these get autofixers because the trailing binary means the type doesn't matter
       {
         code: 'foo && foo.bar != null;',
-        output: 'foo?.bar != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar != null;',
       },
       {
         code: 'foo && foo.bar != undefined;',
-        output: 'foo?.bar != undefined;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar != undefined;',
       },
       {
         code: 'foo && foo.bar != null && baz;',
-        output: 'foo?.bar != null && baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar != null && baz;',
       },
       // case with this keyword at the start of expression
       {
         code: 'this.bar && this.bar.baz;',
-        output: 'this.bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'this.bar?.baz;',
       },
       // other weird cases
       {
         code: 'foo && foo?.();',
-        output: 'foo?.();',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.();',
       },
       {
         code: 'foo.bar && foo.bar?.();',
-        output: 'foo.bar?.();',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo.bar?.();',
       },
       {
         code: 'foo && foo.bar(baz => <This Requires Spaces />);',
-        output: 'foo?.bar(baz => <This Requires Spaces />);',
         errors: [
           {
-            messageId: 'preferOptionalChain',
-            line: 1,
             column: 1,
+            line: 1,
+            messageId: 'preferOptionalChain',
             suggestions: null,
           },
         ],
-        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+        output: 'foo?.bar(baz => <This Requires Spaces />);',
       },
       // case with this keyword at the start of expression
       {
         code: '!this.bar || !this.bar.baz;',
-        output: '!this.bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!this.bar?.baz;',
       },
       {
         code: '!a.b || !a.b();',
-        output: '!a.b?.();',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!a.b?.();',
       },
       {
         code: '!foo.bar || !foo.bar.baz;',
-        output: '!foo.bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo.bar?.baz;',
       },
       {
         code: '!foo[bar] || !foo[bar]?.[baz];',
-        output: '!foo[bar]?.[baz];',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo[bar]?.[baz];',
       },
       {
         code: '!foo || !foo?.bar.baz;',
-        output: '!foo?.bar.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo?.bar.baz;',
       },
       // two  errors
       {
         code: '(!foo || !foo.bar || !foo.bar.baz) && (!baz || !baz.bar || !baz.bar.foo);',
-        output: '(!foo?.bar?.baz) && (!baz?.bar?.foo);',
         errors: [
           { messageId: 'preferOptionalChain', suggestions: null },
           { messageId: 'preferOptionalChain', suggestions: null },
         ],
+        output: '(!foo?.bar?.baz) && (!baz?.bar?.foo);',
       },
       {
         code: `
@@ -1138,7 +901,6 @@ describe('hand-crafted cases', () => {
             }
           }
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1156,49 +918,49 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: 'import.meta && import.meta?.baz;',
-        output: 'import.meta?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'import.meta?.baz;',
       },
       {
         code: '!import.meta || !import.meta?.baz;',
-        output: '!import.meta?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!import.meta?.baz;',
       },
       {
         code: 'import.meta && import.meta?.() && import.meta?.().baz;',
-        output: 'import.meta?.()?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'import.meta?.()?.baz;',
       },
       // non-null expressions
       {
         code: '!foo() || !foo().bar;',
-        output: '!foo()?.bar;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo()?.bar;',
       },
       {
         code: '!foo!.bar || !foo!.bar.baz;',
-        output: '!foo!.bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo!.bar?.baz;',
       },
       {
         code: '!foo!.bar!.baz || !foo!.bar!.baz!.paz;',
-        output: '!foo!.bar!.baz?.paz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo!.bar!.baz?.paz;',
       },
       {
         code: '!foo.bar!.baz || !foo.bar!.baz!.paz;',
-        output: '!foo.bar!.baz?.paz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '!foo.bar!.baz?.paz;',
       },
       {
         code: `
           declare const foo: { bar: string } | null;
           foo !== null && foo.bar !== null;
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1213,18 +975,18 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: 'foo != null && foo.bar != null;',
-        output: 'foo?.bar != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar != null;',
       },
       {
         code: `
           declare const foo: { bar: string | null } | null;
           foo != null && foo.bar !== null;
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1239,77 +1001,78 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: `
           declare const foo: { bar: string | null } | null;
           foo !== null && foo.bar != null;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           declare const foo: { bar: string | null } | null;
           foo?.bar != null;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // https://github.com/typescript-eslint/typescript-eslint/issues/6332
       {
         code: 'unrelated != null && foo != null && foo.bar != null;',
-        output: 'unrelated != null && foo?.bar != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'unrelated != null && foo?.bar != null;',
       },
       {
         code: 'unrelated1 != null && unrelated2 != null && foo != null && foo.bar != null;',
-        output: 'unrelated1 != null && unrelated2 != null && foo?.bar != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'unrelated1 != null && unrelated2 != null && foo?.bar != null;',
       },
       // https://github.com/typescript-eslint/typescript-eslint/issues/1461
       {
         code: 'foo1 != null && foo1.bar != null && foo2 != null && foo2.bar != null;',
-        output: 'foo1?.bar != null && foo2?.bar != null;',
         errors: [
           { messageId: 'preferOptionalChain', suggestions: null },
           { messageId: 'preferOptionalChain', suggestions: null },
         ],
+        output: 'foo1?.bar != null && foo2?.bar != null;',
       },
       {
         code: 'foo && foo.a && bar && bar.a;',
-        output: 'foo?.a && bar?.a;',
         errors: [
           { messageId: 'preferOptionalChain', suggestions: null },
           { messageId: 'preferOptionalChain', suggestions: null },
         ],
+        output: 'foo?.a && bar?.a;',
       },
       // randomly placed optional chain tokens are ignored
       {
         code: 'foo.bar.baz != null && foo?.bar?.baz.bam != null;',
-        output: 'foo.bar.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo.bar.baz?.bam != null;',
       },
       {
         code: 'foo?.bar.baz != null && foo.bar?.baz.bam != null;',
-        output: 'foo?.bar.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar.baz?.bam != null;',
       },
       {
         code: 'foo?.bar?.baz != null && foo.bar.baz.bam != null;',
-        output: 'foo?.bar?.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar?.baz?.bam != null;',
       },
       // randomly placed non-null assertions are retained as long as they're in an earlier operand
       {
         code: 'foo.bar.baz != null && foo!.bar!.baz.bam != null;',
-        output: 'foo.bar.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo.bar.baz?.bam != null;',
       },
       {
         code: 'foo!.bar.baz != null && foo.bar!.baz.bam != null;',
-        output: 'foo!.bar.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo!.bar.baz?.bam != null;',
       },
       {
         code: 'foo!.bar!.baz != null && foo.bar.baz.bam != null;',
-        output: 'foo!.bar!.baz?.bam != null;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo!.bar!.baz?.bam != null;',
       },
       // mixed binary checks are followed and flagged
       {
@@ -1326,10 +1089,10 @@ describe('hand-crafted cases', () => {
             a.b.c.d.e.f.g !== null &&
             a.b.c.d.e.f.g.h;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           a?.b?.c?.d?.e?.f?.g?.h;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
@@ -1345,10 +1108,10 @@ describe('hand-crafted cases', () => {
             a.b.c.d.e.f.g === null ||
             !a.b.c.d.e.f.g.h;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           !a?.b?.c?.d?.e?.f?.g?.h;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
@@ -1364,16 +1127,16 @@ describe('hand-crafted cases', () => {
             a.b.c.d.e.f.g === null ||
             !a.b.c.d.e.f.g.h;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           !a?.b?.c?.d?.e?.f?.g?.h;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // yoda checks are flagged
       {
         code: 'undefined !== foo && null !== foo && null != foo.bar && foo.bar.baz;',
-        output: 'foo?.bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: 'foo?.bar?.baz;',
       },
       {
         code: `
@@ -1382,10 +1145,10 @@ describe('hand-crafted cases', () => {
             null !== foo.bar &&
             foo.bar.baz;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           foo?.bar?.baz;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
@@ -1394,10 +1157,10 @@ describe('hand-crafted cases', () => {
             null !== foo.bar &&
             null != foo.bar.baz;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           null != foo?.bar?.baz;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // We should retain the split strict equals check if it's the last operand
       {
@@ -1408,7 +1171,6 @@ describe('hand-crafted cases', () => {
             null !== foo.bar.baz &&
             'undefined' !== typeof foo.bar.baz;
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1423,6 +1185,7 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: `
@@ -1432,7 +1195,6 @@ describe('hand-crafted cases', () => {
             foo.bar.baz !== null &&
             typeof foo.bar.baz !== 'undefined';
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1447,6 +1209,7 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: `
@@ -1456,7 +1219,6 @@ describe('hand-crafted cases', () => {
             null !== foo.bar.baz &&
             undefined !== foo.bar.baz;
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1471,6 +1233,7 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: `
@@ -1480,7 +1243,6 @@ describe('hand-crafted cases', () => {
             foo.bar.baz !== null &&
             foo.bar.baz !== undefined;
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1495,6 +1257,7 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       {
         code: `
@@ -1504,11 +1267,11 @@ describe('hand-crafted cases', () => {
             undefined !== foo.bar.baz &&
             null !== foo.bar.baz;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           undefined !== foo?.bar?.baz &&
             null !== foo.bar.baz;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
@@ -1518,17 +1281,17 @@ describe('hand-crafted cases', () => {
             foo.bar.baz !== undefined &&
             foo.bar.baz !== null;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           foo?.bar?.baz !== undefined &&
             foo.bar.baz !== null;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       // await
       {
         code: '(await foo).bar && (await foo).bar.baz;',
-        output: '(await foo).bar?.baz;',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: '(await foo).bar?.baz;',
       },
       // TODO - should we handle this case and expand the range, or should we leave this as is?
       {
@@ -1544,11 +1307,11 @@ describe('hand-crafted cases', () => {
             a.b.c.d.e.f.g == null ||
             a.b.c.d.e.f.g.h;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           a?.b?.c?.d?.e?.f?.g == null ||
             a.b.c.d.e.f.g.h;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
 
       {
@@ -1556,33 +1319,33 @@ describe('hand-crafted cases', () => {
           declare const foo: { bar: number } | null | undefined;
           foo && foo.bar != null;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           declare const foo: { bar: number } | null | undefined;
           foo?.bar != null;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
           declare const foo: { bar: number } | undefined;
           foo && typeof foo.bar !== 'undefined';
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           declare const foo: { bar: number } | undefined;
           typeof foo?.bar !== 'undefined';
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
       {
         code: `
           declare const foo: { bar: number } | undefined;
           foo && 'undefined' !== typeof foo.bar;
         `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         output: `
           declare const foo: { bar: number } | undefined;
           'undefined' !== typeof foo?.bar;
         `,
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
       },
 
       // requireNullish
@@ -1591,8 +1354,6 @@ describe('hand-crafted cases', () => {
           declare const thing1: string | null;
           thing1 && thing1.toString();
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1607,14 +1368,14 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
       {
         code: `
           declare const thing1: string | null;
           thing1 && thing1.toString() && true;
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1629,14 +1390,14 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
       {
         code: `
           declare const foo: string | null;
           foo && foo.toString() && foo.toString();
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1651,38 +1412,38 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
       {
         code: `
           declare const foo: { bar: string | null | undefined } | null | undefined;
           foo && foo.bar && foo.bar.toString();
         `,
+        errors: [{ messageId: 'preferOptionalChain' }],
+        options: [{ requireNullish: true }],
         output: `
           declare const foo: { bar: string | null | undefined } | null | undefined;
           foo?.bar?.toString();
         `,
-        options: [{ requireNullish: true }],
-        errors: [{ messageId: 'preferOptionalChain' }],
       },
       {
         code: `
           declare const foo: { bar: string | null | undefined } | null | undefined;
           foo && foo.bar && foo.bar.toString() && foo.bar.toString();
         `,
+        errors: [{ messageId: 'preferOptionalChain' }],
+        options: [{ requireNullish: true }],
         output: `
           declare const foo: { bar: string | null | undefined } | null | undefined;
           foo?.bar?.toString() && foo.bar.toString();
         `,
-        options: [{ requireNullish: true }],
-        errors: [{ messageId: 'preferOptionalChain' }],
       },
       {
         code: `
           declare const foo: string | null;
           (foo || {}).toString();
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1697,14 +1458,14 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
       {
         code: `
           declare const foo: string;
           (foo || undefined || {}).toString();
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1719,14 +1480,14 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
       {
         code: `
           declare const foo: string | null;
           (foo || undefined || {}).toString();
         `,
-        output: null,
-        options: [{ requireNullish: true }],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1741,6 +1502,8 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [{ requireNullish: true }],
+        output: null,
       },
 
       // allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing
@@ -1749,30 +1512,23 @@ describe('hand-crafted cases', () => {
           declare const foo: { bar: number } | null | undefined;
           foo != undefined && foo.bar;
         `,
-        output: `
-          declare const foo: { bar: number } | null | undefined;
-          foo?.bar;
-        `,
+        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
         options: [
           {
             allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing:
               true,
           },
         ],
-        errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
+        output: `
+          declare const foo: { bar: number } | null | undefined;
+          foo?.bar;
+        `,
       },
       {
         code: `
           declare const foo: { bar: number } | null | undefined;
           foo != undefined && foo.bar;
         `,
-        output: null,
-        options: [
-          {
-            allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing:
-              false,
-          },
-        ],
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1787,6 +1543,13 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        options: [
+          {
+            allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing:
+              false,
+          },
+        ],
+        output: null,
       },
       {
         code: `
@@ -1794,18 +1557,18 @@ describe('hand-crafted cases', () => {
           declare function acceptsBoolean(arg: boolean): void;
           acceptsBoolean(foo != null && foo.bar);
         `,
-        output: `
-          declare const foo: { bar: boolean } | null | undefined;
-          declare function acceptsBoolean(arg: boolean): void;
-          acceptsBoolean(foo?.bar);
-        `,
+        errors: [{ messageId: 'preferOptionalChain' }],
         options: [
           {
             allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing:
               true,
           },
         ],
-        errors: [{ messageId: 'preferOptionalChain' }],
+        output: `
+          declare const foo: { bar: boolean } | null | undefined;
+          declare function acceptsBoolean(arg: boolean): void;
+          acceptsBoolean(foo?.bar);
+        `,
       },
       {
         code: `
@@ -1813,18 +1576,17 @@ describe('hand-crafted cases', () => {
             typeof globalThis !== 'undefined' && globalThis.Array();
           }
         `,
+        errors: [{ messageId: 'preferOptionalChain' }],
         output: `
           function foo(globalThis?: { Array: Function }) {
             globalThis?.Array();
           }
         `,
-        errors: [{ messageId: 'preferOptionalChain' }],
       },
       {
         code: `
           typeof globalThis !== 'undefined' && globalThis.Array && globalThis.Array();
         `,
-        output: null,
         errors: [
           {
             messageId: 'preferOptionalChain',
@@ -1838,85 +1600,323 @@ describe('hand-crafted cases', () => {
             ],
           },
         ],
+        output: null,
       },
       // parenthesis
       {
         code: noFormat`a && (a.b && a.b.c)`,
-        output: 'a?.b?.c',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 20,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'a?.b?.c',
       },
       {
         code: noFormat`(a && a.b) && a.b.c`,
-        output: 'a?.b?.c',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 20,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'a?.b?.c',
       },
       {
         code: noFormat`((a && a.b)) && a.b.c`,
-        output: 'a?.b?.c',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 22,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'a?.b?.c',
       },
       {
         code: noFormat`foo(a && (a.b && a.b.c))`,
-        output: 'foo(a?.b?.c)',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 5,
             endColumn: 24,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'foo(a?.b?.c)',
       },
       {
         code: noFormat`foo(a && a.b && a.b.c)`,
-        output: 'foo(a?.b?.c)',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 5,
             endColumn: 22,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'foo(a?.b?.c)',
       },
       {
         code: noFormat`!foo || !foo.bar || ((((!foo.bar.baz || !foo.bar.baz()))));`,
-        output: '!foo?.bar?.baz?.();',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 59,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: '!foo?.bar?.baz?.();',
       },
       {
         code: noFormat`a !== undefined && ((a !== null && a.prop));`,
-        output: 'a?.prop;',
         errors: [
           {
-            messageId: 'preferOptionalChain',
             column: 1,
             endColumn: 44,
+            messageId: 'preferOptionalChain',
           },
         ],
+        output: 'a?.prop;',
+      },
+    ],
+    valid: [
+      '!a || !b;',
+      '!a || a.b;',
+      '!a && a.b;',
+      '!a && !a.b;',
+      '!a.b || a.b?.();',
+      '!a.b || a.b();',
+      'foo ||= bar;',
+      'foo ||= bar?.baz;',
+      'foo ||= bar?.baz?.buzz;',
+      '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;',
+      "typeof foo === 'number' && foo.toFixed();",
+      "foo === 'undefined' && foo.length;",
+      'foo == bar && foo.bar == null;',
+      'foo === 1 && foo.toFixed();',
+      // call arguments are considered
+      'foo.bar(a) && foo.bar(a, b).baz;',
+      // type parameters are considered
+      'foo.bar<a>() && foo.bar<a, b>().baz;',
+      // array elements are considered
+      '[1, 2].length && [1, 2, 3].length.toFixed();',
+      noFormat`[1,].length && [1, 2].length.toFixed();`,
+      // short-circuiting chains are considered
+      '(foo?.a).b && foo.a.b.c;',
+      '(foo?.a)() && foo.a().b;',
+      '(foo?.a)() && foo.a()();',
+      // looks like a chain, but isn't actually a chain - just a pair of strict nullish checks
+      'foo !== null && foo !== undefined;',
+      "x['y'] !== undefined && x['y'] !== null;",
+      // private properties
+      'this.#a && this.#b;',
+      '!this.#a || !this.#b;',
+      'a.#foo?.bar;',
+      '!a.#foo?.bar;',
+      '!foo().#a || a;',
+      '!a.b.#a || a;',
+      '!new A().#b || a;',
+      '!(await a).#b || a;',
+      "!(foo as any).bar || 'anything';",
+      // computed properties should be interrogated and correctly ignored
+      '!foo[1 + 1] || !foo[1 + 2];',
+      '!foo[1 + 1] || !foo[1 + 2].foo;',
+      // currently do not handle 'this' as the first part of a chain
+      'this && this.foo;',
+      '!this || !this.foo;',
+      '!entity.__helper!.__initialized || options.refresh;',
+      'import.meta || true;',
+      'import.meta || import.meta.foo;',
+      '!import.meta && false;',
+      '!import.meta && !import.meta.foo;',
+      'new.target || new.target.length;',
+      '!new.target || true;',
+      // Do not handle direct optional chaining on private properties because this TS limitation (https://github.com/microsoft/TypeScript/issues/42734)
+      'foo && foo.#bar;',
+      '!foo || !foo.#bar;',
+      // weird non-constant cases are ignored
+      '({}) && {}.toString();',
+      '[] && [].length;',
+      '(() => {}) && (() => {}).name;',
+      '(function () {}) && function () {}.name;',
+      '(class Foo {}) && class Foo {}.constructor;',
+      "new Map().get('a') && new Map().get('a').what;",
+      // https://github.com/typescript-eslint/typescript-eslint/issues/7654
+      'data && data.value !== null;',
+      {
+        code: '<div /> && (<div />).wtf;',
+        filename: 'react.tsx',
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+      },
+      {
+        code: '<></> && (<></>).wtf;',
+        filename: 'react.tsx',
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+      },
+      'foo[x++] && foo[x++].bar;',
+      'foo[yield x] && foo[yield x].bar;',
+      'a = b && (a = b).wtf;',
+      // TODO - should we handle this?
+      '(x || y) != null && (x || y).foo;',
+      // TODO - should we handle this?
+      '(await foo) && (await foo).bar;',
+      {
+        code: `
+          declare const x: string;
+          x && x.length;
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const foo: string;
+          foo && foo.toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const x: string | number | boolean | object;
+          x && x.toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const foo: { bar: string };
+          foo && foo.bar && foo.bar.toString();
+        `,
+        options: [{ requireNullish: true }],
       },
+      {
+        code: `
+          declare const foo: string;
+          foo && foo.toString() && foo.toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const foo: { bar: string };
+          foo && foo.bar && foo.bar.toString() && foo.bar.toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const foo1: { bar: string | null };
+          foo1 && foo1.bar;
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const foo: string;
+          (foo || {}).toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+
+      {
+        code: `
+          declare const foo: string | null;
+          (foo || 'a' || {}).toString();
+        `,
+        options: [{ requireNullish: true }],
+      },
+      {
+        code: `
+          declare const x: any;
+          x && x.length;
+        `,
+        options: [{ checkAny: false }],
+      },
+      {
+        code: `
+          declare const x: bigint;
+          x && x.length;
+        `,
+        options: [{ checkBigInt: false }],
+      },
+      {
+        code: `
+          declare const x: boolean;
+          x && x.length;
+        `,
+        options: [{ checkBoolean: false }],
+      },
+      {
+        code: `
+          declare const x: number;
+          x && x.length;
+        `,
+        options: [{ checkNumber: false }],
+      },
+      {
+        code: `
+          declare const x: string;
+          x && x.length;
+        `,
+        options: [{ checkString: false }],
+      },
+      {
+        code: `
+          declare const x: unknown;
+          x && x.length;
+        `,
+        options: [{ checkUnknown: false }],
+      },
+      '(x = {}) && (x.y = true) != null && x.y.toString();',
+      "('x' as `${'x'}`) && ('x' as `${'x'}`).length;",
+      '`x` && `x`.length;',
+      '`x${a}` && `x${a}`.length;',
+
+      // falsy unions should be ignored
+      `
+        declare const x: false | { a: string };
+        x && x.a;
+      `,
+      `
+        declare const x: false | { a: string };
+        !x || x.a;
+      `,
+      `
+        declare const x: '' | { a: string };
+        x && x.a;
+      `,
+      `
+        declare const x: '' | { a: string };
+        !x || x.a;
+      `,
+      `
+        declare const x: 0 | { a: string };
+        x && x.a;
+      `,
+      `
+        declare const x: 0 | { a: string };
+        !x || x.a;
+      `,
+      `
+        declare const x: 0n | { a: string };
+        x && x.a;
+      `,
+      `
+        declare const x: 0n | { a: string };
+        !x || x.a;
+      `,
+      "typeof globalThis !== 'undefined' && globalThis.Array();",
     ],
   });
 });
@@ -1925,19 +1925,19 @@ describe('base cases', () => {
   describe('and', () => {
     describe('boolean', () => {
       ruleTester.run('prefer-optional-chain', rule, {
-        valid: [],
         invalid: [
           ...BaseCases({ operator: '&&' }),
           // it should ignore parts of the expression that aren't part of the expression chain
           ...BaseCases({
-            operator: '&&',
             mutateCode: c => c.replace(/;$/, ' && bing;'),
+            operator: '&&',
           }),
           ...BaseCases({
-            operator: '&&',
             mutateCode: c => c.replace(/;$/, ' && bing.bong;'),
+            operator: '&&',
           }),
         ],
+        valid: [],
       });
     });
 
@@ -1947,17 +1947,17 @@ describe('base cases', () => {
           // with the `| null | undefined` type - `!== null` doesn't cover the
           // `undefined` case - so optional chaining is not a valid conversion
           valid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!== null &&'),
             mutateOutput: identity,
+            operator: '&&',
           }),
           // but if the type is just `| null` - then it covers the cases and is
           // a valid conversion
           invalid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!== null &&'),
-            mutateOutput: identity,
             mutateDeclaration: c => c.replaceAll('| undefined', ''),
+            mutateOutput: identity,
+            operator: '&&',
             useSuggestionFixer: true,
           }),
         });
@@ -1965,13 +1965,13 @@ describe('base cases', () => {
 
       describe('!= null', () => {
         ruleTester.run('prefer-optional-chain', rule, {
-          valid: [],
           invalid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!= null &&'),
             mutateOutput: identity,
+            operator: '&&',
             useSuggestionFixer: true,
           }),
+          valid: [],
         });
       });
 
@@ -1980,17 +1980,17 @@ describe('base cases', () => {
           // with the `| null | undefined` type - `!== undefined` doesn't cover the
           // `null` case - so optional chaining is not a valid conversion
           valid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!== undefined &&'),
             mutateOutput: identity,
+            operator: '&&',
           }),
           // but if the type is just `| undefined` - then it covers the cases and is
           // a valid conversion
           invalid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!== undefined &&'),
-            mutateOutput: identity,
             mutateDeclaration: c => c.replaceAll('| null', ''),
+            mutateOutput: identity,
+            operator: '&&',
             useSuggestionFixer: true,
           }),
         });
@@ -1998,13 +1998,13 @@ describe('base cases', () => {
 
       describe('!= undefined', () => {
         ruleTester.run('prefer-optional-chain', rule, {
-          valid: [],
           invalid: BaseCases({
-            operator: '&&',
             mutateCode: c => c.replaceAll('&&', '!= undefined &&'),
             mutateOutput: identity,
+            operator: '&&',
             useSuggestionFixer: true,
           }),
+          valid: [],
         });
       });
     });
@@ -2013,12 +2013,12 @@ describe('base cases', () => {
   describe('or', () => {
     describe('boolean', () => {
       ruleTester.run('prefer-optional-chain', rule, {
-        valid: [],
         invalid: BaseCases({
-          operator: '||',
           mutateCode: c => `!${c.replaceAll('||', '|| !')}`,
           mutateOutput: c => `!${c}`,
+          operator: '||',
         }),
+        valid: [],
       });
     });
 
@@ -2028,22 +2028,22 @@ describe('base cases', () => {
           // with the `| null | undefined` type - `=== null` doesn't cover the
           // `undefined` case - so optional chaining is not a valid conversion
           valid: BaseCases({
-            operator: '||',
             mutateCode: c => c.replaceAll('||', '=== null ||'),
             mutateOutput: identity,
+            operator: '||',
           }),
           // but if the type is just `| null` - then it covers the cases and is
           // a valid conversion
           invalid: BaseCases({
-            operator: '||',
             mutateCode: c =>
               c
                 .replaceAll('||', '=== null ||')
                 // SEE TODO AT THE BOTTOM OF THE RULE
                 // We need to ensure the final operand is also a "valid" `||` check
                 .replace(/;$/, ' === null;'),
-            mutateOutput: c => c.replace(/;$/, ' === null;'),
             mutateDeclaration: c => c.replaceAll('| undefined', ''),
+            mutateOutput: c => c.replace(/;$/, ' === null;'),
+            operator: '||',
             useSuggestionFixer: true,
           }),
         });
@@ -2051,9 +2051,7 @@ describe('base cases', () => {
 
       describe('== null', () => {
         ruleTester.run('prefer-optional-chain', rule, {
-          valid: [],
           invalid: BaseCases({
-            operator: '||',
             mutateCode: c =>
               c
                 .replaceAll('||', '== null ||')
@@ -2061,7 +2059,9 @@ describe('base cases', () => {
                 // We need to ensure the final operand is also a "valid" `||` check
                 .replace(/;$/, ' == null;'),
             mutateOutput: c => c.replace(/;$/, ' == null;'),
+            operator: '||',
           }),
+          valid: [],
         });
       });
 
@@ -2070,31 +2070,29 @@ describe('base cases', () => {
           // with the `| null | undefined` type - `=== undefined` doesn't cover the
           // `null` case - so optional chaining is not a valid conversion
           valid: BaseCases({
-            operator: '||',
             mutateCode: c => c.replaceAll('||', '=== undefined ||'),
             mutateOutput: identity,
+            operator: '||',
           }),
           // but if the type is just `| undefined` - then it covers the cases and is
           // a valid conversion
           invalid: BaseCases({
-            operator: '||',
             mutateCode: c =>
               c
                 .replaceAll('||', '=== undefined ||')
                 // SEE TODO AT THE BOTTOM OF THE RULE
                 // We need to ensure the final operand is also a "valid" `||` check
                 .replace(/;$/, ' === undefined;'),
-            mutateOutput: c => c.replace(/;$/, ' === undefined;'),
             mutateDeclaration: c => c.replaceAll('| null', ''),
+            mutateOutput: c => c.replace(/;$/, ' === undefined;'),
+            operator: '||',
           }),
         });
       });
 
       describe('== undefined', () => {
         ruleTester.run('prefer-optional-chain', rule, {
-          valid: [],
           invalid: BaseCases({
-            operator: '||',
             mutateCode: c =>
               c
                 .replaceAll('||', '== undefined ||')
@@ -2102,7 +2100,9 @@ describe('base cases', () => {
                 // We need to ensure the final operand is also a "valid" `||` check
                 .replace(/;$/, ' == undefined;'),
             mutateOutput: c => c.replace(/;$/, ' == undefined;'),
+            operator: '||',
           }),
+          valid: [],
         });
       });
     });
@@ -2115,8 +2115,8 @@ describe('base cases', () => {
       invalid: dedupeTestCases(
         // it should ignore whitespace in the expressions
         BaseCases({
-          operator: '&&',
           mutateCode: c => c.replaceAll('.', '.      '),
+          operator: '&&',
           // note - the rule will use raw text for computed expressions - so we
           //        need to ensure that the spacing for the computed member
           //        expressions is retained for correct fixer matching
@@ -2124,10 +2124,10 @@ describe('base cases', () => {
             c.replaceAll(/(\[.+])/g, m => m.replaceAll('.', '.      ')),
         }),
         BaseCases({
-          operator: '&&',
           mutateCode: c => c.replaceAll('.', '.\n'),
           mutateOutput: c =>
             c.replaceAll(/(\[.+])/g, m => m.replaceAll('.', '.\n')),
+          operator: '&&',
         }),
       ),
     });
diff --git a/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts b/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
index d890886eff15..5a7429331370 100644
--- a/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
@@ -8,617 +8,365 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('prefer-promise-reject-errors', rule, {
-  valid: [
-    'Promise.resolve(5);',
+  invalid: [
+    {
+      code: 'Promise.reject(5);',
+      errors: [
+        {
+          column: 1,
+          endColumn: 18,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: "Promise.reject('foo');",
+      errors: [
+        {
+          column: 1,
+          endColumn: 22,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: 'Promise.reject(`foo`);',
+      errors: [
+        {
+          column: 1,
+          endColumn: 22,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: "Promise.reject('foo', somethingElse);",
+      errors: [
+        {
+          column: 1,
+          endColumn: 37,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: 'Promise.reject(false);',
+      errors: [
+        {
+          column: 1,
+          endColumn: 22,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: 'Promise.reject(void `foo`);',
+      errors: [
+        {
+          column: 1,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
     {
       code: 'Promise.reject();',
-      options: [
+      errors: [
         {
-          allowEmptyReject: true,
+          column: 1,
+          endColumn: 17,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
-    'Promise.reject(new Error());',
-    'Promise.reject(new TypeError());',
-    "Promise.reject(new Error('foo'));",
-    `
-      class CustomError extends Error {}
-      Promise.reject(new CustomError());
-    `,
-    `
-      declare const foo: () => { err: SyntaxError };
-      Promise.reject(foo().err);
-    `,
-    `
-      declare const foo: () => Promise<Error>;
-      Promise.reject(await foo());
-    `,
-    'Promise.reject((foo = new Error()));',
-    `
-      const foo = Promise;
-      foo.reject(new Error());
-    `,
-    "Promise['reject'](new Error());",
-    'Promise.reject(true && new Error());',
-    `
-      const foo = false;
-      Promise.reject(false || new Error());
-    `,
-    `
-      declare const foo: Readonly<Error>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> | Readonly<TypeError>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> & Readonly<TypeError>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> & { foo: 'bar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Readonly<Error>>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Readonly<Readonly<Error>>>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<
-        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
-          fooBar: 'barFoo';
-        }
-      > & { barFoo: 'fooBar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo:
-        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
-        | Readonly<Error>;
-      Promise.reject(foo);
-    `,
-    `
-      type Wrapper<T> = { foo: Readonly<T>[] };
-      declare const foo: Wrapper<Error>['foo'][5];
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Error[];
-      Promise.reject(foo[5]);
-    `,
-    `
-      declare const foo: ReadonlyArray<Error>;
-      Promise.reject(foo[5]);
-    `,
-    `
-      declare const foo: [Error];
-      Promise.reject(foo[0]);
-    `,
-
-    `
-      new Promise(function (resolve, reject) {
-        resolve(5);
-      });
-    `,
-    `
-      new Promise(function (resolve, reject) {
-        reject(new Error());
-      });
-    `,
-    `
-      new Promise((resolve, reject) => {
-        reject(new Error());
-      });
-    `,
-    'new Promise((resolve, reject) => reject(new Error()));',
     {
-      code: `
-        new Promise(function (resolve, reject) {
-          reject();
-        });
-      `,
-      options: [
+      code: 'Promise.reject(undefined);',
+      errors: [
         {
-          allowEmptyReject: true,
+          column: 1,
+          endColumn: 26,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
-    'new Promise((yes, no) => no(new Error()));',
-    'new Promise();',
-    'new Promise(5);',
-    'new Promise((resolve, { apply }) => {});',
-    'new Promise((resolve, reject) => {});',
-    'new Promise((resolve, reject) => reject);',
-    `
-      class CustomError extends Error {}
-      new Promise(function (resolve, reject) {
-        reject(new CustomError());
-      });
-    `,
-    `
-      declare const foo: () => { err: SyntaxError };
-      new Promise(function (resolve, reject) {
-        reject(foo().err);
-      });
-    `,
-    'new Promise((resolve, reject) => reject((foo = new Error())));',
-    `
-      new Foo((resolve, reject) => reject(5));
-    `,
-    `
-      class Foo {
-        constructor(
-          executor: (resolve: () => void, reject: (reason?: any) => void) => void,
-        ): Promise<any> {}
-      }
-      new Foo((resolve, reject) => reject(5));
-    `,
-    `
-      new Promise((resolve, reject) => {
-        return function (reject) {
-          reject(5);
-        };
-      });
-    `,
-    'new Promise((resolve, reject) => resolve(5, reject));',
-    `
-      class C {
-        #error: Error;
-        foo() {
-          Promise.reject(this.#error);
-        }
-      }
-    `,
-    `
-      const foo = Promise;
-      new foo((resolve, reject) => reject(new Error()));
-    `,
-    `
-      declare const foo: Readonly<Error>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> | Readonly<TypeError>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> & Readonly<TypeError>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> & { foo: 'bar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Readonly<Error>>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Readonly<Readonly<Error>>>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<
-        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
-          fooBar: 'barFoo';
-        }
-      > & { barFoo: 'fooBar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo:
-        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
-        | Readonly<Error>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      type Wrapper<T> = { foo: Readonly<T>[] };
-      declare const foo: Wrapper<Error>['foo'][5];
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Error[];
-      new Promise((resolve, reject) => reject(foo[5]));
-    `,
-    `
-      declare const foo: ReadonlyArray<Error>;
-      new Promise((resolve, reject) => reject(foo[5]));
-    `,
-    `
-      declare const foo: [Error];
-      new Promise((resolve, reject) => reject(foo[0]));
-    `,
-    `
-      class Foo extends Promise<number> {}
-      Foo.reject(new Error());
-    `,
-    `
-      class Foo extends Promise<number> {}
-      new Foo((resolve, reject) => reject(new Error()));
-    `,
-    `
-      declare const someRandomCall: {
-        reject(arg: any): void;
-      };
-      someRandomCall.reject(5);
-    `,
-    `
-      declare const foo: PromiseConstructor;
-      foo.reject(new Error());
-    `,
-  ],
-  invalid: [
     {
-      code: 'Promise.reject(5);',
+      code: 'Promise.reject(undefined);',
       errors: [
         {
+          column: 1,
+          endColumn: 26,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 18,
         },
       ],
+      options: [{ allowEmptyReject: true }],
     },
     {
-      code: "Promise.reject('foo');",
+      code: 'Promise.reject(null);',
       errors: [
         {
+          column: 1,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 22,
         },
       ],
     },
     {
-      code: 'Promise.reject(`foo`);',
+      code: 'Promise.reject({ foo: 1 });',
       errors: [
         {
+          column: 1,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 22,
         },
       ],
     },
     {
-      code: "Promise.reject('foo', somethingElse);",
+      code: 'Promise.reject([1, 2, 3]);',
       errors: [
         {
+          column: 1,
+          endColumn: 26,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 37,
         },
       ],
     },
     {
-      code: 'Promise.reject(false);',
+      code: `
+declare const foo: Error | undefined;
+Promise.reject(foo);
+      `,
       errors: [
         {
+          column: 1,
+          endColumn: 20,
+          endLine: 3,
+          line: 3,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 22,
         },
       ],
     },
     {
-      code: 'Promise.reject(void `foo`);',
+      code: `
+declare const foo: () => Promise<string>;
+Promise.reject(await foo());
+      `,
       errors: [
         {
+          column: 1,
+          endColumn: 28,
+          endLine: 3,
+          line: 3,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 27,
         },
       ],
     },
     {
-      code: 'Promise.reject();',
+      code: `
+declare const foo: boolean;
+Promise.reject(foo && new Error());
+      `,
       errors: [
         {
+          column: 1,
+          endColumn: 35,
+          endLine: 3,
+          line: 3,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 17,
         },
       ],
     },
     {
-      code: 'Promise.reject(undefined);',
+      code: `
+const foo = Promise;
+foo.reject();
+      `,
       errors: [
         {
+          column: 1,
+          endColumn: 13,
+          endLine: 3,
+          line: 3,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 26,
         },
       ],
     },
+
     {
-      code: 'Promise.reject(undefined);',
-      options: [{ allowEmptyReject: true }],
+      code: 'Promise.reject?.(5);',
       errors: [
         {
+          column: 1,
+          endColumn: 20,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 26,
         },
       ],
     },
     {
-      code: 'Promise.reject(null);',
+      code: 'Promise?.reject(5);',
       errors: [
         {
+          column: 1,
+          endColumn: 19,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 21,
         },
       ],
     },
     {
-      code: 'Promise.reject({ foo: 1 });',
+      code: 'Promise?.reject?.(5);',
       errors: [
         {
+          column: 1,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 27,
         },
       ],
     },
     {
-      code: 'Promise.reject([1, 2, 3]);',
+      code: '(Promise?.reject)(5);',
       errors: [
         {
+          column: 1,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 26,
         },
       ],
     },
     {
-      code: `
-declare const foo: Error | undefined;
-Promise.reject(foo);
-      `,
+      code: noFormat`(Promise?.reject)?.(5);`,
       errors: [
         {
+          column: 1,
+          endColumn: 23,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 20,
         },
       ],
     },
     {
-      code: `
-declare const foo: () => Promise<string>;
-Promise.reject(await foo());
-      `,
+      code: "Promise['reject'](5);",
       errors: [
         {
+          column: 1,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 28,
         },
       ],
     },
+
+    // Assignments with mathematical operators will either evaluate to a primitive value or throw a TypeError
     {
-      code: `
-declare const foo: boolean;
-Promise.reject(foo && new Error());
-      `,
+      code: 'Promise.reject((foo += new Error()));',
       errors: [
         {
+          column: 1,
+          endColumn: 37,
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 35,
-        },
-      ],
-    },
-    {
-      code: `
-const foo = Promise;
-foo.reject();
-      `,
-      errors: [
-        {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
-          column: 1,
-          endColumn: 13,
         },
       ],
     },
-
     {
-      code: 'Promise.reject?.(5);',
+      code: 'Promise.reject((foo -= new Error()));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 1,
-          endColumn: 20,
-        },
-      ],
-    },
-    {
-      code: 'Promise?.reject(5);',
-      errors: [
-        {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
+          endColumn: 37,
           endLine: 1,
-          column: 1,
-          endColumn: 19,
-        },
-      ],
-    },
-    {
-      code: 'Promise?.reject?.(5);',
-      errors: [
-        {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
           line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 21,
-        },
-      ],
-    },
-    {
-      code: '(Promise?.reject)(5);',
-      errors: [
-        {
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 21,
         },
       ],
     },
     {
-      code: noFormat`(Promise?.reject)?.(5);`,
+      code: 'Promise.reject((foo **= new Error()));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 1,
-          endColumn: 23,
-        },
-      ],
-    },
-    {
-      code: "Promise['reject'](5);",
-      errors: [
-        {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
+          endColumn: 38,
           endLine: 1,
-          column: 1,
-          endColumn: 21,
-        },
-      ],
-    },
-
-    // Assignments with mathematical operators will either evaluate to a primitive value or throw a TypeError
-    {
-      code: 'Promise.reject((foo += new Error()));',
-      errors: [
-        {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
           line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 37,
-        },
-      ],
-    },
-    {
-      code: 'Promise.reject((foo -= new Error()));',
-      errors: [
-        {
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 37,
         },
       ],
     },
     {
-      code: 'Promise.reject((foo **= new Error()));',
+      code: 'Promise.reject((foo <<= new Error()));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 38,
-        },
-      ],
-    },
-    {
-      code: 'Promise.reject((foo <<= new Error()));',
-      errors: [
-        {
+          endLine: 1,
+          line: 1,
           messageId: 'rejectAnError',
           type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
-          column: 1,
-          endColumn: 38,
         },
       ],
     },
@@ -626,12 +374,12 @@ foo.reject();
       code: 'Promise.reject((foo |= new Error()));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 37,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -639,12 +387,12 @@ foo.reject();
       code: 'Promise.reject((foo &= new Error()));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 1,
           endColumn: 37,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -655,12 +403,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -671,12 +419,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -688,12 +436,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 1,
           endColumn: 20,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -704,12 +452,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -720,12 +468,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -736,12 +484,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -752,12 +500,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -768,12 +516,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -784,12 +532,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -800,12 +548,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -816,12 +564,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -833,12 +581,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 1,
           endColumn: 20,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -849,12 +597,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -865,12 +613,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -881,12 +629,12 @@ Promise.reject(foo);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 20,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -899,12 +647,12 @@ new Promise(function (resolve, reject) {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -916,12 +664,12 @@ new Promise(function (resolve, reject) {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -933,12 +681,12 @@ new Promise((resolve, reject) => {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -946,12 +694,12 @@ new Promise((resolve, reject) => {
       code: 'new Promise((resolve, reject) => reject(5));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 34,
           endColumn: 43,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -966,12 +714,12 @@ new Promise((resolve, reject) => {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 14,
           endColumn: 38,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -979,12 +727,12 @@ new Promise((resolve, reject) => {
       code: 'new Promise((yes, no) => no(5));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 26,
           endColumn: 31,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -992,12 +740,12 @@ new Promise((resolve, reject) => {
       code: 'new Promise(({ foo, bar, baz }, reject) => reject(5));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 44,
           endColumn: 53,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1009,12 +757,12 @@ new Promise(function (reject, reject) {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1026,12 +774,12 @@ new Promise(function (foo, arguments) {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1039,12 +787,12 @@ new Promise(function (foo, arguments) {
       code: 'new Promise((foo, arguments) => arguments(5));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 33,
           endColumn: 45,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1056,12 +804,12 @@ new Promise(function ({}, reject) {
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 3,
           endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1069,12 +817,12 @@ new Promise(function ({}, reject) {
       code: 'new Promise(({}, reject) => reject(5));',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 29,
           endColumn: 38,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1082,12 +830,12 @@ new Promise(function ({}, reject) {
       code: 'new Promise((resolve, reject, somethingElse = reject(5)) => {});',
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 1,
-          endLine: 1,
           column: 47,
           endColumn: 56,
+          endLine: 1,
+          line: 1,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1100,12 +848,12 @@ new foo.bar((resolve, reject) => reject(5));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 5,
-          endLine: 5,
           column: 34,
           endColumn: 43,
+          endLine: 5,
+          line: 5,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1118,12 +866,12 @@ new (foo?.bar)((resolve, reject) => reject(5));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 5,
-          endLine: 5,
           column: 37,
           endColumn: 46,
+          endLine: 5,
+          line: 5,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1134,12 +882,12 @@ new foo((resolve, reject) => reject(5));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 30,
           endColumn: 39,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1150,12 +898,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1166,12 +914,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1183,12 +931,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 34,
           endColumn: 45,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1199,12 +947,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1215,12 +963,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1231,12 +979,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1247,12 +995,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1263,12 +1011,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1279,12 +1027,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1295,12 +1043,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1311,12 +1059,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1328,12 +1076,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 34,
           endColumn: 45,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1344,12 +1092,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1360,12 +1108,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1376,12 +1124,12 @@ new Promise((resolve, reject) => reject(foo));
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 34,
           endColumn: 45,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1392,12 +1140,12 @@ Foo.reject(5);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1408,12 +1156,12 @@ foo.reject(5);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 3,
-          endLine: 3,
           column: 1,
           endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
         },
       ],
     },
@@ -1425,14 +1173,266 @@ Bar.reject(5);
       `,
       errors: [
         {
-          messageId: 'rejectAnError',
-          type: AST_NODE_TYPES.CallExpression,
-          line: 4,
-          endLine: 4,
           column: 1,
           endColumn: 14,
+          endLine: 4,
+          line: 4,
+          messageId: 'rejectAnError',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+  ],
+  valid: [
+    'Promise.resolve(5);',
+    {
+      code: 'Promise.reject();',
+      options: [
+        {
+          allowEmptyReject: true,
+        },
+      ],
+    },
+    'Promise.reject(new Error());',
+    'Promise.reject(new TypeError());',
+    "Promise.reject(new Error('foo'));",
+    `
+      class CustomError extends Error {}
+      Promise.reject(new CustomError());
+    `,
+    `
+      declare const foo: () => { err: SyntaxError };
+      Promise.reject(foo().err);
+    `,
+    `
+      declare const foo: () => Promise<Error>;
+      Promise.reject(await foo());
+    `,
+    'Promise.reject((foo = new Error()));',
+    `
+      const foo = Promise;
+      foo.reject(new Error());
+    `,
+    "Promise['reject'](new Error());",
+    'Promise.reject(true && new Error());',
+    `
+      const foo = false;
+      Promise.reject(false || new Error());
+    `,
+    `
+      declare const foo: Readonly<Error>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> | Readonly<TypeError>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> & Readonly<TypeError>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> & { foo: 'bar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Readonly<Error>>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Readonly<Readonly<Error>>>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<
+        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
+          fooBar: 'barFoo';
+        }
+      > & { barFoo: 'fooBar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo:
+        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
+        | Readonly<Error>;
+      Promise.reject(foo);
+    `,
+    `
+      type Wrapper<T> = { foo: Readonly<T>[] };
+      declare const foo: Wrapper<Error>['foo'][5];
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Error[];
+      Promise.reject(foo[5]);
+    `,
+    `
+      declare const foo: ReadonlyArray<Error>;
+      Promise.reject(foo[5]);
+    `,
+    `
+      declare const foo: [Error];
+      Promise.reject(foo[0]);
+    `,
+
+    `
+      new Promise(function (resolve, reject) {
+        resolve(5);
+      });
+    `,
+    `
+      new Promise(function (resolve, reject) {
+        reject(new Error());
+      });
+    `,
+    `
+      new Promise((resolve, reject) => {
+        reject(new Error());
+      });
+    `,
+    'new Promise((resolve, reject) => reject(new Error()));',
+    {
+      code: `
+        new Promise(function (resolve, reject) {
+          reject();
+        });
+      `,
+      options: [
+        {
+          allowEmptyReject: true,
         },
       ],
     },
+    'new Promise((yes, no) => no(new Error()));',
+    'new Promise();',
+    'new Promise(5);',
+    'new Promise((resolve, { apply }) => {});',
+    'new Promise((resolve, reject) => {});',
+    'new Promise((resolve, reject) => reject);',
+    `
+      class CustomError extends Error {}
+      new Promise(function (resolve, reject) {
+        reject(new CustomError());
+      });
+    `,
+    `
+      declare const foo: () => { err: SyntaxError };
+      new Promise(function (resolve, reject) {
+        reject(foo().err);
+      });
+    `,
+    'new Promise((resolve, reject) => reject((foo = new Error())));',
+    `
+      new Foo((resolve, reject) => reject(5));
+    `,
+    `
+      class Foo {
+        constructor(
+          executor: (resolve: () => void, reject: (reason?: any) => void) => void,
+        ): Promise<any> {}
+      }
+      new Foo((resolve, reject) => reject(5));
+    `,
+    `
+      new Promise((resolve, reject) => {
+        return function (reject) {
+          reject(5);
+        };
+      });
+    `,
+    'new Promise((resolve, reject) => resolve(5, reject));',
+    `
+      class C {
+        #error: Error;
+        foo() {
+          Promise.reject(this.#error);
+        }
+      }
+    `,
+    `
+      const foo = Promise;
+      new foo((resolve, reject) => reject(new Error()));
+    `,
+    `
+      declare const foo: Readonly<Error>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> | Readonly<TypeError>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> & Readonly<TypeError>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> & { foo: 'bar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Readonly<Error>>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Readonly<Readonly<Error>>>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<
+        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
+          fooBar: 'barFoo';
+        }
+      > & { barFoo: 'fooBar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo:
+        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
+        | Readonly<Error>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      type Wrapper<T> = { foo: Readonly<T>[] };
+      declare const foo: Wrapper<Error>['foo'][5];
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Error[];
+      new Promise((resolve, reject) => reject(foo[5]));
+    `,
+    `
+      declare const foo: ReadonlyArray<Error>;
+      new Promise((resolve, reject) => reject(foo[5]));
+    `,
+    `
+      declare const foo: [Error];
+      new Promise((resolve, reject) => reject(foo[0]));
+    `,
+    `
+      class Foo extends Promise<number> {}
+      Foo.reject(new Error());
+    `,
+    `
+      class Foo extends Promise<number> {}
+      new Foo((resolve, reject) => reject(new Error()));
+    `,
+    `
+      declare const someRandomCall: {
+        reject(arg: any): void;
+      };
+      someRandomCall.reject(5);
+    `,
+    `
+      declare const foo: PromiseConstructor;
+      foo.reject(new Error());
+    `,
   ],
 });
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 326c87a72014..75a53b1b94fe 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
@@ -1,11 +1,13 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
-import rule from '../../src/rules/prefer-readonly-parameter-types';
 import type {
   InferMessageIdsTypeFromRule,
   InferOptionsTypeFromRule,
 } from '../../src/util';
+
+import rule from '../../src/rules/prefer-readonly-parameter-types';
 import { readonlynessOptionsDefaults } from '../../src/util';
 import { dedupeTestCases } from '../dedupeTestCases';
 import { getFixturesRootDir } from '../RuleTester';
@@ -18,8 +20,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -67,831 +69,879 @@ const weirdIntersections = [
 ];
 
 ruleTester.run('prefer-readonly-parameter-types', rule, {
-  valid: [
-    'function foo() {}',
-
-    // primitives
-    ...primitives.map(type => `function foo(arg: ${type}) {}`),
-    `
-      const symb = Symbol('a');
-      function foo(arg: typeof symb) {}
-    `,
-    `
-      enum Enum {
-        a,
-        b,
-      }
-      function foo(arg: Enum) {}
-    `,
-
+  invalid: [
     // arrays
-    ...arrays.map(type => `function foo(arg: ${type}) {}`),
-    // nested arrays
-    'function foo(arg: readonly (readonly string[])[]) {}',
-    'function foo(arg: Readonly<Readonly<string[]>[]>) {}',
-    'function foo(arg: ReadonlyArray<ReadonlyArray<string>>) {}',
-
-    // functions
-    'function foo(arg: () => void) {}',
-
-    // unions
-    'function foo(arg: string | null) {}',
-    'function foo(arg: string | ReadonlyArray<string>) {}',
-    'function foo(arg: string | (() => void)) {}',
-    'function foo(arg: ReadonlyArray<string> | ReadonlyArray<number>) {}',
-
-    // objects
-    ...objects.map(type => `function foo(arg: Readonly<${type}>) {}`),
-    `
-      function foo(arg: {
-        readonly foo: {
-          readonly bar: string;
+    // Removing readonly causes duplicates
+    ...dedupeTestCases(
+      arrays.map<InvalidTestCase<MessageIds, Options>>(baseType => {
+        const type = baseType
+          .replaceAll('readonly ', '')
+          .replaceAll(/Readonly<(.+?)>/g, '$1')
+          .replaceAll('ReadonlyArray', 'Array');
+        return {
+          code: `function foo(arg: ${type}) {}`,
+          errors: [
+            {
+              column: 14,
+              endColumn: 19 + type.length,
+              messageId: 'shouldBeReadonly',
+            },
+          ],
         };
-      }) {}
-    `,
-    `
-      function foo(arg: { readonly [k: string]: string }) {}
-    `,
-    `
-      function foo(arg: { readonly [k: number]: string }) {}
-    `,
-    `
-      interface Empty {}
-      function foo(arg: Empty) {}
-    `,
-
-    // weird other cases
-    ...weirdIntersections.map(code => code),
-    `
-      interface Test extends ReadonlyArray<string> {
-        readonly property: boolean;
-      }
-      function foo(arg: Readonly<Test>) {}
-    `,
-    `
-      type Test = readonly string[] & {
-        readonly property: boolean;
-      };
-      function foo(arg: Readonly<Test>) {}
-    `,
-    `
-      type Test = string & number;
-      function foo(arg: Test) {}
-    `,
-
-    // declaration merging
-    `
-      class Foo {
-        readonly bang = 1;
-      }
-      interface Foo {
-        readonly prop: string;
-      }
-      interface Foo {
-        readonly prop2: string;
-      }
-      function foo(arg: Foo) {}
-    `,
-    // method made readonly via Readonly<T>
-    `
-      class Foo {
-        method() {}
-      }
-      function foo(arg: Readonly<Foo>) {}
-    `,
-    // immutable methods
-    `
-      type MyType = Readonly<{
-        prop: string;
-        method(): string;
-      }>;
-      function foo(arg: MyType) {}
-    `,
-    `
-      type MyType = {
-        readonly prop: string;
-        readonly method: () => string;
-      };
-      function bar(arg: MyType) {}
-    `,
-    // PrivateIdentifier is exempt from this rule
+      }),
+    ),
+    // nested arrays
     {
-      code: `
-        class Foo {
-          #privateField = 'foo';
-          #privateMember() {}
-        }
-        function foo(arg: Foo) {}
-      `,
+      code: 'function foo(arg: readonly string[][]) {}',
+      errors: [
+        {
+          column: 14,
+          endColumn: 38,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
     },
     {
-      code: `
-        class HasText {
-          readonly #text: string;
-        }
-
-        export function onDone(task: HasText): void {}
-      `,
+      code: 'function foo(arg: Readonly<string[][]>) {}',
+      errors: [
+        {
+          column: 14,
+          endColumn: 39,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
     },
-    // methods treated as readonly
     {
-      code: `
-        type MyType = {
-          readonly prop: string;
-          method(): string;
-        };
-        function foo(arg: MyType) {}
-      `,
-      options: [
+      code: 'function foo(arg: ReadonlyArray<Array<string>>) {}',
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 14,
+          endColumn: 47,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+
+    // objects
+    ...objects.map<InvalidTestCase<MessageIds, Options>>(type => {
+      return {
+        code: `function foo(arg: ${type}) {}`,
+        errors: [
+          {
+            column: 14,
+            endColumn: 19 + type.length,
+            messageId: 'shouldBeReadonly',
+          },
+        ],
+      };
+    }),
     {
       code: `
-        class Foo {
-          method() {}
-        }
-        function foo(arg: Foo) {}
+        function foo(arg: {
+          readonly foo: {
+            bar: string;
+          };
+        }) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 10,
+          endLine: 6,
+          line: 2,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+    // object index signatures
     {
       code: `
-        interface Foo {
-          method(): void;
-        }
-        function foo(arg: Foo) {}
+        function foo(arg: { [key: string]: string }) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 52,
+          endLine: 2,
+          line: 2,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // ReadonlySet and ReadonlyMap are seen as readonly when methods are treated as readonly
     {
       code: `
-        function foo(arg: ReadonlySet<string>) {}
-        function bar(arg: ReadonlyMap<string, string>) {}
+        function foo(arg: { [key: number]: string }) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 52,
+          endLine: 2,
+          line: 2,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // parameter properties should work fine
+
+    // weird intersections
+    ...weirdIntersections.map<InvalidTestCase<MessageIds, Options>>(
+      baseCode => {
+        const code = baseCode.replaceAll('readonly ', '');
+        return {
+          code,
+          errors: [{ messageId: 'shouldBeReadonly' }],
+        };
+      },
+    ),
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: readonly string[],
-            public arg2: readonly string[],
-            protected arg3: readonly string[],
-            readonly arg4: readonly string[],
-          ) {}
+        interface Test extends Array<string> {
+          readonly property: boolean;
         }
+        function foo(arg: Test) {}
       `,
-      options: [{ checkParameterProperties: true }],
-    },
-    {
-      code: `
-        class Foo {
-          constructor(
-            private arg1: string[],
-            public arg2: string[],
-            protected arg3: string[],
-            readonly arg4: string[],
-          ) {}
-        }
-      `,
-      options: [{ checkParameterProperties: false }],
-    },
-
-    // type functions
-    `
-      interface Foo {
-        (arg: readonly string[]): void;
-      }
-    `, // TSCallSignatureDeclaration
-    `
-      interface Foo {
-        new (arg: readonly string[]): void;
-      }
-    `, // TSConstructSignatureDeclaration
-    noFormat`class Foo { 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
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
-    // directly recursive interface
-    `
-      interface Foo {
-        readonly prop: Foo;
-      }
-      function foo(arg: Foo) {}
-    `,
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3396
-    // directly recursive union type
-    `
-      type MyType = string | readonly MyType[];
-
-      function foo<A extends MyType[]>(a: A): MyType[] {
-        return [];
-      }
-    `,
-    // indirectly recursive
-    `
-      interface Foo {
-        readonly prop: Bar;
-      }
-      interface Bar {
-        readonly prop: Foo;
-      }
-      function foo(arg: Foo) {}
-    `,
-    `
-      interface Foo {
-        prop: Readonly<Bar>;
-      }
-      interface Bar {
-        prop: Readonly<Foo>;
-      }
-      function foo(arg: Readonly<Foo>) {}
-    `,
-    `
-      const sym = Symbol('sym');
-
-      interface WithSymbol {
-        [sym]: number;
-      }
-
-      const willNotCrash = (foo: Readonly<WithSymbol>) => {};
-    `,
-    {
-      code: `
-        type Callback<T> = (options: T) => void;
-
-        declare const acceptsCallback: <T>(callback: Callback<T>) => void;
-
-        interface CallbackOptions {
-          prop: string;
-        }
-
-        acceptsCallback<CallbackOptions>(options => {});
-      `,
-      options: [
+      errors: [
         {
-          ignoreInferredTypes: true,
+          column: 22,
+          endColumn: 31,
+          endLine: 5,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      name: 'circular readonly types (Bug: #4476)',
       code: `
-        interface Obj {
-          readonly [K: string]: Obj;
+        interface Test extends Array<string> {
+          property: boolean;
         }
-
-        function foo(event: Obj): void {}
+        function foo(arg: Test) {}
       `,
-      options: [
+      errors: [
         {
-          checkParameterProperties: true,
-          ignoreInferredTypes: false,
-          ...readonlynessOptionsDefaults,
+          column: 22,
+          endColumn: 31,
+          endLine: 5,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+
+    // parameter properties should work fine
     {
-      name: 'circular readonly types (Bug: #5875)',
       code: `
-        interface Obj1 {
-          readonly [K: string]: Obj2;
-        }
-
-        interface Obj2 {
-          readonly [K: string]: Obj1;
+        class Foo {
+          constructor(
+            private arg1: string[],
+            public arg2: string[],
+            protected arg3: string[],
+            readonly arg4: string[],
+          ) {}
         }
-
-        function foo(event: Obj1): void {}
       `,
-      options: [
+      errors: [
         {
-          checkParameterProperties: true,
-          ignoreInferredTypes: false,
-          ...readonlynessOptionsDefaults,
+          column: 21,
+          endColumn: 35,
+          endLine: 4,
+          line: 4,
+          messageId: 'shouldBeReadonly',
         },
-      ],
-    },
-    // Allowlist
-    {
-      code: `
-        interface Foo {
-          readonly prop: RegExp;
-        }
-
-        function foo(arg: Foo) {}
-      `,
-      options: [
         {
-          allow: [{ from: 'lib', name: 'RegExp' }],
+          column: 20,
+          endColumn: 34,
+          endLine: 5,
+          line: 5,
+          messageId: 'shouldBeReadonly',
+        },
+        {
+          column: 23,
+          endColumn: 37,
+          endLine: 6,
+          line: 6,
+          messageId: 'shouldBeReadonly',
+        },
+        {
+          column: 22,
+          endColumn: 36,
+          endLine: 7,
+          line: 7,
+          messageId: 'shouldBeReadonly',
         },
       ],
+      options: [{ checkParameterProperties: true }],
     },
     {
       code: `
-        interface Foo {
-          prop: RegExp;
+        class Foo {
+          constructor(
+            private arg1: readonly string[],
+            public arg2: readonly string[],
+            protected arg3: readonly string[],
+            readonly arg4: readonly string[],
+            arg5: string[],
+          ) {}
         }
-
-        function foo(arg: Readonly<Foo>) {}
       `,
-      options: [
+      errors: [
         {
-          allow: [{ from: 'lib', name: 'RegExp' }],
+          column: 13,
+          endColumn: 27,
+          endLine: 8,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
+      options: [{ checkParameterProperties: false }],
     },
+
+    // type functions
     {
+      // TSCallSignatureDeclaration
       code: `
         interface Foo {
-          prop: string;
+          (arg: string[]): void;
         }
-
-        function foo(arg: Foo) {}
       `,
-      options: [
+      errors: [
         {
-          allow: [{ from: 'file', name: 'Foo' }],
+          column: 12,
+          endColumn: 25,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
+      // TSConstructSignatureDeclaration
       code: `
-        interface Bar {
-          prop: string;
-        }
         interface Foo {
-          readonly prop: Bar;
+          new (arg: string[]): void;
         }
-
-        function foo(arg: Foo) {}
       `,
-      options: [
+      errors: [
         {
-          allow: [{ from: 'file', name: 'Foo' }],
+          column: 16,
+          endColumn: 29,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      code: `
-        interface Bar {
-          prop: string;
-        }
-        interface Foo {
-          readonly prop: Bar;
-        }
-
-        function foo(arg: Foo) {}
-      `,
-      options: [
+      // TSEmptyBodyFunctionExpression
+      code: noFormat`class Foo { foo(arg: string[]): void; };`,
+      errors: [
         {
-          allow: [{ from: 'file', name: 'Bar' }],
+          column: 17,
+          endColumn: 30,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-  ],
-  invalid: [
-    // arrays
-    // Removing readonly causes duplicates
-    ...dedupeTestCases(
-      arrays.map<InvalidTestCase<MessageIds, Options>>(baseType => {
-        const type = baseType
-          .replaceAll('readonly ', '')
-          .replaceAll(/Readonly<(.+?)>/g, '$1')
-          .replaceAll('ReadonlyArray', 'Array');
-        return {
-          code: `function foo(arg: ${type}) {}`,
-          errors: [
-            {
-              messageId: 'shouldBeReadonly',
-              column: 14,
-              endColumn: 19 + type.length,
-            },
-          ],
-        };
-      }),
-    ),
-    // nested arrays
     {
-      code: 'function foo(arg: readonly string[][]) {}',
+      // TSDeclareFunction
+      code: 'function foo(arg: string[]);',
       errors: [
         {
-          messageId: 'shouldBeReadonly',
           column: 14,
-          endColumn: 38,
+          endColumn: 27,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      code: 'function foo(arg: Readonly<string[][]>) {}',
+      // TSFunctionType
+      code: 'type Foo = (arg: string[]) => void;',
       errors: [
         {
+          column: 13,
+          endColumn: 26,
           messageId: 'shouldBeReadonly',
-          column: 14,
-          endColumn: 39,
         },
       ],
     },
     {
-      code: 'function foo(arg: ReadonlyArray<Array<string>>) {}',
+      // TSMethodSignature
+      code: `
+        interface Foo {
+          foo(arg: string[]): void;
+        }
+      `,
       errors: [
         {
+          column: 15,
+          endColumn: 28,
           messageId: 'shouldBeReadonly',
-          column: 14,
-          endColumn: 47,
         },
       ],
     },
 
-    // objects
-    ...objects.map<InvalidTestCase<MessageIds, Options>>(type => {
-      return {
-        code: `function foo(arg: ${type}) {}`,
-        errors: [
-          {
-            messageId: 'shouldBeReadonly',
-            column: 14,
-            endColumn: 19 + type.length,
-          },
-        ],
-      };
-    }),
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
+    // directly recursive
     {
       code: `
-        function foo(arg: {
-          readonly foo: {
-            bar: string;
-          };
-        }) {}
+        interface Foo {
+          prop: Foo;
+        }
+        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 2,
           column: 22,
-          endLine: 6,
-          endColumn: 10,
+          endColumn: 30,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // object index signatures
     {
       code: `
-        function foo(arg: { [key: string]: string }) {}
+        interface Foo {
+          prop: Foo;
+        }
+        function foo(arg: Readonly<Foo>) {}
       `,
       errors: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 2,
           column: 22,
-          endLine: 2,
-          endColumn: 52,
+          endColumn: 40,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+    // indirectly recursive
     {
       code: `
-        function foo(arg: { [key: number]: string }) {}
+        interface Foo {
+          prop: Bar;
+        }
+        interface Bar {
+          readonly prop: Foo;
+        }
+        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 2,
           column: 22,
-          endLine: 2,
-          endColumn: 52,
+          endColumn: 30,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-
-    // weird intersections
-    ...weirdIntersections.map<InvalidTestCase<MessageIds, Options>>(
-      baseCode => {
-        const code = baseCode.replaceAll('readonly ', '');
-        return {
-          code,
-          errors: [{ messageId: 'shouldBeReadonly' }],
-        };
-      },
-    ),
     {
       code: `
-        interface Test extends Array<string> {
-          readonly property: boolean;
+        interface Foo {
+          prop: Bar;
         }
-        function foo(arg: Test) {}
+        interface Bar {
+          readonly prop: Foo;
+        }
+        function foo(arg: Readonly<Foo>) {}
       `,
       errors: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 5,
           column: 22,
-          endLine: 5,
-          endColumn: 31,
+          endColumn: 40,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
       code: `
-        interface Test extends Array<string> {
-          property: boolean;
+        interface Foo {
+          prop: Readonly<Bar>;
         }
-        function foo(arg: Test) {}
+        interface Bar {
+          prop: Readonly<Foo>;
+        }
+        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 5,
           column: 22,
-          endLine: 5,
-          endColumn: 31,
+          endColumn: 30,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-
-    // parameter properties should work fine
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: string[],
-            public arg2: string[],
-            protected arg3: string[],
-            readonly arg4: string[],
-          ) {}
+        const sym = Symbol('sym');
+
+        interface WithSymbol {
+          [sym]: number;
         }
+
+        const willNot = (foo: WithSymbol) => {};
       `,
-      options: [{ checkParameterProperties: true }],
       errors: [
         {
+          column: 26,
+          endColumn: 41,
+          line: 8,
           messageId: 'shouldBeReadonly',
-          line: 4,
-          column: 21,
-          endLine: 4,
-          endColumn: 35,
         },
+      ],
+    },
+    {
+      code: `
+        type Callback<T> = (options: T) => void;
+
+        declare const acceptsCallback: <T>(callback: Callback<T>) => void;
+
+        interface CallbackOptions {
+          prop: string;
+        }
+
+        acceptsCallback<CallbackOptions>((options: CallbackOptions) => {});
+      `,
+      errors: [
         {
+          column: 43,
+          endColumn: 67,
+          line: 10,
           messageId: 'shouldBeReadonly',
-          line: 5,
-          column: 20,
-          endLine: 5,
-          endColumn: 34,
         },
+      ],
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 6,
-          column: 23,
-          endLine: 6,
-          endColumn: 37,
+          ignoreInferredTypes: true,
         },
+      ],
+    },
+    // Mutable methods.
+    {
+      code: `
+        type MyType = {
+          readonly prop: string;
+          method(): string;
+        };
+        function foo(arg: MyType) {}
+      `,
+      errors: [
         {
+          column: 22,
+          endColumn: 33,
+          line: 6,
           messageId: 'shouldBeReadonly',
-          line: 7,
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3405
+    {
+      code: `
+        type MyType<T> = {
+          [K in keyof T]: 'cat' | 'dog' | T[K];
+        };
+
+        function method<A extends any[] = string[]>(value: MyType<A>) {
+          return value;
+        }
+
+        method(['cat', 'dog']);
+        method<'mouse'[]>(['cat', 'mouse']);
+      `,
+      errors: [{ line: 6, messageId: 'shouldBeReadonly' }],
+    },
+    // Allowlist
+    {
+      code: `
+        function foo(arg: RegExp) {}
+      `,
+      errors: [
+        {
           column: 22,
-          endLine: 7,
-          endColumn: 36,
+          endColumn: 33,
+          line: 2,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
+      options: [
+        {
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: readonly string[],
-            public arg2: readonly string[],
-            protected arg3: readonly string[],
-            readonly arg4: readonly string[],
-            arg5: string[],
-          ) {}
+        interface Foo {
+          readonly prop: RegExp;
         }
+
+        function foo(arg: Foo) {}
       `,
-      options: [{ checkParameterProperties: false }],
       errors: [
         {
+          column: 22,
+          endColumn: 30,
+          line: 6,
           messageId: 'shouldBeReadonly',
-          line: 8,
-          column: 13,
-          endLine: 8,
-          endColumn: 27,
+        },
+      ],
+      options: [
+        {
+          allow: [{ from: 'file', name: 'Bar' }],
         },
       ],
     },
-
-    // type functions
     {
-      // TSCallSignatureDeclaration
       code: `
         interface Foo {
-          (arg: string[]): void;
+          readonly prop: RegExp;
         }
+
+        function foo(arg: Foo) {}
       `,
       errors: [
         {
+          column: 22,
+          endColumn: 30,
+          line: 6,
           messageId: 'shouldBeReadonly',
-          column: 12,
-          endColumn: 25,
+        },
+      ],
+      options: [
+        {
+          allow: [{ from: 'lib', name: 'Foo' }],
         },
       ],
     },
     {
-      // TSConstructSignatureDeclaration
       code: `
         interface Foo {
-          new (arg: string[]): void;
+          readonly prop: RegExp;
         }
+
+        function foo(arg: Foo) {}
       `,
       errors: [
         {
+          column: 22,
+          endColumn: 30,
+          line: 6,
           messageId: 'shouldBeReadonly',
-          column: 16,
-          endColumn: 29,
         },
       ],
-    },
-    {
-      // TSEmptyBodyFunctionExpression
-      code: noFormat`class Foo { foo(arg: string[]): void; };`,
-      errors: [
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          column: 17,
-          endColumn: 30,
+          allow: [{ from: 'package', name: 'Foo', package: 'foo-lib' }],
         },
       ],
     },
     {
-      // TSDeclareFunction
-      code: 'function foo(arg: string[]);',
+      code: `
+        function foo(arg: RegExp) {}
+      `,
       errors: [
         {
+          column: 22,
+          endColumn: 33,
+          line: 2,
           messageId: 'shouldBeReadonly',
-          column: 14,
-          endColumn: 27,
         },
       ],
-    },
-    {
-      // TSFunctionType
-      code: 'type Foo = (arg: string[]) => void;',
-      errors: [
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          column: 13,
-          endColumn: 26,
+          allow: [{ from: 'file', name: 'RegExp' }],
         },
       ],
     },
     {
-      // TSMethodSignature
       code: `
-        interface Foo {
-          foo(arg: string[]): void;
-        }
+        function foo(arg: RegExp) {}
       `,
       errors: [
         {
+          column: 22,
+          endColumn: 33,
+          line: 2,
           messageId: 'shouldBeReadonly',
-          column: 15,
-          endColumn: 28,
+        },
+      ],
+      options: [
+        {
+          allow: [{ from: 'package', name: 'RegExp', package: 'regexp-lib' }],
         },
       ],
     },
+  ],
+  valid: [
+    'function foo() {}',
 
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
-    // directly recursive
+    // primitives
+    ...primitives.map(type => `function foo(arg: ${type}) {}`),
+    `
+      const symb = Symbol('a');
+      function foo(arg: typeof symb) {}
+    `,
+    `
+      enum Enum {
+        a,
+        b,
+      }
+      function foo(arg: Enum) {}
+    `,
+
+    // arrays
+    ...arrays.map(type => `function foo(arg: ${type}) {}`),
+    // nested arrays
+    'function foo(arg: readonly (readonly string[])[]) {}',
+    'function foo(arg: Readonly<Readonly<string[]>[]>) {}',
+    'function foo(arg: ReadonlyArray<ReadonlyArray<string>>) {}',
+
+    // functions
+    'function foo(arg: () => void) {}',
+
+    // unions
+    'function foo(arg: string | null) {}',
+    'function foo(arg: string | ReadonlyArray<string>) {}',
+    'function foo(arg: string | (() => void)) {}',
+    'function foo(arg: ReadonlyArray<string> | ReadonlyArray<number>) {}',
+
+    // objects
+    ...objects.map(type => `function foo(arg: Readonly<${type}>) {}`),
+    `
+      function foo(arg: {
+        readonly foo: {
+          readonly bar: string;
+        };
+      }) {}
+    `,
+    `
+      function foo(arg: { readonly [k: string]: string }) {}
+    `,
+    `
+      function foo(arg: { readonly [k: number]: string }) {}
+    `,
+    `
+      interface Empty {}
+      function foo(arg: Empty) {}
+    `,
+
+    // weird other cases
+    ...weirdIntersections.map(code => code),
+    `
+      interface Test extends ReadonlyArray<string> {
+        readonly property: boolean;
+      }
+      function foo(arg: Readonly<Test>) {}
+    `,
+    `
+      type Test = readonly string[] & {
+        readonly property: boolean;
+      };
+      function foo(arg: Readonly<Test>) {}
+    `,
+    `
+      type Test = string & number;
+      function foo(arg: Test) {}
+    `,
+
+    // declaration merging
+    `
+      class Foo {
+        readonly bang = 1;
+      }
+      interface Foo {
+        readonly prop: string;
+      }
+      interface Foo {
+        readonly prop2: string;
+      }
+      function foo(arg: Foo) {}
+    `,
+    // method made readonly via Readonly<T>
+    `
+      class Foo {
+        method() {}
+      }
+      function foo(arg: Readonly<Foo>) {}
+    `,
+    // immutable methods
+    `
+      type MyType = Readonly<{
+        prop: string;
+        method(): string;
+      }>;
+      function foo(arg: MyType) {}
+    `,
+    `
+      type MyType = {
+        readonly prop: string;
+        readonly method: () => string;
+      };
+      function bar(arg: MyType) {}
+    `,
+    // PrivateIdentifier is exempt from this rule
     {
       code: `
-        interface Foo {
-          prop: Foo;
+        class Foo {
+          #privateField = 'foo';
+          #privateMember() {}
         }
         function foo(arg: Foo) {}
       `,
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 5,
-          column: 22,
-          endColumn: 30,
-        },
-      ],
     },
     {
       code: `
-        interface Foo {
-          prop: Foo;
+        class HasText {
+          readonly #text: string;
         }
-        function foo(arg: Readonly<Foo>) {}
+
+        export function onDone(task: HasText): void {}
       `,
-      errors: [
+    },
+    // methods treated as readonly
+    {
+      code: `
+        type MyType = {
+          readonly prop: string;
+          method(): string;
+        };
+        function foo(arg: MyType) {}
+      `,
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 5,
-          column: 22,
-          endColumn: 40,
+          treatMethodsAsReadonly: true,
         },
       ],
     },
-    // indirectly recursive
     {
       code: `
-        interface Foo {
-          prop: Bar;
-        }
-        interface Bar {
-          readonly prop: Foo;
+        class Foo {
+          method() {}
         }
         function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 8,
-          column: 22,
-          endColumn: 30,
+          treatMethodsAsReadonly: true,
         },
       ],
     },
     {
       code: `
         interface Foo {
-          prop: Bar;
-        }
-        interface Bar {
-          readonly prop: Foo;
+          method(): void;
         }
-        function foo(arg: Readonly<Foo>) {}
+        function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 8,
-          column: 22,
-          endColumn: 40,
+          treatMethodsAsReadonly: true,
+        },
+      ],
+    },
+    // ReadonlySet and ReadonlyMap are seen as readonly when methods are treated as readonly
+    {
+      code: `
+        function foo(arg: ReadonlySet<string>) {}
+        function bar(arg: ReadonlyMap<string, string>) {}
+      `,
+      options: [
+        {
+          treatMethodsAsReadonly: true,
         },
       ],
     },
+    // parameter properties should work fine
     {
       code: `
-        interface Foo {
-          prop: Readonly<Bar>;
-        }
-        interface Bar {
-          prop: Readonly<Foo>;
+        class Foo {
+          constructor(
+            private arg1: readonly string[],
+            public arg2: readonly string[],
+            protected arg3: readonly string[],
+            readonly arg4: readonly string[],
+          ) {}
         }
-        function foo(arg: Foo) {}
       `,
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 8,
-          column: 22,
-          endColumn: 30,
-        },
-      ],
+      options: [{ checkParameterProperties: true }],
     },
     {
       code: `
-        const sym = Symbol('sym');
-
-        interface WithSymbol {
-          [sym]: number;
+        class Foo {
+          constructor(
+            private arg1: string[],
+            public arg2: string[],
+            protected arg3: string[],
+            readonly arg4: string[],
+          ) {}
         }
-
-        const willNot = (foo: WithSymbol) => {};
       `,
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 8,
-          column: 26,
-          endColumn: 41,
-        },
-      ],
+      options: [{ checkParameterProperties: false }],
     },
+
+    // type functions
+    `
+      interface Foo {
+        (arg: readonly string[]): void;
+      }
+    `, // TSCallSignatureDeclaration
+    `
+      interface Foo {
+        new (arg: readonly string[]): void;
+      }
+    `, // TSConstructSignatureDeclaration
+    noFormat`class Foo { 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
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
+    // directly recursive interface
+    `
+      interface Foo {
+        readonly prop: Foo;
+      }
+      function foo(arg: Foo) {}
+    `,
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3396
+    // directly recursive union type
+    `
+      type MyType = string | readonly MyType[];
+
+      function foo<A extends MyType[]>(a: A): MyType[] {
+        return [];
+      }
+    `,
+    // indirectly recursive
+    `
+      interface Foo {
+        readonly prop: Bar;
+      }
+      interface Bar {
+        readonly prop: Foo;
+      }
+      function foo(arg: Foo) {}
+    `,
+    `
+      interface Foo {
+        prop: Readonly<Bar>;
+      }
+      interface Bar {
+        prop: Readonly<Foo>;
+      }
+      function foo(arg: Readonly<Foo>) {}
+    `,
+    `
+      const sym = Symbol('sym');
+
+      interface WithSymbol {
+        [sym]: number;
+      }
+
+      const willNotCrash = (foo: Readonly<WithSymbol>) => {};
+    `,
     {
       code: `
         type Callback<T> = (options: T) => void;
@@ -902,75 +952,53 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
           prop: string;
         }
 
-        acceptsCallback<CallbackOptions>((options: CallbackOptions) => {});
+        acceptsCallback<CallbackOptions>(options => {});
       `,
       options: [
         {
           ignoreInferredTypes: true,
         },
       ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 10,
-          column: 43,
-          endColumn: 67,
-        },
-      ],
     },
-    // Mutable methods.
     {
       code: `
-        type MyType = {
-          readonly prop: string;
-          method(): string;
-        };
-        function foo(arg: MyType) {}
+        interface Obj {
+          readonly [K: string]: Obj;
+        }
+
+        function foo(event: Obj): void {}
       `,
-      errors: [
+      name: 'circular readonly types (Bug: #4476)',
+      options: [
         {
-          messageId: 'shouldBeReadonly',
-          line: 6,
-          column: 22,
-          endColumn: 33,
+          checkParameterProperties: true,
+          ignoreInferredTypes: false,
+          ...readonlynessOptionsDefaults,
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3405
     {
       code: `
-        type MyType<T> = {
-          [K in keyof T]: 'cat' | 'dog' | T[K];
-        };
+        interface Obj1 {
+          readonly [K: string]: Obj2;
+        }
 
-        function method<A extends any[] = string[]>(value: MyType<A>) {
-          return value;
+        interface Obj2 {
+          readonly [K: string]: Obj1;
         }
 
-        method(['cat', 'dog']);
-        method<'mouse'[]>(['cat', 'mouse']);
-      `,
-      errors: [{ line: 6, messageId: 'shouldBeReadonly' }],
-    },
-    // Allowlist
-    {
-      code: `
-        function foo(arg: RegExp) {}
+        function foo(event: Obj1): void {}
       `,
+      name: 'circular readonly types (Bug: #5875)',
       options: [
         {
-          allow: [{ from: 'file', name: 'Foo' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 2,
-          column: 22,
-          endColumn: 33,
+          checkParameterProperties: true,
+          ignoreInferredTypes: false,
+          ...readonlynessOptionsDefaults,
         },
       ],
     },
+    // Allowlist
     {
       code: `
         interface Foo {
@@ -981,95 +1009,69 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
       `,
       options: [
         {
-          allow: [{ from: 'file', name: 'Bar' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 6,
-          column: 22,
-          endColumn: 30,
+          allow: [{ from: 'lib', name: 'RegExp' }],
         },
       ],
     },
     {
       code: `
         interface Foo {
-          readonly prop: RegExp;
+          prop: RegExp;
         }
 
-        function foo(arg: Foo) {}
+        function foo(arg: Readonly<Foo>) {}
       `,
       options: [
         {
-          allow: [{ from: 'lib', name: 'Foo' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 6,
-          column: 22,
-          endColumn: 30,
+          allow: [{ from: 'lib', name: 'RegExp' }],
         },
       ],
     },
     {
       code: `
         interface Foo {
-          readonly prop: RegExp;
+          prop: string;
         }
 
         function foo(arg: Foo) {}
       `,
       options: [
         {
-          allow: [{ from: 'package', name: 'Foo', package: 'foo-lib' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 6,
-          column: 22,
-          endColumn: 30,
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
     {
       code: `
-        function foo(arg: RegExp) {}
+        interface Bar {
+          prop: string;
+        }
+        interface Foo {
+          readonly prop: Bar;
+        }
+
+        function foo(arg: Foo) {}
       `,
       options: [
         {
-          allow: [{ from: 'file', name: 'RegExp' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 2,
-          column: 22,
-          endColumn: 33,
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
     {
       code: `
-        function foo(arg: RegExp) {}
+        interface Bar {
+          prop: string;
+        }
+        interface Foo {
+          readonly prop: Bar;
+        }
+
+        function foo(arg: Foo) {}
       `,
       options: [
         {
-          allow: [{ from: 'package', name: 'RegExp', package: 'regexp-lib' }],
-        },
-      ],
-      errors: [
-        {
-          messageId: 'shouldBeReadonly',
-          line: 2,
-          column: 22,
-          endColumn: 33,
+          allow: [{ from: 'file', name: 'Bar' }],
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
index 82c7324be605..f6f5881e19bb 100644
--- a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
@@ -7,596 +7,794 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 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 TestReadonlyStatic {
-        static readonly #correctlyReadonlyStatic = 7;
-      }
-    `,
-    `
-      class TestModifiableStatic {
-        private static correctlyModifiableStatic = 7;
-
-        public constructor() {
-          TestModifiableStatic.correctlyModifiableStatic += 1;
+  invalid: [
+    {
+      code: `
+        class TestIncorrectlyModifiableStatic {
+          private static incorrectlyModifiableStatic = 7;
         }
-      }
-    `,
-    `
-      class TestModifiableStatic {
-        static #correctlyModifiableStatic = 7;
-
-        public constructor() {
-          TestModifiableStatic.#correctlyModifiableStatic += 1;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiableStatic',
+          },
+          endColumn: 53,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableStatic {
+          private static readonly incorrectlyModifiableStatic = 7;
         }
-      }
-    `,
-    `
-      class TestModifiableByParameterProperty {
-        private static readonly correctlyModifiableByParameterProperty = 7;
-
-        public constructor(
-          public correctlyModifiablePublicParameter: number = (() => {
-            return (TestModifiableStatic.correctlyModifiableByParameterProperty += 1);
-          })(),
-        ) {}
-      }
-    `,
-    `
-      class TestModifiableByParameterProperty {
-        static readonly #correctlyModifiableByParameterProperty = 7;
-
-        public constructor(
-          public correctlyModifiablePublicParameter: number = (() => {
-            return (TestModifiableStatic.#correctlyModifiableByParameterProperty += 1);
-          })(),
-        ) {}
-      }
-    `,
-    `
-      class TestReadonlyInline {
-        private readonly correctlyReadonlyInline = 7;
-      }
-    `,
-    `
-      class TestReadonlyInline {
-        readonly #correctlyReadonlyInline = 7;
-      }
-    `,
-    `
-      class TestReadonlyDelayed {
-        private readonly correctlyReadonlyDelayed = 7;
-
-        public constructor() {
-          this.correctlyReadonlyDelayed += 1;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableStatic {
+          static #incorrectlyModifiableStatic = 7;
         }
-      }
-    `,
-    `
-      class TestReadonlyDelayed {
-        readonly #correctlyReadonlyDelayed = 7;
-
-        public constructor() {
-          this.#correctlyReadonlyDelayed += 1;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiableStatic',
+          },
+          endColumn: 46,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableStatic {
+          static readonly #incorrectlyModifiableStatic = 7;
         }
-      }
-    `,
-    `
-      class TestModifiableInline {
-        private correctlyModifiableInline = 7;
-
-        public mutate() {
-          this.correctlyModifiableInline += 1;
-
-          return class {
-            private correctlyModifiableInline = 7;
-
-            mutate() {
-              this.correctlyModifiableInline += 1;
-            }
-          };
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableStaticArrow {
+          private static incorrectlyModifiableStaticArrow = () => 7;
         }
-      }
-    `,
-    `
-      class TestModifiableInline {
-        #correctlyModifiableInline = 7;
-
-        public mutate() {
-          this.#correctlyModifiableInline += 1;
-
-          return class {
-            #correctlyModifiableInline = 7;
-
-            mutate() {
-              this.#correctlyModifiableInline += 1;
-            }
-          };
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiableStaticArrow',
+          },
+          endColumn: 58,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableStaticArrow {
+          private static readonly incorrectlyModifiableStaticArrow = () => 7;
         }
-      }
-    `,
-    `
-      class TestModifiableDelayed {
-        private correctlyModifiableDelayed = 7;
-
-        public mutate() {
-          this.correctlyModifiableDelayed += 1;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableStaticArrow {
+          static #incorrectlyModifiableStaticArrow = () => 7;
         }
-      }
-    `,
-    `
-      class TestModifiableDelayed {
-        #correctlyModifiableDelayed = 7;
-
-        public mutate() {
-          this.#correctlyModifiableDelayed += 1;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiableStaticArrow',
+          },
+          endColumn: 51,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableStaticArrow {
+          static readonly #incorrectlyModifiableStaticArrow = () => 7;
         }
-      }
-    `,
-    `
-      class TestModifiableDeleted {
-        private correctlyModifiableDeleted = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableInline {
+          private incorrectlyModifiableInline = 7;
 
-        public mutate() {
-          delete this.correctlyModifiableDeleted;
-        }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructor {
-        private correctlyModifiableWithinConstructor = 7;
-
-        public constructor() {
-          (() => {
-            this.correctlyModifiableWithinConstructor += 1;
-          })();
+          public createConfusingChildClass() {
+            return class {
+              private incorrectlyModifiableInline = 7;
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructor {
-        #correctlyModifiableWithinConstructor = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiableInline',
+          },
+          endColumn: 46,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+        {
+          column: 15,
+          data: {
+            name: 'incorrectlyModifiableInline',
+          },
+          endColumn: 50,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableInline {
+          private readonly incorrectlyModifiableInline = 7;
 
-        public constructor() {
-          (() => {
-            this.#correctlyModifiableWithinConstructor += 1;
-          })();
+          public createConfusingChildClass() {
+            return class {
+              private readonly incorrectlyModifiableInline = 7;
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorArrowFunction {
-        private correctlyModifiableWithinConstructorArrowFunction = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableInline {
+          #incorrectlyModifiableInline = 7;
 
-        public constructor() {
-          (() => {
-            this.correctlyModifiableWithinConstructorArrowFunction += 1;
-          })();
+          public createConfusingChildClass() {
+            return class {
+              #incorrectlyModifiableInline = 7;
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorArrowFunction {
-        #correctlyModifiableWithinConstructorArrowFunction = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiableInline',
+          },
+          endColumn: 39,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+        {
+          column: 15,
+          data: {
+            name: '#incorrectlyModifiableInline',
+          },
+          endColumn: 43,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableInline {
+          readonly #incorrectlyModifiableInline = 7;
 
-        public constructor() {
-          (() => {
-            this.#correctlyModifiableWithinConstructorArrowFunction += 1;
-          })();
+          public createConfusingChildClass() {
+            return class {
+              readonly #incorrectlyModifiableInline = 7;
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInFunctionExpression {
-        private correctlyModifiableWithinConstructorInFunctionExpression = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableDelayed {
+          private incorrectlyModifiableDelayed = 7;
 
-        public constructor() {
-          const self = this;
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiableDelayed',
+          },
+          endColumn: 47,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableDelayed {
+          private readonly incorrectlyModifiableDelayed = 7;
 
-          (() => {
-            self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
-          })();
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInFunctionExpression {
-        #correctlyModifiableWithinConstructorInFunctionExpression = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableDelayed {
+          #incorrectlyModifiableDelayed = 7;
 
-        public constructor() {
-          const self = this;
+          public constructor() {
+            this.#incorrectlyModifiableDelayed = 7;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiableDelayed',
+          },
+          endColumn: 40,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableDelayed {
+          readonly #incorrectlyModifiableDelayed = 7;
 
-          (() => {
-            self.#correctlyModifiableWithinConstructorInFunctionExpression += 1;
-          })();
+          public constructor() {
+            this.#incorrectlyModifiableDelayed = 7;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInGetAccessor {
-        private correctlyModifiableWithinConstructorInGetAccessor = 7;
+      `,
+    },
+    {
+      code: `
+        class TestChildClassExpressionModifiable {
+          private childClassExpressionModifiable = 7;
 
-        public constructor() {
-          const self = this;
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
 
-          const confusingObject = {
-            get accessor() {
-              return (self.correctlyModifiableWithinConstructorInGetAccessor += 1);
-            },
-          };
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInGetAccessor {
-        #correctlyModifiableWithinConstructorInGetAccessor = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'childClassExpressionModifiable',
+          },
+          endColumn: 49,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestChildClassExpressionModifiable {
+          private readonly childClassExpressionModifiable = 7;
 
-        public constructor() {
-          const self = this;
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
 
-          const confusingObject = {
-            get accessor() {
-              return (self.#correctlyModifiableWithinConstructorInGetAccessor += 1);
-            },
-          };
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInMethodDeclaration {
-        private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+      `,
+    },
+    {
+      code: `
+        class TestChildClassExpressionModifiable {
+          #childClassExpressionModifiable = 7;
 
-        public constructor() {
-          const self = this;
+          public createConfusingChildClass() {
+            return class {
+              #childClassExpressionModifiable = 7;
 
-          const confusingObject = {
-            methodDeclaration() {
-              self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-            },
-          };
+              mutate() {
+                this.#childClassExpressionModifiable += 1;
+              }
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInMethodDeclaration {
-        #correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#childClassExpressionModifiable',
+          },
+          endColumn: 42,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestChildClassExpressionModifiable {
+          readonly #childClassExpressionModifiable = 7;
 
-        public constructor() {
-          const self = this;
+          public createConfusingChildClass() {
+            return class {
+              #childClassExpressionModifiable = 7;
 
-          const confusingObject = {
-            methodDeclaration() {
-              self.#correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-            },
-          };
+              mutate() {
+                this.#childClassExpressionModifiable += 1;
+              }
+            };
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInSetAccessor {
-        private correctlyModifiableWithinConstructorInSetAccessor = 7;
-
-        public constructor() {
-          const self = this;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiablePostMinus {
+          private incorrectlyModifiablePostMinus = 7;
 
-          const confusingObject = {
-            set accessor(value: number) {
-              self.correctlyModifiableWithinConstructorInSetAccessor += value;
-            },
-          };
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInSetAccessor {
-        #correctlyModifiableWithinConstructorInSetAccessor = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiablePostMinus',
+          },
+          endColumn: 49,
+          endLine: 3,
 
-        public constructor() {
-          const self = this;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePostMinus {
+          private readonly incorrectlyModifiablePostMinus = 7;
 
-          const confusingObject = {
-            set accessor(value: number) {
-              self.#correctlyModifiableWithinConstructorInSetAccessor += value;
-            },
-          };
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePostDecremented {
-        private correctlyModifiablePostDecremented = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiablePostMinus {
+          #incorrectlyModifiablePostMinus = 7;
 
-        public mutate() {
-          this.correctlyModifiablePostDecremented -= 1;
+          public mutate() {
+            this.#incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePostDecremented {
-        #correctlyModifiablePostDecremented = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiablePostMinus',
+          },
+          endColumn: 42,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePostMinus {
+          readonly #incorrectlyModifiablePostMinus = 7;
 
-        public mutate() {
-          this.#correctlyModifiablePostDecremented -= 1;
+          public mutate() {
+            this.#incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }
-    `,
-    `
-      class TestyModifiablePostIncremented {
-        private correctlyModifiablePostIncremented = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiablePostPlus {
+          private incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          this.correctlyModifiablePostIncremented += 1;
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }
-    `,
-    `
-      class TestyModifiablePostIncremented {
-        #correctlyModifiablePostIncremented = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiablePostPlus',
+          },
+          endColumn: 48,
+          endLine: 3,
 
-        public mutate() {
-          this.#correctlyModifiablePostIncremented += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiablePreDecremented {
-        private correctlyModifiablePreDecremented = 7;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePostPlus {
+          private readonly incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          --this.correctlyModifiablePreDecremented;
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreDecremented {
-        #correctlyModifiablePreDecremented = 7;
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiablePostPlus {
+          #incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          --this.#correctlyModifiablePreDecremented;
+          public mutate() {
+            this.#incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreIncremented {
-        private correctlyModifiablePreIncremented = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiablePostPlus',
+          },
+          endColumn: 41,
+          endLine: 3,
 
-        public mutate() {
-          ++this.correctlyModifiablePreIncremented;
-        }
-      }
-    `,
-    `
-      class TestModifiablePreIncremented {
-        #correctlyModifiablePreIncremented = 7;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePostPlus {
+          readonly #incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          ++this.#correctlyModifiablePreIncremented;
+          public mutate() {
+            this.#incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }
-    `,
-    `
-      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;
-        }
-      }
-    `,
+      `,
+    },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          private correctlyNonInlineLambda = 7;
+        class TestIncorrectlyModifiablePreMinus {
+          private incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
+          }
         }
       `,
-      options: [
+      errors: [
         {
-          onlyInlineLambdas: true,
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiablePreMinus',
+          },
+          endColumn: 48,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
         },
       ],
+      output: `
+        class TestIncorrectlyModifiablePreMinus {
+          private readonly incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
+          }
+        }
+      `,
     },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          #correctlyNonInlineLambda = 7;
+        class TestIncorrectlyModifiablePreMinus {
+          #incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.#incorrectlyModifiablePreMinus;
+          }
         }
       `,
-      options: [
+      errors: [
         {
-          onlyInlineLambdas: true,
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiablePreMinus',
+          },
+          endColumn: 41,
+          endLine: 3,
+
+          line: 3,
+          messageId: 'preferReadonly',
         },
       ],
-    },
-    `
-      class TestComputedParameter {
-        public mutate() {
-          this['computed'] = 1;
-        }
-      }
-    `,
-    `
-      class TestComputedParameter {
-        private ['computed-ignored-by-rule'] = 1;
-      }
-    `,
-    {
-      code: `
-class Foo {
-  private value: number = 0;
+      output: `
+        class TestIncorrectlyModifiablePreMinus {
+          readonly #incorrectlyModifiablePreMinus = 7;
 
-  bar(newValue: { value: number }) {
-    ({ value: this.value } = newValue);
-    return this.value;
-  }
-}
+          public mutate() {
+            -this.#incorrectlyModifiablePreMinus;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  #value: number = 0;
+        class TestIncorrectlyModifiablePrePlus {
+          private incorrectlyModifiablePrePlus = 7;
 
-  bar(newValue: { value: number }) {
-    ({ value: this.#value } = newValue);
-    return this.#value;
-  }
-}
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
+          }
+        }
       `,
-    },
-    {
-      code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    private _name: string;
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyModifiablePrePlus',
+          },
+          endColumn: 47,
+          endLine: 3,
 
-    public test(value: string) {
-      this._name = value;
-    }
-  };
-}
-      `,
-    },
-    {
-      code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    #name: string;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePrePlus {
+          private readonly incorrectlyModifiablePrePlus = 7;
 
-    public test(value: string) {
-      this.#name = value;
-    }
-  };
-}
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: Record<string, number> = {};
+        class TestIncorrectlyModifiablePrePlus {
+          #incorrectlyModifiablePrePlus = 7;
 
-  bar(newValue: Record<string, number>) {
-    ({ ...this.value } = newValue);
-    return this.value;
-  }
-}
+          public mutate() {
+            +this.#incorrectlyModifiablePrePlus;
+          }
+        }
       `,
-    },
-    {
-      code: `
-class Foo {
-  #value: Record<string, number> = {};
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#incorrectlyModifiablePrePlus',
+          },
+          endColumn: 40,
+          endLine: 3,
 
-  bar(newValue: Record<string, number>) {
-    ({ ...this.#value } = newValue);
-    return this.#value;
-  }
-}
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiablePrePlus {
+          readonly #incorrectlyModifiablePrePlus = 7;
+
+          public mutate() {
+            +this.#incorrectlyModifiablePrePlus;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: number[] = [];
+        class TestOverlappingClassVariable {
+          private overlappingClassVariable = 7;
 
-  bar(newValue: number[]) {
-    [...this.value] = newValue;
-    return this.value;
-  }
-}
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
+          }
+        }
+
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
       `,
-    },
-    {
-      code: `
-class Foo {
-  #value: number[] = [];
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'overlappingClassVariable',
+          },
+          endColumn: 43,
+          endLine: 3,
 
-  bar(newValue: number[]) {
-    [...this.#value] = newValue;
-    return this.#value;
-  }
-}
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestOverlappingClassVariable {
+          private readonly overlappingClassVariable = 7;
+
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
+          }
+        }
+
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: number = 0;
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private incorrectlyModifiableParameter = 7) {}
+        }
+      `,
+      errors: [
+        {
+          column: 30,
+          data: {
+            name: 'incorrectlyModifiableParameter',
+          },
+          endColumn: 68,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private readonly incorrectlyModifiableParameter = 7) {}
+        }
+      `,
+    },
+    {
+      code: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private incorrectlyModifiableParameter = 7,
+          ) {}
+        }
+      `,
+      errors: [
+        {
+          column: 13,
+          data: {
+            name: 'incorrectlyModifiableParameter',
+          },
+          endColumn: 51,
+          endLine: 5,
 
-  bar(newValue: number[]) {
-    [this.value] = newValue;
-    return this.value;
-  }
+          line: 5,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private readonly incorrectlyModifiableParameter = 7,
+          ) {}
+        }
+      `,
+    },
+    {
+      code: `
+        class TestCorrectlyNonInlineLambdas {
+          private incorrectlyInlineLambda = () => 7;
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'incorrectlyInlineLambda',
+          },
+          endColumn: 42,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      options: [
+        {
+          onlyInlineLambdas: true,
+        },
+      ],
+      output: `
+        class TestCorrectlyNonInlineLambdas {
+          private readonly incorrectlyInlineLambda = () => 7;
+        }
+      `,
+    },
+    {
+      code: `
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    private _name: string;
+  };
+}
+      `,
+      errors: [
+        {
+          column: 5,
+          data: {
+            name: '_name',
+          },
+          endColumn: 18,
+          endLine: 4,
+          line: 4,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    private readonly _name: string;
+  };
 }
       `,
     },
     {
       code: `
-class Foo {
-  #value: number = 0;
-
-  bar(newValue: number[]) {
-    [this.#value] = newValue;
-    return this.#value;
-  }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    #name: string;
+  };
+}
+      `,
+      errors: [
+        {
+          column: 5,
+          data: {
+            name: '#name',
+          },
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    readonly #name: string;
+  };
 }
       `,
     },
@@ -608,7 +806,31 @@ class Foo {
           };
 
           public test(): void {
-            this.testObj = '';
+            this.testObj.prop = '';
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {
+            prop: '',
+          };
+
+          public test(): void {
+            this.testObj.prop = '';
           }
         }
       `,
@@ -621,7 +843,30 @@ class Foo {
           };
 
           public test(): void {
-            this.#testObj = '';
+            this.#testObj.prop = '';
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {
+            prop: '',
+          };
+
+          public test(): void {
+            this.#testObj.prop = '';
           }
         }
       `,
@@ -636,7 +881,32 @@ class Foo {
           private testObj = new TestObject();
 
           public test(): void {
-            this.testObj = new TestObject();
+            this.testObj.prop = 10;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestObject {
+          public prop: number;
+        }
+
+        class Test {
+          private readonly testObj = new TestObject();
+
+          public test(): void {
+            this.testObj.prop = 10;
           }
         }
       `,
@@ -651,1687 +921,1417 @@ class Foo {
           #testObj = new TestObject();
 
           public test(): void {
-            this.#testObj = new TestObject();
+            this.#testObj.prop = 10;
           }
         }
       `,
-    },
-    `
-      class TestIntersection {
-        private prop: number = 3;
-
-        test() {
-          const that = {} as this & { _foo: 'bar' };
-          that.prop = 1;
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestObject {
+          public prop: number;
         }
-      }
-    `,
-    `
-      class TestUnion {
-        private prop: number = 3;
 
-        test() {
-          const that = {} as this | (this & { _foo: 'bar' });
-          that.prop = 1;
-        }
-      }
-    `,
-    `
-      class TestStaticIntersection {
-        private static prop: number;
-
-        test() {
-          const that = {} as typeof TestStaticIntersection & { _foo: 'bar' };
-          that.prop = 1;
-        }
-      }
-    `,
-    `
-      class TestStaticUnion {
-        private static prop: number = 1;
-
-        test() {
-          const that = {} as
-            | typeof TestStaticUnion
-            | (typeof TestStaticUnion & { _foo: 'bar' });
-          that.prop = 1;
-        }
-      }
-    `,
-    `
-      class TestBothIntersection {
-        private prop1: number = 1;
-        private static prop2: number;
-
-        test() {
-          const that = {} as typeof TestBothIntersection & this;
-          that.prop1 = 1;
-          that.prop2 = 1;
-        }
-      }
-    `,
-    `
-      class TestBothIntersection {
-        private prop1: number = 1;
-        private static prop2: number;
+        class Test {
+          readonly #testObj = new TestObject();
 
-        test() {
-          const that = {} as this & typeof TestBothIntersection;
-          that.prop1 = 1;
-          that.prop2 = 1;
+          public test(): void {
+            this.#testObj.prop = 10;
+          }
         }
-      }
-    `,
-    `
-      class TestStaticPrivateAccessor {
-        private static accessor staticAcc = 1;
-      }
-    `,
-    `
-      class TestStaticPrivateFieldAccessor {
-        static accessor #staticAcc = 1;
-      }
-    `,
-    `
-      class TestPrivateAccessor {
-        private accessor acc = 3;
-      }
-    `,
-    `
-      class TestPrivateFieldAccessor {
-        accessor #acc = 3;
-      }
-    `,
-  ],
-  invalid: [
+      `,
+    },
     {
       code: `
-        class TestIncorrectlyModifiableStatic {
-          private static incorrectlyModifiableStatic = 7;
+        class Test {
+          private testObj = {
+            prop: '',
+          };
+          public test(): void {
+            this.testObj.prop;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 53,
           data: {
-            name: 'incorrectlyModifiableStatic',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableStatic {
-          private static readonly incorrectlyModifiableStatic = 7;
+        class Test {
+          private readonly testObj = {
+            prop: '',
+          };
+          public test(): void {
+            this.testObj.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableStatic {
-          static #incorrectlyModifiableStatic = 7;
+        class Test {
+          #testObj = {
+            prop: '',
+          };
+          public test(): void {
+            this.#testObj.prop;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 46,
           data: {
-            name: '#incorrectlyModifiableStatic',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableStatic {
-          static readonly #incorrectlyModifiableStatic = 7;
+        class Test {
+          readonly #testObj = {
+            prop: '',
+          };
+          public test(): void {
+            this.#testObj.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableStaticArrow {
-          private static incorrectlyModifiableStaticArrow = () => 7;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 58,
           data: {
-            name: 'incorrectlyModifiableStaticArrow',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableStaticArrow {
-          private static readonly incorrectlyModifiableStaticArrow = () => 7;
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableStaticArrow {
-          static #incorrectlyModifiableStaticArrow = () => 7;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 51,
           data: {
-            name: '#incorrectlyModifiableStaticArrow',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableStaticArrow {
-          static readonly #incorrectlyModifiableStaticArrow = () => 7;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableInline {
-          private incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private incorrectlyModifiableInline = 7;
-            };
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj!.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 46,
-          data: {
-            name: 'incorrectlyModifiableInline',
-          },
-          messageId: 'preferReadonly',
-        },
-        {
-          line: 7,
-          column: 15,
-          endLine: 7,
-          endColumn: 50,
           data: {
-            name: 'incorrectlyModifiableInline',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableInline {
-          private readonly incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private readonly incorrectlyModifiableInline = 7;
-            };
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj!.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableInline {
-          #incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              #incorrectlyModifiableInline = 7;
-            };
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj!.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 39,
-          data: {
-            name: '#incorrectlyModifiableInline',
-          },
-          messageId: 'preferReadonly',
-        },
-        {
-          line: 7,
-          column: 15,
-          endLine: 7,
-          endColumn: 43,
           data: {
-            name: '#incorrectlyModifiableInline',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableInline {
-          readonly #incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              readonly #incorrectlyModifiableInline = 7;
-            };
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj!.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableDelayed {
-          private incorrectlyModifiableDelayed = 7;
-
-          public constructor() {
-            this.incorrectlyModifiableDelayed = 7;
-          }
-        }
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop.prop = '';
+          }
+        }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 47,
           data: {
-            name: 'incorrectlyModifiableDelayed',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableDelayed {
-          private readonly incorrectlyModifiableDelayed = 7;
-
-          public constructor() {
-            this.incorrectlyModifiableDelayed = 7;
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop.prop = '';
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableDelayed {
-          #incorrectlyModifiableDelayed = 7;
-
-          public constructor() {
-            this.#incorrectlyModifiableDelayed = 7;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj.prop.prop = '';
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 40,
           data: {
-            name: '#incorrectlyModifiableDelayed',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableDelayed {
-          readonly #incorrectlyModifiableDelayed = 7;
-
-          public constructor() {
-            this.#incorrectlyModifiableDelayed = 7;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj.prop.prop = '';
           }
         }
       `,
     },
     {
       code: `
-        class TestChildClassExpressionModifiable {
-          private childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private childClassExpressionModifiable = 7;
-
-              mutate() {
-                this.childClassExpressionModifiable += 1;
-              }
-            };
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop.doesSomething();
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 49,
           data: {
-            name: 'childClassExpressionModifiable',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestChildClassExpressionModifiable {
-          private readonly childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private childClassExpressionModifiable = 7;
-
-              mutate() {
-                this.childClassExpressionModifiable += 1;
-              }
-            };
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop.doesSomething();
           }
         }
       `,
     },
     {
       code: `
-        class TestChildClassExpressionModifiable {
-          #childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              #childClassExpressionModifiable = 7;
-
-              mutate() {
-                this.#childClassExpressionModifiable += 1;
-              }
-            };
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj.prop.doesSomething();
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 42,
           data: {
-            name: '#childClassExpressionModifiable',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestChildClassExpressionModifiable {
-          readonly #childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              #childClassExpressionModifiable = 7;
-
-              mutate() {
-                this.#childClassExpressionModifiable += 1;
-              }
-            };
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj.prop.doesSomething();
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePostMinus {
-          private incorrectlyModifiablePostMinus = 7;
-
-          public mutate() {
-            this.incorrectlyModifiablePostMinus - 1;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 49,
-
           data: {
-            name: 'incorrectlyModifiablePostMinus',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePostMinus {
-          private readonly incorrectlyModifiablePostMinus = 7;
-
-          public mutate() {
-            this.incorrectlyModifiablePostMinus - 1;
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePostMinus {
-          #incorrectlyModifiablePostMinus = 7;
-
-          public mutate() {
-            this.#incorrectlyModifiablePostMinus - 1;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 42,
           data: {
-            name: '#incorrectlyModifiablePostMinus',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePostMinus {
-          readonly #incorrectlyModifiablePostMinus = 7;
-
-          public mutate() {
-            this.#incorrectlyModifiablePostMinus - 1;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePostPlus {
-          private incorrectlyModifiablePostPlus = 7;
-
-          public mutate() {
-            this.incorrectlyModifiablePostPlus + 1;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 48,
-
           data: {
-            name: 'incorrectlyModifiablePostPlus',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePostPlus {
-          private readonly incorrectlyModifiablePostPlus = 7;
-
-          public mutate() {
-            this.incorrectlyModifiablePostPlus + 1;
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePostPlus {
-          #incorrectlyModifiablePostPlus = 7;
-
-          public mutate() {
-            this.#incorrectlyModifiablePostPlus + 1;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 41,
-
           data: {
-            name: '#incorrectlyModifiablePostPlus',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePostPlus {
-          readonly #incorrectlyModifiablePostPlus = 7;
-
-          public mutate() {
-            this.#incorrectlyModifiablePostPlus + 1;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePreMinus {
-          private incorrectlyModifiablePreMinus = 7;
-
-          public mutate() {
-            -this.incorrectlyModifiablePreMinus;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 48,
           data: {
-            name: 'incorrectlyModifiablePreMinus',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePreMinus {
-          private readonly incorrectlyModifiablePreMinus = 7;
-
-          public mutate() {
-            -this.incorrectlyModifiablePreMinus;
-          }
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop?.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePreMinus {
-          #incorrectlyModifiablePreMinus = 7;
-
-          public mutate() {
-            -this.#incorrectlyModifiablePreMinus;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 41,
-
           data: {
-            name: '#incorrectlyModifiablePreMinus',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePreMinus {
-          readonly #incorrectlyModifiablePreMinus = 7;
-
-          public mutate() {
-            -this.#incorrectlyModifiablePreMinus;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePrePlus {
-          private incorrectlyModifiablePrePlus = 7;
-
-          public mutate() {
-            +this.incorrectlyModifiablePrePlus;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj!.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 47,
-
           data: {
-            name: 'incorrectlyModifiablePrePlus',
+            name: 'testObj',
           },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePrePlus {
-          private readonly incorrectlyModifiablePrePlus = 7;
-
-          public mutate() {
-            +this.incorrectlyModifiablePrePlus;
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj!.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiablePrePlus {
-          #incorrectlyModifiablePrePlus = 7;
-
-          public mutate() {
-            +this.#incorrectlyModifiablePrePlus;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj!.prop?.prop;
           }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 40,
-
           data: {
-            name: '#incorrectlyModifiablePrePlus',
+            name: '#testObj',
           },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiablePrePlus {
-          readonly #incorrectlyModifiablePrePlus = 7;
-
-          public mutate() {
-            +this.#incorrectlyModifiablePrePlus;
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj!.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestOverlappingClassVariable {
-          private overlappingClassVariable = 7;
+        class Test {
+          private prop: number = 3;
 
-          public workWithSimilarClass(other: SimilarClass) {
-            other.overlappingClassVariable = 7;
+          test() {
+            const that = {} as this & { _foo: 'bar' };
+            that._foo = 1;
           }
         }
-
-        class SimilarClass {
-          public overlappingClassVariable = 7;
-        }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 43,
-
           data: {
-            name: 'overlappingClassVariable',
+            name: 'prop',
           },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestOverlappingClassVariable {
-          private readonly overlappingClassVariable = 7;
+        class Test {
+          private readonly prop: number = 3;
 
-          public workWithSimilarClass(other: SimilarClass) {
-            other.overlappingClassVariable = 7;
+          test() {
+            const that = {} as this & { _foo: 'bar' };
+            that._foo = 1;
           }
         }
-
-        class SimilarClass {
-          public overlappingClassVariable = 7;
-        }
       `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(private incorrectlyModifiableParameter = 7) {}
+        class Test {
+          private prop: number = 3;
+
+          test() {
+            const that = {} as this | (this & { _foo: 'bar' });
+            that.prop;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
-          column: 30,
-          endLine: 3,
-          endColumn: 68,
+          column: 11,
           data: {
-            name: 'incorrectlyModifiableParameter',
+            name: 'prop',
           },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(private readonly incorrectlyModifiableParameter = 7) {}
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(
-            public ignore: boolean,
-            private incorrectlyModifiableParameter = 7,
-          ) {}
-        }
-      `,
-      errors: [
-        {
-          line: 5,
-          column: 13,
-          endLine: 5,
-          endColumn: 51,
+        class Test {
+          private readonly prop: number = 3;
 
-          data: {
-            name: 'incorrectlyModifiableParameter',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(
-            public ignore: boolean,
-            private readonly incorrectlyModifiableParameter = 7,
-          ) {}
+          test() {
+            const that = {} as this | (this & { _foo: 'bar' });
+            that.prop;
+          }
         }
       `,
     },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          private incorrectlyInlineLambda = () => 7;
+        class Test {
+          private prop: number;
+
+          constructor() {
+            const that = {} as this & { _foo: 'bar' };
+            that.prop = 1;
+          }
         }
       `,
       errors: [
         {
-          line: 3,
           column: 11,
-          endLine: 3,
-          endColumn: 42,
           data: {
-            name: 'incorrectlyInlineLambda',
+            name: 'prop',
           },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      options: [
-        {
-          onlyInlineLambdas: true,
-        },
-      ],
       output: `
-        class TestCorrectlyNonInlineLambdas {
-          private readonly incorrectlyInlineLambda = () => 7;
+        class Test {
+          private readonly prop: number;
+
+          constructor() {
+            const that = {} as this & { _foo: 'bar' };
+            that.prop = 1;
+          }
         }
       `,
     },
-    {
-      code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    private _name: string;
-  };
-}
-      `,
-      output: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    private readonly _name: string;
-  };
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          column: 5,
-          endLine: 4,
-          endColumn: 18,
-          data: {
-            name: '_name',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    #name: string;
-  };
-}
-      `,
-      output: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    readonly #name: string;
-  };
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          column: 5,
-          endLine: 4,
-          endColumn: 10,
-          data: {
-            name: '#name',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {
-            prop: '',
-          };
+  ],
+  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 TestReadonlyStatic {
+        static readonly #correctlyReadonlyStatic = 7;
+      }
+    `,
+    `
+      class TestModifiableStatic {
+        private static correctlyModifiableStatic = 7;
 
-          public test(): void {
-            this.testObj.prop = '';
-          }
+        public constructor() {
+          TestModifiableStatic.correctlyModifiableStatic += 1;
         }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {
-            prop: '',
-          };
+      }
+    `,
+    `
+      class TestModifiableStatic {
+        static #correctlyModifiableStatic = 7;
 
-          public test(): void {
-            this.testObj.prop = '';
-          }
+        public constructor() {
+          TestModifiableStatic.#correctlyModifiableStatic += 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
+      }
+    `,
+    `
+      class TestModifiableByParameterProperty {
+        private static readonly correctlyModifiableByParameterProperty = 7;
 
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {
-            prop: '',
-          };
+        public constructor(
+          public correctlyModifiablePublicParameter: number = (() => {
+            return (TestModifiableStatic.correctlyModifiableByParameterProperty += 1);
+          })(),
+        ) {}
+      }
+    `,
+    `
+      class TestModifiableByParameterProperty {
+        static readonly #correctlyModifiableByParameterProperty = 7;
 
-          public test(): void {
-            this.#testObj.prop = '';
-          }
-        }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {
-            prop: '',
-          };
+        public constructor(
+          public correctlyModifiablePublicParameter: number = (() => {
+            return (TestModifiableStatic.#correctlyModifiableByParameterProperty += 1);
+          })(),
+        ) {}
+      }
+    `,
+    `
+      class TestReadonlyInline {
+        private readonly correctlyReadonlyInline = 7;
+      }
+    `,
+    `
+      class TestReadonlyInline {
+        readonly #correctlyReadonlyInline = 7;
+      }
+    `,
+    `
+      class TestReadonlyDelayed {
+        private readonly correctlyReadonlyDelayed = 7;
 
-          public test(): void {
-            this.#testObj.prop = '';
-          }
+        public constructor() {
+          this.correctlyReadonlyDelayed += 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class TestObject {
-          public prop: number;
+      }
+    `,
+    `
+      class TestReadonlyDelayed {
+        readonly #correctlyReadonlyDelayed = 7;
+
+        public constructor() {
+          this.#correctlyReadonlyDelayed += 1;
         }
+      }
+    `,
+    `
+      class TestModifiableInline {
+        private correctlyModifiableInline = 7;
 
-        class Test {
-          private testObj = new TestObject();
+        public mutate() {
+          this.correctlyModifiableInline += 1;
 
-          public test(): void {
-            this.testObj.prop = 10;
-          }
-        }
-      `,
-      output: `
-        class TestObject {
-          public prop: number;
+          return class {
+            private correctlyModifiableInline = 7;
+
+            mutate() {
+              this.correctlyModifiableInline += 1;
+            }
+          };
         }
+      }
+    `,
+    `
+      class TestModifiableInline {
+        #correctlyModifiableInline = 7;
 
-        class Test {
-          private readonly testObj = new TestObject();
+        public mutate() {
+          this.#correctlyModifiableInline += 1;
 
-          public test(): void {
-            this.testObj.prop = 10;
-          }
-        }
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 11,
-          endLine: 7,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class TestObject {
-          public prop: number;
-        }
+          return class {
+            #correctlyModifiableInline = 7;
 
-        class Test {
-          #testObj = new TestObject();
+            mutate() {
+              this.#correctlyModifiableInline += 1;
+            }
+          };
+        }
+      }
+    `,
+    `
+      class TestModifiableDelayed {
+        private correctlyModifiableDelayed = 7;
 
-          public test(): void {
-            this.#testObj.prop = 10;
-          }
+        public mutate() {
+          this.correctlyModifiableDelayed += 1;
         }
-      `,
-      output: `
-        class TestObject {
-          public prop: number;
+      }
+    `,
+    `
+      class TestModifiableDelayed {
+        #correctlyModifiableDelayed = 7;
+
+        public mutate() {
+          this.#correctlyModifiableDelayed += 1;
         }
+      }
+    `,
+    `
+      class TestModifiableDeleted {
+        private correctlyModifiableDeleted = 7;
 
-        class Test {
-          readonly #testObj = new TestObject();
+        public mutate() {
+          delete this.correctlyModifiableDeleted;
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructor {
+        private correctlyModifiableWithinConstructor = 7;
 
-          public test(): void {
-            this.#testObj.prop = 10;
-          }
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructor += 1;
+          })();
         }
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 11,
-          endLine: 7,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {
-            prop: '',
-          };
-          public test(): void {
-            this.testObj.prop;
-          }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructor {
+        #correctlyModifiableWithinConstructor = 7;
+
+        public constructor() {
+          (() => {
+            this.#correctlyModifiableWithinConstructor += 1;
+          })();
         }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {
-            prop: '',
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorArrowFunction {
+        private correctlyModifiableWithinConstructorArrowFunction = 7;
+
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructorArrowFunction += 1;
+          })();
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorArrowFunction {
+        #correctlyModifiableWithinConstructorArrowFunction = 7;
+
+        public constructor() {
+          (() => {
+            this.#correctlyModifiableWithinConstructorArrowFunction += 1;
+          })();
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInFunctionExpression {
+        private correctlyModifiableWithinConstructorInFunctionExpression = 7;
+
+        public constructor() {
+          const self = this;
+
+          (() => {
+            self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
+          })();
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInFunctionExpression {
+        #correctlyModifiableWithinConstructorInFunctionExpression = 7;
+
+        public constructor() {
+          const self = this;
+
+          (() => {
+            self.#correctlyModifiableWithinConstructorInFunctionExpression += 1;
+          })();
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInGetAccessor {
+        private correctlyModifiableWithinConstructorInGetAccessor = 7;
+
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            get accessor() {
+              return (self.correctlyModifiableWithinConstructorInGetAccessor += 1);
+            },
           };
-          public test(): void {
-            this.testObj.prop;
-          }
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInGetAccessor {
+        #correctlyModifiableWithinConstructorInGetAccessor = 7;
 
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {
-            prop: '',
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            get accessor() {
+              return (self.#correctlyModifiableWithinConstructorInGetAccessor += 1);
+            },
           };
-          public test(): void {
-            this.#testObj.prop;
-          }
         }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {
-            prop: '',
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInMethodDeclaration {
+        private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            methodDeclaration() {
+              self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+            },
           };
-          public test(): void {
-            this.#testObj.prop;
-          }
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop;
-          }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInMethodDeclaration {
+        #correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            methodDeclaration() {
+              self.#correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+            },
+          };
         }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop;
-          }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInSetAccessor {
+        private correctlyModifiableWithinConstructorInSetAccessor = 7;
+
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            set accessor(value: number) {
+              self.correctlyModifiableWithinConstructorInSetAccessor += value;
+            },
+          };
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop;
-          }
-        }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop;
-          }
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInSetAccessor {
+        #correctlyModifiableWithinConstructorInSetAccessor = 7;
 
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj!.prop;
-          }
-        }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj!.prop;
-          }
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            set accessor(value: number) {
+              self.#correctlyModifiableWithinConstructorInSetAccessor += value;
+            },
+          };
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj!.prop;
-          }
+      }
+    `,
+    `
+      class TestModifiablePostDecremented {
+        private correctlyModifiablePostDecremented = 7;
+
+        public mutate() {
+          this.correctlyModifiablePostDecremented -= 1;
         }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj!.prop;
-          }
+      }
+    `,
+    `
+      class TestModifiablePostDecremented {
+        #correctlyModifiablePostDecremented = 7;
+
+        public mutate() {
+          this.#correctlyModifiablePostDecremented -= 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop.prop = '';
-          }
+      }
+    `,
+    `
+      class TestyModifiablePostIncremented {
+        private correctlyModifiablePostIncremented = 7;
+
+        public mutate() {
+          this.correctlyModifiablePostIncremented += 1;
         }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop.prop = '';
-          }
+      }
+    `,
+    `
+      class TestyModifiablePostIncremented {
+        #correctlyModifiablePostIncremented = 7;
+
+        public mutate() {
+          this.#correctlyModifiablePostIncremented += 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
+      }
+    `,
+    `
+      class TestModifiablePreDecremented {
+        private correctlyModifiablePreDecremented = 7;
 
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj.prop.prop = '';
-          }
+        public mutate() {
+          --this.correctlyModifiablePreDecremented;
         }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj.prop.prop = '';
-          }
+      }
+    `,
+    `
+      class TestModifiablePreDecremented {
+        #correctlyModifiablePreDecremented = 7;
+
+        public mutate() {
+          --this.#correctlyModifiablePreDecremented;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop.doesSomething();
-          }
+      }
+    `,
+    `
+      class TestModifiablePreIncremented {
+        private correctlyModifiablePreIncremented = 7;
+
+        public mutate() {
+          ++this.correctlyModifiablePreIncremented;
         }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop.doesSomething();
-          }
+      }
+    `,
+    `
+      class TestModifiablePreIncremented {
+        #correctlyModifiablePreIncremented = 7;
+
+        public mutate() {
+          ++this.#correctlyModifiablePreIncremented;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj.prop.doesSomething();
-          }
+      }
+    `,
+    `
+      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;
         }
-      `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj.prop.doesSomething();
-          }
+      }
+    `,
+    {
+      code: `
+        class TestCorrectlyNonInlineLambdas {
+          private correctlyNonInlineLambda = 7;
         }
       `,
-      errors: [
+      options: [
         {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
+          onlyInlineLambdas: true,
         },
       ],
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop.prop;
-          }
-        }
-      `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop.prop;
-          }
+        class TestCorrectlyNonInlineLambdas {
+          #correctlyNonInlineLambda = 7;
         }
       `,
-      errors: [
+      options: [
         {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
+          onlyInlineLambdas: true,
         },
       ],
     },
+    `
+      class TestComputedParameter {
+        public mutate() {
+          this['computed'] = 1;
+        }
+      }
+    `,
+    `
+      class TestComputedParameter {
+        private ['computed-ignored-by-rule'] = 1;
+      }
+    `,
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop.prop;
-          }
-        }
+class Foo {
+  private value: number = 0;
+
+  bar(newValue: { value: number }) {
+    ({ value: this.value } = newValue);
+    return this.value;
+  }
+}
       `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop.prop;
-          }
-        }
+    },
+    {
+      code: `
+class Foo {
+  #value: number = 0;
+
+  bar(newValue: { value: number }) {
+    ({ value: this.#value } = newValue);
+    return this.#value;
+  }
+}
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop?.prop;
-          }
-        }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    private _name: string;
+
+    public test(value: string) {
+      this._name = value;
+    }
+  };
+}
       `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop?.prop;
-          }
-        }
+    },
+    {
+      code: `
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    #name: string;
+
+    public test(value: string) {
+      this.#name = value;
+    }
+  };
+}
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop?.prop;
-          }
-        }
+class Foo {
+  private value: Record<string, number> = {};
+
+  bar(newValue: Record<string, number>) {
+    ({ ...this.value } = newValue);
+    return this.value;
+  }
+}
       `,
-      output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop?.prop;
-          }
-        }
+    },
+    {
+      code: `
+class Foo {
+  #value: Record<string, number> = {};
+
+  bar(newValue: Record<string, number>) {
+    ({ ...this.#value } = newValue);
+    return this.#value;
+  }
+}
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop?.prop;
-          }
-        }
+class Foo {
+  private value: number[] = [];
+
+  bar(newValue: number[]) {
+    [...this.value] = newValue;
+    return this.value;
+  }
+}
       `,
-      output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop?.prop;
-          }
-        }
+    },
+    {
+      code: `
+class Foo {
+  #value: number[] = [];
+
+  bar(newValue: number[]) {
+    [...this.#value] = newValue;
+    return this.#value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  private value: number = 0;
+
+  bar(newValue: number[]) {
+    [this.value] = newValue;
+    return this.value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  #value: number = 0;
+
+  bar(newValue: number[]) {
+    [this.#value] = newValue;
+    return this.#value;
+  }
+}
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
         class Test {
-          #testObj = {};
+          private testObj = {
+            prop: '',
+          };
+
           public test(): void {
-            this.#testObj.prop?.prop;
+            this.testObj = '';
           }
         }
       `,
-      output: `
+    },
+    {
+      code: `
         class Test {
-          readonly #testObj = {};
+          #testObj = {
+            prop: '',
+          };
+
           public test(): void {
-            this.#testObj.prop?.prop;
+            this.#testObj = '';
           }
         }
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj!.prop?.prop;
-          }
+        class TestObject {
+          public prop: number;
         }
-      `,
-      output: `
+
         class Test {
-          private readonly testObj = {};
+          private testObj = new TestObject();
+
           public test(): void {
-            this.testObj!.prop?.prop;
+            this.testObj = new TestObject();
           }
         }
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 26,
-          data: {
-            name: 'testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj!.prop?.prop;
-          }
+        class TestObject {
+          public prop: number;
         }
-      `,
-      output: `
+
         class Test {
-          readonly #testObj = {};
+          #testObj = new TestObject();
+
           public test(): void {
-            this.#testObj!.prop?.prop;
+            this.#testObj = new TestObject();
           }
         }
       `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 19,
-          data: {
-            name: '#testObj',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
     },
-    {
-      code: `
-        class Test {
-          private prop: number = 3;
+    `
+      class TestIntersection {
+        private prop: number = 3;
 
-          test() {
-            const that = {} as this & { _foo: 'bar' };
-            that._foo = 1;
-          }
+        test() {
+          const that = {} as this & { _foo: 'bar' };
+          that.prop = 1;
         }
-      `,
-      output: `
-        class Test {
-          private readonly prop: number = 3;
+      }
+    `,
+    `
+      class TestUnion {
+        private prop: number = 3;
 
-          test() {
-            const that = {} as this & { _foo: 'bar' };
-            that._foo = 1;
-          }
+        test() {
+          const that = {} as this | (this & { _foo: 'bar' });
+          that.prop = 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 23,
-          data: {
-            name: 'prop',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private prop: number = 3;
+      }
+    `,
+    `
+      class TestStaticIntersection {
+        private static prop: number;
 
-          test() {
-            const that = {} as this | (this & { _foo: 'bar' });
-            that.prop;
-          }
+        test() {
+          const that = {} as typeof TestStaticIntersection & { _foo: 'bar' };
+          that.prop = 1;
         }
-      `,
-      output: `
-        class Test {
-          private readonly prop: number = 3;
+      }
+    `,
+    `
+      class TestStaticUnion {
+        private static prop: number = 1;
 
-          test() {
-            const that = {} as this | (this & { _foo: 'bar' });
-            that.prop;
-          }
+        test() {
+          const that = {} as
+            | typeof TestStaticUnion
+            | (typeof TestStaticUnion & { _foo: 'bar' });
+          that.prop = 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 23,
-          data: {
-            name: 'prop',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          private prop: number;
+      }
+    `,
+    `
+      class TestBothIntersection {
+        private prop1: number = 1;
+        private static prop2: number;
 
-          constructor() {
-            const that = {} as this & { _foo: 'bar' };
-            that.prop = 1;
-          }
+        test() {
+          const that = {} as typeof TestBothIntersection & this;
+          that.prop1 = 1;
+          that.prop2 = 1;
         }
-      `,
-      output: `
-        class Test {
-          private readonly prop: number;
+      }
+    `,
+    `
+      class TestBothIntersection {
+        private prop1: number = 1;
+        private static prop2: number;
 
-          constructor() {
-            const that = {} as this & { _foo: 'bar' };
-            that.prop = 1;
-          }
+        test() {
+          const that = {} as this & typeof TestBothIntersection;
+          that.prop1 = 1;
+          that.prop2 = 1;
         }
-      `,
-      errors: [
-        {
-          line: 3,
-          column: 11,
-          endLine: 3,
-          endColumn: 23,
-          data: {
-            name: 'prop',
-          },
-          messageId: 'preferReadonly',
-        },
-      ],
-    },
+      }
+    `,
+    `
+      class TestStaticPrivateAccessor {
+        private static accessor staticAcc = 1;
+      }
+    `,
+    `
+      class TestStaticPrivateFieldAccessor {
+        static accessor #staticAcc = 1;
+      }
+    `,
+    `
+      class TestPrivateAccessor {
+        private accessor acc = 3;
+      }
+    `,
+    `
+      class TestPrivateFieldAccessor {
+        accessor #acc = 3;
+      }
+    `,
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
index e5a86ccda41f..b6fbfe94456b 100644
--- a/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
@@ -8,117 +8,74 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-reduce-type-parameter', rule, {
-  valid: [
-    `
-      new (class Mine {
-        reduce() {}
-      })().reduce(() => {}, 1 as any);
-    `,
-    `
-      class Mine {
-        reduce() {}
-      }
-
-      new Mine().reduce(() => {}, 1 as any);
-    `,
-    `
-      import { Reducable } from './class';
-
-      new Reducable().reduce(() => {}, 1 as any);
-    `,
-    "[1, 2, 3]['reduce']((sum, num) => sum + num, 0);",
-    '[1, 2, 3][null]((sum, num) => sum + num, 0);',
-    '[1, 2, 3]?.[null]((sum, num) => sum + num, 0);',
-    '[1, 2, 3].reduce((sum, num) => sum + num, 0);',
-    '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
-    '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
-    `
-      declare const tuple: [number, number, number];
-      tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
-    `,
-    `
-      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
-      declare const tuple: [number, number, number] | Reducer;
-      tuple.reduce(a => {
-        return a.concat(1);
-      }, [] as number[]);
-    `,
-    `
-      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
-      declare const arrayOrReducer: number[] & Reducer;
-      arrayOrReducer.reduce(a => {
-        return a.concat(1);
-      }, [] as number[]);
-    `,
-  ],
   invalid: [
     {
       code: `
 declare const arr: string[];
 arr.reduce<string>(acc => acc, arr.shift() as string);
-      `,
-      output: `
-declare const arr: string[];
-arr.reduce<string>(acc => acc, arr.shift());
       `,
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 32,
           line: 3,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: `
+declare const arr: string[];
+arr.reduce<string>(acc => acc, arr.shift());
+      `,
     },
     {
       code: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), [] as number[]);',
-      output: '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 45,
           line: 1,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
     },
     {
       code: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), <number[]>[]);',
-      output: '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 45,
           line: 1,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
     },
     {
       code: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), [] as number[]);',
-      output: '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 46,
           line: 1,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
     },
     {
       code: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), <number[]>[]);',
-      output: '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 46,
           line: 1,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
     },
     {
       code: `
@@ -132,6 +89,13 @@ names.reduce(
   {} as Record<string, boolean>,
 );
       `,
+      errors: [
+        {
+          column: 3,
+          line: 9,
+          messageId: 'preferTypeParameter',
+        },
+      ],
       output: `
 const names = ['a', 'b', 'c'];
 
@@ -143,13 +107,6 @@ names.reduce<Record<string, boolean>>(
   {},
 );
       `,
-      errors: [
-        {
-          messageId: 'preferTypeParameter',
-          column: 3,
-          line: 9,
-        },
-      ],
     },
     {
       code: `
@@ -161,6 +118,13 @@ names.reduce<Record<string, boolean>>(
   <Record<string, boolean>>{},
 );
       `,
+      errors: [
+        {
+          column: 3,
+          line: 7,
+          messageId: 'preferTypeParameter',
+        },
+      ],
       output: `
 ['a', 'b'].reduce<Record<string, boolean>>(
   (accum, name) => ({
@@ -170,13 +134,6 @@ names.reduce<Record<string, boolean>>(
   {},
 );
       `,
-      errors: [
-        {
-          messageId: 'preferTypeParameter',
-          column: 3,
-          line: 7,
-        },
-      ],
     },
     {
       code: `
@@ -188,6 +145,13 @@ names.reduce<Record<string, boolean>>(
   {} as Record<string, boolean>,
 );
       `,
+      errors: [
+        {
+          column: 3,
+          line: 7,
+          messageId: 'preferTypeParameter',
+        },
+      ],
       output: `
 ['a', 'b']['reduce']<Record<string, boolean>>(
   (accum, name) => ({
@@ -197,83 +161,119 @@ names.reduce<Record<string, boolean>>(
   {},
 );
       `,
-      errors: [
-        {
-          messageId: 'preferTypeParameter',
-          column: 3,
-          line: 7,
-        },
-      ],
     },
     {
       code: `
 function f<T, U extends T[]>(a: U) {
   return a.reduce(() => {}, {} as Record<string, boolean>);
-}
-      `,
-      output: `
-function f<T, U extends T[]>(a: U) {
-  return a.reduce<Record<string, boolean>>(() => {}, {});
 }
       `,
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 29,
           line: 3,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: `
+function f<T, U extends T[]>(a: U) {
+  return a.reduce<Record<string, boolean>>(() => {}, {});
+}
+      `,
     },
     {
       code: `
 declare const tuple: [number, number, number];
 tuple.reduce((a, s) => a.concat(s * 2), [] as number[]);
-      `,
-      output: `
-declare const tuple: [number, number, number];
-tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
       `,
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 41,
           line: 3,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: `
+declare const tuple: [number, number, number];
+tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
+      `,
     },
     {
       code: `
 declare const tupleOrArray: [number, number, number] | number[];
 tupleOrArray.reduce((a, s) => a.concat(s * 2), [] as number[]);
-      `,
-      output: `
-declare const tupleOrArray: [number, number, number] | number[];
-tupleOrArray.reduce<number[]>((a, s) => a.concat(s * 2), []);
       `,
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 48,
           line: 3,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: `
+declare const tupleOrArray: [number, number, number] | number[];
+tupleOrArray.reduce<number[]>((a, s) => a.concat(s * 2), []);
+      `,
     },
     {
       code: `
 declare const tuple: [number, number, number] & number[];
 tuple.reduce((a, s) => a.concat(s * 2), [] as number[]);
-      `,
-      output: `
-declare const tuple: [number, number, number] & number[];
-tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
       `,
       errors: [
         {
-          messageId: 'preferTypeParameter',
           column: 41,
           line: 3,
+          messageId: 'preferTypeParameter',
         },
       ],
+      output: `
+declare const tuple: [number, number, number] & number[];
+tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
+      `,
     },
   ],
+  valid: [
+    `
+      new (class Mine {
+        reduce() {}
+      })().reduce(() => {}, 1 as any);
+    `,
+    `
+      class Mine {
+        reduce() {}
+      }
+
+      new Mine().reduce(() => {}, 1 as any);
+    `,
+    `
+      import { Reducable } from './class';
+
+      new Reducable().reduce(() => {}, 1 as any);
+    `,
+    "[1, 2, 3]['reduce']((sum, num) => sum + num, 0);",
+    '[1, 2, 3][null]((sum, num) => sum + num, 0);',
+    '[1, 2, 3]?.[null]((sum, num) => sum + num, 0);',
+    '[1, 2, 3].reduce((sum, num) => sum + num, 0);',
+    '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
+    '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
+    `
+      declare const tuple: [number, number, number];
+      tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
+    `,
+    `
+      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
+      declare const tuple: [number, number, number] | Reducer;
+      tuple.reduce(a => {
+        return a.concat(1);
+      }, [] as number[]);
+    `,
+    `
+      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
+      declare const arrayOrReducer: number[] & Reducer;
+      arrayOrReducer.reduce(a => {
+        return a.concat(1);
+      }, [] as number[]);
+    `,
+  ],
 });
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 0cb2e346ee71..012364ca9f02 100644
--- a/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
@@ -8,112 +8,21 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-regexp-exec', rule, {
-  valid: [
-    "'something'.match();",
-    "'something'.match(/thing/g);",
-    `
-const text = 'something';
-const search = /thing/g;
-text.match(search);
-    `,
-    `
-const match = (s: RegExp) => 'something';
-match(/thing/);
-    `,
-    `
-const a = { match: (s: RegExp) => 'something' };
-a.match(/thing/);
-    `,
-    `
-function f(s: string | string[]) {
-  s.match(/e/);
-}
-    `,
-    "(Math.random() > 0.5 ? 'abc' : 123).match(2);",
-    "'212'.match(2);",
-    "'212'.match(+2);",
-    "'oNaNo'.match(NaN);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(Infinity);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(+Infinity);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(-Infinity);",
-    "'void and null'.match(null);",
-    `
-const matchers = ['package-lock.json', /regexp/];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    `
-const matchers = [/regexp/, 'package-lock.json'];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    `
-const matchers = [{ match: (s: RegExp) => false }];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-function test(pattern: string) {
-  'hello hello'.match(RegExp(pattern, 'g'))?.reduce(() => []);
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-function test(pattern: string) {
-  'hello hello'.match(new RegExp(pattern, 'gi'))?.reduce(() => []);
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-const matchCount = (str: string, re: RegExp) => {
-  return (str.match(re) || []).length;
-};
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6928
-    `
-function test(str: string) {
-  str.match('[a-z');
-}
-    `,
-    {
-      code: `
-const text = 'something';
-declare const search: RegExp;
-text.match(search);
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8614
-    {
-      code: `
-const text = 'something';
-declare const obj: { search: RegExp };
-text.match(obj.search);
-      `,
-    },
-    {
-      code: `
-const text = 'something';
-declare function returnsRegexp(): RegExp;
-text.match(returnsRegexp());
-      `,
-    },
-  ],
   invalid: [
     {
       code: "'something'.match(/thing/);",
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: "/thing/.exec('something');",
@@ -122,9 +31,9 @@ text.match(returnsRegexp());
       code: "'something'.match('^[a-z]+thing/?$');",
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 1,
           column: 13,
+          line: 1,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: "/^[a-z]+thing\\/?$/.exec('something');",
@@ -137,9 +46,9 @@ text.match(search);
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 4,
           column: 6,
+          line: 4,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -156,9 +65,9 @@ text.match(search);
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 4,
           column: 6,
+          line: 4,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -175,9 +84,9 @@ function f(s: 'a' | 'b') {
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 3,
           column: 5,
+          line: 3,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -195,9 +104,9 @@ function f(s: SafeString) {
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 4,
           column: 5,
+          line: 4,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -215,9 +124,9 @@ function f<T extends 'a' | 'b'>(s: T) {
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 3,
           column: 5,
+          line: 3,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -234,9 +143,9 @@ text.match(search);
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 4,
           column: 6,
+          line: 4,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -253,9 +162,9 @@ function test(pattern: string) {
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -274,14 +183,14 @@ function temp(text: string): void {
       `,
       errors: [
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 3,
           column: 8,
+          line: 3,
+          messageId: 'regExpExecOverStringMatch',
         },
         {
-          messageId: 'regExpExecOverStringMatch',
-          line: 4,
           column: 8,
+          line: 4,
+          messageId: 'regExpExecOverStringMatch',
         },
       ],
       output: `
@@ -292,4 +201,95 @@ function temp(text: string): void {
       `,
     },
   ],
+  valid: [
+    "'something'.match();",
+    "'something'.match(/thing/g);",
+    `
+const text = 'something';
+const search = /thing/g;
+text.match(search);
+    `,
+    `
+const match = (s: RegExp) => 'something';
+match(/thing/);
+    `,
+    `
+const a = { match: (s: RegExp) => 'something' };
+a.match(/thing/);
+    `,
+    `
+function f(s: string | string[]) {
+  s.match(/e/);
+}
+    `,
+    "(Math.random() > 0.5 ? 'abc' : 123).match(2);",
+    "'212'.match(2);",
+    "'212'.match(+2);",
+    "'oNaNo'.match(NaN);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(Infinity);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(+Infinity);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(-Infinity);",
+    "'void and null'.match(null);",
+    `
+const matchers = ['package-lock.json', /regexp/];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    `
+const matchers = [/regexp/, 'package-lock.json'];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    `
+const matchers = [{ match: (s: RegExp) => false }];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+function test(pattern: string) {
+  'hello hello'.match(RegExp(pattern, 'g'))?.reduce(() => []);
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+function test(pattern: string) {
+  'hello hello'.match(new RegExp(pattern, 'gi'))?.reduce(() => []);
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+const matchCount = (str: string, re: RegExp) => {
+  return (str.match(re) || []).length;
+};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6928
+    `
+function test(str: string) {
+  str.match('[a-z');
+}
+    `,
+    {
+      code: `
+const text = 'something';
+declare const search: RegExp;
+text.match(search);
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8614
+    {
+      code: `
+const text = 'something';
+declare const obj: { search: RegExp };
+text.match(obj.search);
+      `,
+    },
+    {
+      code: `
+const text = 'something';
+declare function returnsRegexp(): RegExp;
+text.match(returnsRegexp());
+      `,
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts b/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
index 2a89eddb4255..8f7fb17bfc67 100644
--- a/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
@@ -8,80 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-return-this-type', rule, {
-  valid: [
-    `
-class Foo {
-  f1() {}
-  f2(): Foo {
-    return new Foo();
-  }
-  f3() {
-    return this;
-  }
-  f4(): this {
-    return this;
-  }
-  f5(): any {
-    return this;
-  }
-  f6(): unknown {
-    return this;
-  }
-  f7(foo: Foo): Foo {
-    return Math.random() > 0.5 ? foo : this;
-  }
-  f10(this: Foo, that: Foo): Foo;
-  f11(): Foo {
-    return;
-  }
-  f13(this: Foo): Foo {
-    return this;
-  }
-  f14(): { f14: Function } {
-    return this;
-  }
-  f15(): Foo | this {
-    return Math.random() > 0.5 ? new Foo() : this;
-  }
-}
-    `,
-    `
-class Foo {
-  f1 = () => {};
-  f2 = (): Foo => {
-    return new Foo();
-  };
-  f3 = () => this;
-  f4 = (): this => {
-    return this;
-  };
-  f5 = (): Foo => new Foo();
-  f6 = '';
-}
-    `,
-    `
-const Foo = class {
-  bar() {
-    return this;
-  }
-};
-    `,
-    `
-class Base {}
-class Derived extends Base {
-  f(): Base {
-    return this;
-  }
-}
-    `,
-  ],
   invalid: [
     {
       code: `
@@ -93,9 +26,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 8,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -117,9 +50,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 8,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -141,9 +74,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -165,9 +98,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -187,9 +120,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 11,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -211,9 +144,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 9,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -239,9 +172,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 10,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -269,9 +202,9 @@ class Foo {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 20,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -299,10 +232,10 @@ class Animal<T> {
       `,
       errors: [
         {
-          messageId: 'useThisType',
-          line: 3,
           column: 10,
           endColumn: 19,
+          line: 3,
+          messageId: 'useThisType',
         },
       ],
       output: `
@@ -315,4 +248,71 @@ class Animal<T> {
       `,
     },
   ],
+  valid: [
+    `
+class Foo {
+  f1() {}
+  f2(): Foo {
+    return new Foo();
+  }
+  f3() {
+    return this;
+  }
+  f4(): this {
+    return this;
+  }
+  f5(): any {
+    return this;
+  }
+  f6(): unknown {
+    return this;
+  }
+  f7(foo: Foo): Foo {
+    return Math.random() > 0.5 ? foo : this;
+  }
+  f10(this: Foo, that: Foo): Foo;
+  f11(): Foo {
+    return;
+  }
+  f13(this: Foo): Foo {
+    return this;
+  }
+  f14(): { f14: Function } {
+    return this;
+  }
+  f15(): Foo | this {
+    return Math.random() > 0.5 ? new Foo() : this;
+  }
+}
+    `,
+    `
+class Foo {
+  f1 = () => {};
+  f2 = (): Foo => {
+    return new Foo();
+  };
+  f3 = () => this;
+  f4 = (): this => {
+    return this;
+  };
+  f5 = (): Foo => new Foo();
+  f6 = '';
+}
+    `,
+    `
+const Foo = class {
+  bar() {
+    return this;
+  }
+};
+    `,
+    `
+class Base {}
+class Derived extends Base {
+  f(): Base {
+    return this;
+  }
+}
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
index d1e2f3b680fe..3c6eb5115a4e 100644
--- a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
@@ -8,310 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('prefer-string-starts-ends-with', rule, {
-  valid: [
-    `
-      function f(s: string[]) {
-        s[0] === 'a';
-      }
-    `,
-    `
-      function f(s: string[] | null) {
-        s?.[0] === 'a';
-      }
-    `,
-    `
-      function f(s: string[] | undefined) {
-        s?.[0] === 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s[0] + 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s[1] === 'a';
-      }
-    `,
-    `
-      function f(s: string | undefined) {
-        s?.[1] === 'a';
-      }
-    `,
-    `
-      function f(s: string | string[]) {
-        s[0] === 'a';
-      }
-    `,
-    `
-      function f(s: any) {
-        s[0] === 'a';
-      }
-    `,
-    `
-      function f<T>(s: T) {
-        s[0] === 'a';
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s[s.length - 1] === 'a';
-      }
-    `,
-    `
-      function f(s: string[] | undefined) {
-        s?.[s.length - 1] === 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s[s.length - 2] === 'a';
-      }
-    `,
-    `
-      function f(s: string | undefined) {
-        s?.[s.length - 2] === 'a';
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.charAt(0) === 'a';
-      }
-    `,
-    `
-      function f(s: string[] | undefined) {
-        s?.charAt(0) === 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s.charAt(0) + 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s.charAt(1) === 'a';
-      }
-    `,
-    `
-      function f(s: string | undefined) {
-        s?.charAt(1) === 'a';
-      }
-    `,
-    `
-      function f(s: string) {
-        s.charAt() === 'a';
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.charAt(s.length - 1) === 'a';
-      }
-    `,
-    `
-      function f(a: string, b: string, c: string) {
-        (a + b).charAt((a + c).length - 1) === 'a';
-      }
-    `,
-    `
-      function f(a: string, b: string, c: string) {
-        (a + b).charAt(c.length - 1) === 'a';
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.indexOf(needle) === 0;
-      }
-    `,
-    `
-      function f(s: string | string[]) {
-        s.indexOf(needle) === 0;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.indexOf(needle) === s.length - needle.length;
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.lastIndexOf(needle) === s.length - needle.length;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.lastIndexOf(needle) === 0;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/^foo/);
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/foo$/);
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/^foo/) + 1;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/foo$/) + 1;
-      }
-    `,
-    `
-      function f(s: { match(x: any): boolean }) {
-        s.match(/^foo/) !== null;
-      }
-    `,
-    `
-      function f(s: { match(x: any): boolean }) {
-        s.match(/foo$/) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/foo/) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/^foo$/) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/^foo./) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(/^foo|bar/) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(new RegExp('')) !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(pattern) !== null; // cannot check '^'/'$'
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(new RegExp('^/!{[', 'u')) !== null; // has syntax error
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match() !== null;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.match(777) !== null;
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.slice(0, needle.length) === needle;
-      }
-    `,
-    `
-      function f(s: string[]) {
-        s.slice(-needle.length) === needle;
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(1, 4) === 'bar';
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(-4, -1) === 'bar';
-      }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1690
-    `
-      function f(s: string) {
-        s.slice(1) === 'bar';
-      }
-    `,
-    `
-      function f(s: string | null) {
-        s?.slice(1) === 'bar';
-      }
-    `,
-    `
-      function f(s: string) {
-        pattern.test(s);
-      }
-    `,
-    `
-      function f(s: string) {
-        /^bar/.test();
-      }
-    `,
-    `
-      function f(x: { test(): void }, s: string) {
-        x.test(s);
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(0, -4) === 'car';
-      }
-    `,
-    `
-      function f(x: string, s: string) {
-        x.endsWith('foo') && x.slice(0, -4) === 'bar';
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(0, length) === needle; // the 'length' can be different to 'needle.length'
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(-length) === needle; // 'length' can be different
-      }
-    `,
-    `
-      function f(s: string) {
-        s.slice(0, 3) === needle;
-      }
-    `,
-    {
-      code: `
-        declare const s: string;
-        s[0] === 'a';
-      `,
-      options: [{ allowSingleElementEquality: 'always' }],
-    },
-    {
-      code: `
-        declare const s: string;
-        s[s.length - 1] === 'a';
-      `,
-      options: [{ allowSingleElementEquality: 'always' }],
-    },
-  ],
   invalid: [
     // String indexing.
     {
@@ -320,12 +23,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] === 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -333,12 +36,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s?.[0] === 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s?.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -346,12 +49,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] !== 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -359,12 +62,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s?.[0] !== 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s?.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -372,12 +75,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] == 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -385,12 +88,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] != 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -398,12 +101,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] === 'あ';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('あ');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -411,8 +114,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] === '👍'; // the length is 2.
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
     },
     {
       code: `
@@ -420,8 +123,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[0] === t; // the length of t is unknown.
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
     },
     {
       code: `
@@ -429,12 +132,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s[s.length - 1] === 'a';
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: noFormat`
@@ -442,12 +145,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           (s)[0] === ("a")
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           (s).startsWith("a")
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
 
     // String#charAt
@@ -457,12 +160,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) === 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -470,12 +173,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) !== 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -483,12 +186,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) == 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -496,12 +199,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) != 'a';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -509,12 +212,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) === 'あ';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('あ');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -522,8 +225,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) === '👍'; // the length is 2.
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
     },
     {
       code: `
@@ -531,8 +234,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(0) === t; // the length of t is unknown.
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
     },
     {
       code: `
@@ -540,12 +243,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.charAt(s.length - 1) === 'a';
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('a');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: noFormat`
@@ -553,12 +256,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           (s).charAt(0) === "a";
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           (s).startsWith("a");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
 
     // String#indexOf
@@ -568,12 +271,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.indexOf(needle) === 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -581,12 +284,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s?.indexOf(needle) === 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s?.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -594,12 +297,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.indexOf(needle) !== 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -607,12 +310,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.indexOf(needle) == 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -620,12 +323,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.indexOf(needle) != 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
 
     // String#lastIndexOf
@@ -635,12 +338,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf('bar') === s.length - 3;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -648,12 +351,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf('bar') !== s.length - 3;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           !s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -661,12 +364,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf('bar') == s.length - 3;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -674,12 +377,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf('bar') != s.length - 3;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           !s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -687,12 +390,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf('bar') === s.length - 'bar'.length;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -700,12 +403,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.lastIndexOf(needle) === s.length - needle.length;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
 
     // String#match
@@ -715,12 +418,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/^bar/) !== null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -728,12 +431,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s?.match(/^bar/) !== null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s?.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -741,12 +444,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/^bar/) != null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -754,12 +457,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/bar$/) !== null;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -767,12 +470,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/bar$/) != null;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -780,12 +483,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/^bar/) === null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -793,12 +496,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/^bar/) == null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -806,12 +509,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/bar$/) === null;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           !s.endsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -819,12 +522,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(/bar$/) == null;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           !s.endsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -833,13 +536,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(pattern) != null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = /^bar/;
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -848,13 +551,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(pattern) != null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = new RegExp('^bar');
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -863,13 +566,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.match(pattern) != null;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = /^"quoted"/;
         function f(s: string) {
           s.startsWith("\\"quoted\\"");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
 
     // String#slice
@@ -879,12 +582,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, 3) === 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -892,12 +595,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s?.slice(0, 3) === 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s?.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -905,12 +608,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, 3) !== 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -918,12 +621,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, 3) == 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -931,12 +634,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, 3) != 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           !s.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -944,12 +647,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, needle.length) === needle;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -957,8 +660,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(0, needle.length) == needle; // hating implicit type conversion
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
     },
     {
       code: `
@@ -966,12 +669,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(-3) === 'bar';
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -979,12 +682,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(-3) !== 'bar';
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           !s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -992,12 +695,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(-needle.length) === needle;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -1005,12 +708,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.slice(s.length - needle.length) === needle;
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith(needle);
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -1018,12 +721,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.substring(0, 3) === 'bar';
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1031,8 +734,8 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.substring(-3) === 'bar'; // the code is probably mistake.
         }
       `,
-      output: null,
       errors: [{ messageId: 'preferEndsWith' }],
+      output: null,
     },
     {
       code: `
@@ -1040,12 +743,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.substring(s.length - 3, s.length) === 'bar';
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith('bar');
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
 
     // RegExp#test
@@ -1055,12 +758,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           /^bar/.test(s);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1068,12 +771,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           /^bar/?.test(s);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           s?.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1081,12 +784,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           /bar$/.test(s);
         }
       `,
+      errors: [{ messageId: 'preferEndsWith' }],
       output: `
         function f(s: string) {
           s.endsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferEndsWith' }],
     },
     {
       code: `
@@ -1095,13 +798,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           pattern.test(s);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = /^bar/;
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1110,13 +813,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           pattern.test(s);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = new RegExp('^bar');
         function f(s: string) {
           s.startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1125,13 +828,13 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           pattern.test(s);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         const pattern = /^"quoted"/;
         function f(s: string) {
           s.startsWith("\\"quoted\\"");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
     {
       code: `
@@ -1139,12 +842,12 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           /^bar/.test(a + b);
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: string) {
           (a + b).startsWith("bar");
         }
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
     },
 
     // Test for variation of string types.
@@ -1154,40 +857,337 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
           s.indexOf(needle) === 0;
         }
       `,
+      errors: [{ messageId: 'preferStartsWith' }],
       output: `
         function f(s: 'a' | 'b') {
           s.startsWith(needle);
         }
       `,
+    },
+    {
+      code: `
+        function f<T extends 'a' | 'b'>(s: T) {
+          s.indexOf(needle) === 0;
+        }
+      `,
       errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f<T extends 'a' | 'b'>(s: T) {
+          s.startsWith(needle);
+        }
+      `,
     },
     {
       code: `
-        function f<T extends 'a' | 'b'>(s: T) {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      output: `
-        function f<T extends 'a' | 'b'>(s: T) {
-          s.startsWith(needle);
-        }
+        type SafeString = string & { __HTML_ESCAPED__: void };
+        function f(s: SafeString) {
+          s.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        type SafeString = string & { __HTML_ESCAPED__: void };
+        function f(s: SafeString) {
+          s.startsWith(needle);
+        }
+      `,
+    },
+  ],
+  valid: [
+    `
+      function f(s: string[]) {
+        s[0] === 'a';
+      }
+    `,
+    `
+      function f(s: string[] | null) {
+        s?.[0] === 'a';
+      }
+    `,
+    `
+      function f(s: string[] | undefined) {
+        s?.[0] === 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s[0] + 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s[1] === 'a';
+      }
+    `,
+    `
+      function f(s: string | undefined) {
+        s?.[1] === 'a';
+      }
+    `,
+    `
+      function f(s: string | string[]) {
+        s[0] === 'a';
+      }
+    `,
+    `
+      function f(s: any) {
+        s[0] === 'a';
+      }
+    `,
+    `
+      function f<T>(s: T) {
+        s[0] === 'a';
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s[s.length - 1] === 'a';
+      }
+    `,
+    `
+      function f(s: string[] | undefined) {
+        s?.[s.length - 1] === 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s[s.length - 2] === 'a';
+      }
+    `,
+    `
+      function f(s: string | undefined) {
+        s?.[s.length - 2] === 'a';
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.charAt(0) === 'a';
+      }
+    `,
+    `
+      function f(s: string[] | undefined) {
+        s?.charAt(0) === 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt(0) + 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt(1) === 'a';
+      }
+    `,
+    `
+      function f(s: string | undefined) {
+        s?.charAt(1) === 'a';
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt() === 'a';
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.charAt(s.length - 1) === 'a';
+      }
+    `,
+    `
+      function f(a: string, b: string, c: string) {
+        (a + b).charAt((a + c).length - 1) === 'a';
+      }
+    `,
+    `
+      function f(a: string, b: string, c: string) {
+        (a + b).charAt(c.length - 1) === 'a';
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.indexOf(needle) === 0;
+      }
+    `,
+    `
+      function f(s: string | string[]) {
+        s.indexOf(needle) === 0;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.indexOf(needle) === s.length - needle.length;
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.lastIndexOf(needle) === s.length - needle.length;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.lastIndexOf(needle) === 0;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo/);
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo$/);
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo/) + 1;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo$/) + 1;
+      }
+    `,
+    `
+      function f(s: { match(x: any): boolean }) {
+        s.match(/^foo/) !== null;
+      }
+    `,
+    `
+      function f(s: { match(x: any): boolean }) {
+        s.match(/foo$/) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo/) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo$/) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo./) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo|bar/) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(new RegExp('')) !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(pattern) !== null; // cannot check '^'/'$'
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(new RegExp('^/!{[', 'u')) !== null; // has syntax error
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match() !== null;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(777) !== null;
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.slice(0, needle.length) === needle;
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.slice(-needle.length) === needle;
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(1, 4) === 'bar';
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(-4, -1) === 'bar';
+      }
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1690
+    `
+      function f(s: string) {
+        s.slice(1) === 'bar';
+      }
+    `,
+    `
+      function f(s: string | null) {
+        s?.slice(1) === 'bar';
+      }
+    `,
+    `
+      function f(s: string) {
+        pattern.test(s);
+      }
+    `,
+    `
+      function f(s: string) {
+        /^bar/.test();
+      }
+    `,
+    `
+      function f(x: { test(): void }, s: string) {
+        x.test(s);
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(0, -4) === 'car';
+      }
+    `,
+    `
+      function f(x: string, s: string) {
+        x.endsWith('foo') && x.slice(0, -4) === 'bar';
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(0, length) === needle; // the 'length' can be different to 'needle.length'
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(-length) === needle; // 'length' can be different
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(0, 3) === needle;
+      }
+    `,
+    {
+      code: `
+        declare const s: string;
+        s[0] === 'a';
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
+      options: [{ allowSingleElementEquality: 'always' }],
     },
     {
       code: `
-        type SafeString = string & { __HTML_ESCAPED__: void };
-        function f(s: SafeString) {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      output: `
-        type SafeString = string & { __HTML_ESCAPED__: void };
-        function f(s: SafeString) {
-          s.startsWith(needle);
-        }
+        declare const s: string;
+        s[s.length - 1] === 'a';
       `,
-      errors: [{ messageId: 'preferStartsWith' }],
+      options: [{ allowSingleElementEquality: 'always' }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
index 4abbd9733e84..1c83d14b4ce8 100644
--- a/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
@@ -5,68 +5,40 @@ import rule from '../../src/rules/prefer-ts-expect-error';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-ts-expect-error', rule, {
-  valid: [
-    '// @ts-nocheck',
-    '// @ts-check',
-    '// just a comment containing @ts-ignore somewhere',
-    `
-{
-  /*
-        just a comment containing @ts-ignore somewhere in a block
-      */
-}
-    `,
-    '// @ts-expect-error',
-    `
-if (false) {
-  // @ts-expect-error: Unreachable code error
-  console.log('hello');
-}
-    `,
-    `
-/**
- * Explaining comment
- *
- * @ts-expect-error
- *
- * Not last line
- * */
-    `,
-  ],
   invalid: [
     {
       code: '// @ts-ignore',
-      output: '// @ts-expect-error',
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+      output: '// @ts-expect-error',
     },
     {
       code: '// @ts-ignore: Suppress next line',
-      output: '// @ts-expect-error: Suppress next line',
-
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+
+      output: '// @ts-expect-error: Suppress next line',
     },
     {
       code: '///@ts-ignore: Suppress next line',
-      output: '///@ts-expect-error: Suppress next line',
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+      output: '///@ts-expect-error: Suppress next line',
     },
     {
       code: `
@@ -75,30 +47,30 @@ if (false) {
   console.log('hello');
 }
       `,
+      errors: [
+        {
+          column: 3,
+          line: 3,
+          messageId: 'preferExpectErrorComment',
+        },
+      ],
       output: `
 if (false) {
   // @ts-expect-error: Unreachable code error
   console.log('hello');
 }
       `,
-      errors: [
-        {
-          messageId: 'preferExpectErrorComment',
-          line: 3,
-          column: 3,
-        },
-      ],
     },
     {
       code: '/* @ts-ignore */',
-      output: '/* @ts-expect-error */',
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+      output: '/* @ts-expect-error */',
     },
     {
       code: `
@@ -107,47 +79,75 @@ if (false) {
  *
  * @ts-ignore */
       `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'preferExpectErrorComment',
+        },
+      ],
       output: `
 /**
  * Explaining comment
  *
  * @ts-expect-error */
       `,
-      errors: [
-        {
-          messageId: 'preferExpectErrorComment',
-          line: 2,
-          column: 1,
-        },
-      ],
     },
     {
       code: '/* @ts-ignore in a single block */',
-      output: '/* @ts-expect-error in a single block */',
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 1,
           column: 1,
+          line: 1,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+      output: '/* @ts-expect-error in a single block */',
     },
     {
       code: `
 /*
 // @ts-ignore in a block with single line comments */
-      `,
-      output: `
-/*
-// @ts-expect-error in a block with single line comments */
       `,
       errors: [
         {
-          messageId: 'preferExpectErrorComment',
-          line: 2,
           column: 1,
+          line: 2,
+          messageId: 'preferExpectErrorComment',
         },
       ],
+      output: `
+/*
+// @ts-expect-error in a block with single line comments */
+      `,
     },
   ],
+  valid: [
+    '// @ts-nocheck',
+    '// @ts-check',
+    '// just a comment containing @ts-ignore somewhere',
+    `
+{
+  /*
+        just a comment containing @ts-ignore somewhere in a block
+      */
+}
+    `,
+    '// @ts-expect-error',
+    `
+if (false) {
+  // @ts-expect-error: Unreachable code error
+  console.log('hello');
+}
+    `,
+    `
+/**
+ * Explaining comment
+ *
+ * @ts-expect-error
+ *
+ * Not last line
+ * */
+    `,
+  ],
 });
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 b89b60878949..f6f3cb307e07 100644
--- a/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
+++ b/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
@@ -9,216 +9,49 @@ const messageId = 'missingAsync';
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('promise-function-async', rule, {
-  valid: [
-    `
-const nonAsyncNonPromiseArrowFunction = (n: number) => n;
-    `,
-    `
-function nonAsyncNonPromiseFunctionDeclaration(n: number) {
-  return n;
-}
-    `,
-    `
-const asyncPromiseFunctionExpressionA = async function (p: Promise<void>) {
-  return p;
-};
-    `,
-    `
-const asyncPromiseFunctionExpressionB = async function () {
-  return new Promise<void>();
-};
-    `,
-    `
-class Test {
-  public nonAsyncNonPromiseArrowFunction = (n: number) => n;
-  public nonAsyncNonPromiseMethod() {
-    return 0;
-  }
-
-  public async asyncPromiseMethodA(p: Promise<void>) {
-    return p;
-  }
-
-  public async asyncPromiseMethodB() {
-    return new Promise<void>();
-  }
-}
-    `,
-    `
-class InvalidAsyncModifiers {
-  public constructor() {
-    return new Promise<void>();
-  }
-  public get asyncGetter() {
-    return new Promise<void>();
-  }
-  public set asyncGetter(p: Promise<void>) {
-    return p;
-  }
-  public get asyncGetterFunc() {
-    return async () => new Promise<void>();
-  }
-  public set asyncGetterFunc(p: () => Promise<void>) {
-    return p;
-  }
-}
-    `,
-    `
-const invalidAsyncModifiers = {
-  get asyncGetter() {
-    return new Promise<void>();
-  },
-  set asyncGetter(p: Promise<void>) {
-    return p;
-  },
-  get asyncGetterFunc() {
-    return async () => new Promise<void>();
-  },
-  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() {}
-      }
-    `,
-    `
-class Foo {
-  async catch<T>(arg: Promise<T>) {
-    return arg;
-  }
-}
-    `,
+  invalid: [
     {
       code: `
 function returnsAny(): any {
   return 0;
 }
       `,
-      options: [
+      errors: [
         {
-          allowAny: true,
+          messageId,
         },
       ],
-    },
-    {
-      code: `
-function returnsUnknown(): unknown {
-  return 0;
-}
-      `,
       options: [
         {
-          allowAny: true,
+          allowAny: false,
         },
       ],
+      output: null,
     },
     {
       code: `
-interface ReadableStream {}
-interface Options {
-  stream: ReadableStream;
-}
-
-type Return = ReadableStream | Promise<void>;
-const foo = (options: Options): Return => {
-  return options.stream ? asStream(options) : asPromise(options);
-};
-      `,
-    },
-    {
-      code: `
-function foo(): Promise<string> | boolean {
-  return Math.random() > 0.5 ? Promise.resolve('value') : false;
-}
-      `,
-    },
-    {
-      code: `
-abstract class Test {
-  abstract test1(): Promise<number>;
-
-  // abstract method with body is always an error but it still parses into valid AST
-  abstract test2(): Promise<number> {
-    return Promise.resolve(1);
-  }
-}
-      `,
-    },
-    `
-function promiseInUnionWithExplicitReturnType(
-  p: boolean,
-): Promise<number> | number {
-  return p ? Promise.resolve(5) : 5;
-}
-    `,
-    `
-function explicitReturnWithPromiseInUnion(): Promise<number> | number {
-  return 5;
-}
-    `,
-    `
-async function asyncFunctionReturningUnion(p: boolean) {
-  return p ? Promise.resolve(5) : 5;
-}
-    `,
-  ],
-  invalid: [
-    {
-      code: `
-function returnsAny(): any {
+function returnsUnknown(): unknown {
   return 0;
 }
       `,
-      output: null,
-      options: [
-        {
-          allowAny: false,
-        },
-      ],
       errors: [
         {
           messageId,
         },
       ],
-    },
-    {
-      code: `
-function returnsUnknown(): unknown {
-  return 0;
-}
-      `,
-      output: null,
       options: [
         {
           allowAny: false,
         },
       ],
-      errors: [
-        {
-          messageId,
-        },
-      ],
+      output: null,
     },
     {
       code: `
@@ -388,11 +221,6 @@ class Test {
   }
 }
       `,
-      options: [
-        {
-          checkArrowFunctions: false,
-        },
-      ],
       errors: [
         {
           line: 2,
@@ -407,6 +235,11 @@ class Test {
           messageId,
         },
       ],
+      options: [
+        {
+          checkArrowFunctions: false,
+        },
+      ],
       output: `
 const nonAsyncPromiseFunctionExpression = async function (p: Promise<void>) {
   return p;
@@ -443,11 +276,6 @@ class Test {
   }
 }
       `,
-      options: [
-        {
-          checkFunctionDeclarations: false,
-        },
-      ],
       errors: [
         {
           line: 2,
@@ -462,6 +290,11 @@ class Test {
           messageId,
         },
       ],
+      options: [
+        {
+          checkFunctionDeclarations: false,
+        },
+      ],
       output: `
 const nonAsyncPromiseFunctionExpression = async function (p: Promise<void>) {
   return p;
@@ -498,11 +331,6 @@ class Test {
   }
 }
       `,
-      options: [
-        {
-          checkFunctionExpressions: false,
-        },
-      ],
       errors: [
         {
           line: 6,
@@ -517,6 +345,11 @@ class Test {
           messageId,
         },
       ],
+      options: [
+        {
+          checkFunctionExpressions: false,
+        },
+      ],
       output: `
 const nonAsyncPromiseFunctionExpression = function (p: Promise<void>) {
   return p;
@@ -553,11 +386,6 @@ class Test {
   }
 }
       `,
-      options: [
-        {
-          checkMethodDeclarations: false,
-        },
-      ],
       errors: [
         {
           line: 2,
@@ -572,6 +400,11 @@ class Test {
           messageId,
         },
       ],
+      options: [
+        {
+          checkMethodDeclarations: false,
+        },
+      ],
       output: `
 const nonAsyncPromiseFunctionExpression = async function (p: Promise<void>) {
   return p;
@@ -596,17 +429,17 @@ class PromiseType {}
 
 const returnAllowedType = () => new PromiseType();
       `,
-      options: [
-        {
-          allowedPromiseNames: ['PromiseType'],
-        },
-      ],
       errors: [
         {
           line: 4,
           messageId,
         },
       ],
+      options: [
+        {
+          allowedPromiseNames: ['PromiseType'],
+        },
+      ],
       output: `
 class PromiseType {}
 
@@ -622,17 +455,17 @@ function foo(): Promise<string> | SPromise<boolean> {
     : Promise.resolve(false);
 }
       `,
-      options: [
-        {
-          allowedPromiseNames: ['SPromise'],
-        },
-      ],
       errors: [
         {
           line: 3,
           messageId,
         },
       ],
+      options: [
+        {
+          allowedPromiseNames: ['SPromise'],
+        },
+      ],
       output: `
 interface SPromise<T> extends Promise<T> {}
 async function foo(): Promise<string> | SPromise<boolean> {
@@ -651,7 +484,7 @@ class Test {
   }
 }
       `,
-      errors: [{ line: 4, column: 3, messageId }],
+      errors: [{ column: 3, line: 4, messageId }],
       output: `
 class Test {
   @decorator
@@ -677,9 +510,9 @@ class Test {
 }
       `,
       errors: [
-        { line: 4, column: 3, messageId },
-        { line: 7, column: 3, messageId },
-        { line: 10, column: 3, messageId },
+        { column: 3, line: 4, messageId },
+        { column: 3, line: 7, messageId },
+        { column: 3, line: 10, messageId },
       ],
       output: `
 class Test {
@@ -714,6 +547,23 @@ class Foo {
   }
 }
       `,
+      errors: [
+        {
+          column: 3,
+          line: 3,
+          messageId,
+        },
+        {
+          column: 3,
+          line: 7,
+          messageId,
+        },
+        {
+          column: 3,
+          line: 12,
+          messageId,
+        },
+      ],
       output: `
 class Foo {
   async catch() {
@@ -730,23 +580,6 @@ class Foo {
   }
 }
       `,
-      errors: [
-        {
-          line: 3,
-          column: 3,
-          messageId,
-        },
-        {
-          line: 7,
-          column: 3,
-          messageId,
-        },
-        {
-          line: 12,
-          column: 3,
-          messageId,
-        },
-      ],
     },
     {
       code: `
@@ -756,6 +589,13 @@ const foo = {
   },
 };
       `,
+      errors: [
+        {
+          column: 3,
+          line: 3,
+          messageId,
+        },
+      ],
       output: `
 const foo = {
   async catch() {
@@ -763,13 +603,6 @@ const foo = {
   },
 };
       `,
-      errors: [
-        {
-          line: 3,
-          column: 3,
-          messageId,
-        },
-      ],
     },
     {
       code: `
@@ -789,4 +622,171 @@ async function promiseInUnionWithoutExplicitReturnType(p: boolean) {
       `,
     },
   ],
+  valid: [
+    `
+const nonAsyncNonPromiseArrowFunction = (n: number) => n;
+    `,
+    `
+function nonAsyncNonPromiseFunctionDeclaration(n: number) {
+  return n;
+}
+    `,
+    `
+const asyncPromiseFunctionExpressionA = async function (p: Promise<void>) {
+  return p;
+};
+    `,
+    `
+const asyncPromiseFunctionExpressionB = async function () {
+  return new Promise<void>();
+};
+    `,
+    `
+class Test {
+  public nonAsyncNonPromiseArrowFunction = (n: number) => n;
+  public nonAsyncNonPromiseMethod() {
+    return 0;
+  }
+
+  public async asyncPromiseMethodA(p: Promise<void>) {
+    return p;
+  }
+
+  public async asyncPromiseMethodB() {
+    return new Promise<void>();
+  }
+}
+    `,
+    `
+class InvalidAsyncModifiers {
+  public constructor() {
+    return new Promise<void>();
+  }
+  public get asyncGetter() {
+    return new Promise<void>();
+  }
+  public set asyncGetter(p: Promise<void>) {
+    return p;
+  }
+  public get asyncGetterFunc() {
+    return async () => new Promise<void>();
+  }
+  public set asyncGetterFunc(p: () => Promise<void>) {
+    return p;
+  }
+}
+    `,
+    `
+const invalidAsyncModifiers = {
+  get asyncGetter() {
+    return new Promise<void>();
+  },
+  set asyncGetter(p: Promise<void>) {
+    return p;
+  },
+  get asyncGetterFunc() {
+    return async () => new Promise<void>();
+  },
+  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() {}
+      }
+    `,
+    `
+class Foo {
+  async catch<T>(arg: Promise<T>) {
+    return arg;
+  }
+}
+    `,
+    {
+      code: `
+function returnsAny(): any {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
+    {
+      code: `
+function returnsUnknown(): unknown {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
+    {
+      code: `
+interface ReadableStream {}
+interface Options {
+  stream: ReadableStream;
+}
+
+type Return = ReadableStream | Promise<void>;
+const foo = (options: Options): Return => {
+  return options.stream ? asStream(options) : asPromise(options);
+};
+      `,
+    },
+    {
+      code: `
+function foo(): Promise<string> | boolean {
+  return Math.random() > 0.5 ? Promise.resolve('value') : false;
+}
+      `,
+    },
+    {
+      code: `
+abstract class Test {
+  abstract test1(): Promise<number>;
+
+  // abstract method with body is always an error but it still parses into valid AST
+  abstract test2(): Promise<number> {
+    return Promise.resolve(1);
+  }
+}
+      `,
+    },
+    `
+function promiseInUnionWithExplicitReturnType(
+  p: boolean,
+): Promise<number> | number {
+  return p ? Promise.resolve(5) : 5;
+}
+    `,
+    `
+function explicitReturnWithPromiseInUnion(): Promise<number> | number {
+  return 5;
+}
+    `,
+    `
+async function asyncFunctionReturningUnion(p: boolean) {
+  return p ? Promise.resolve(5) : 5;
+}
+    `,
+  ],
 });
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 3efc6d8e91ab..e144819fa1dc 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
@@ -8,133 +8,13 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('require-array-sort-compare', rule, {
-  valid: [
-    `
-      function f(a: any[]) {
-        a.sort(undefined);
-      }
-    `,
-    `
-      function f(a: any[]) {
-        a.sort((a, b) => a - b);
-      }
-    `,
-    `
-      function f(a: Array<string>) {
-        a.sort(undefined);
-      }
-    `,
-    `
-      function f(a: Array<number>) {
-        a.sort((a, b) => a - b);
-      }
-    `,
-    `
-      function f(a: { sort(): void }) {
-        a.sort();
-      }
-    `,
-    `
-      class A {
-        sort(): void {}
-      }
-      function f(a: A) {
-        a.sort();
-      }
-    `,
-    `
-      interface A {
-        sort(): void;
-      }
-      function f(a: A) {
-        a.sort();
-      }
-    `,
-    `
-      interface A {
-        sort(): void;
-      }
-      function f<T extends A>(a: T) {
-        a.sort();
-      }
-    `,
-    `
-      function f(a: any) {
-        a.sort();
-      }
-    `,
-    `
-      namespace UserDefined {
-        interface Array {
-          sort(): void;
-        }
-        function f(a: Array) {
-          a.sort();
-        }
-      }
-    `,
-    // optional chain
-    `
-      function f(a: any[]) {
-        a?.sort((a, b) => a - b);
-      }
-    `,
-    `
-      namespace UserDefined {
-        interface Array {
-          sort(): void;
-        }
-        function f(a: Array) {
-          a?.sort();
-        }
-      }
-    `,
-    {
-      code: `
-        ['foo', 'bar', 'baz'].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        function getString() {
-          return 'foo';
-        }
-        [getString(), getString()].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        const foo = 'foo';
-        const bar = 'bar';
-        const baz = 'baz';
-        [foo, bar, baz].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        declare const x: string[];
-        x.sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        function f(a: number[]) {
-          a.toSorted((a, b) => a - b);
-        }
-      `,
-    },
-  ],
   invalid: [
     {
       code: `
@@ -271,4 +151,124 @@ ruleTester.run('require-array-sort-compare', rule, {
       errors: [{ messageId: 'requireCompare' }],
     },
   ],
+  valid: [
+    `
+      function f(a: any[]) {
+        a.sort(undefined);
+      }
+    `,
+    `
+      function f(a: any[]) {
+        a.sort((a, b) => a - b);
+      }
+    `,
+    `
+      function f(a: Array<string>) {
+        a.sort(undefined);
+      }
+    `,
+    `
+      function f(a: Array<number>) {
+        a.sort((a, b) => a - b);
+      }
+    `,
+    `
+      function f(a: { sort(): void }) {
+        a.sort();
+      }
+    `,
+    `
+      class A {
+        sort(): void {}
+      }
+      function f(a: A) {
+        a.sort();
+      }
+    `,
+    `
+      interface A {
+        sort(): void;
+      }
+      function f(a: A) {
+        a.sort();
+      }
+    `,
+    `
+      interface A {
+        sort(): void;
+      }
+      function f<T extends A>(a: T) {
+        a.sort();
+      }
+    `,
+    `
+      function f(a: any) {
+        a.sort();
+      }
+    `,
+    `
+      namespace UserDefined {
+        interface Array {
+          sort(): void;
+        }
+        function f(a: Array) {
+          a.sort();
+        }
+      }
+    `,
+    // optional chain
+    `
+      function f(a: any[]) {
+        a?.sort((a, b) => a - b);
+      }
+    `,
+    `
+      namespace UserDefined {
+        interface Array {
+          sort(): void;
+        }
+        function f(a: Array) {
+          a?.sort();
+        }
+      }
+    `,
+    {
+      code: `
+        ['foo', 'bar', 'baz'].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        function getString() {
+          return 'foo';
+        }
+        [getString(), getString()].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        const foo = 'foo';
+        const bar = 'bar';
+        const baz = 'baz';
+        [foo, bar, baz].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        declare const x: string[];
+        x.sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        function f(a: number[]) {
+          a.toSorted((a, b) => a - b);
+        }
+      `,
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/require-await.test.ts b/packages/eslint-plugin/tests/rules/require-await.test.ts
index 79fce65f7176..bc51d73c73d4 100644
--- a/packages/eslint-plugin/tests/rules/require-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-await.test.ts
@@ -8,252 +8,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('require-await', rule, {
-  valid: [
-    // Non-async function declaration
-    `
-function numberOne(): number {
-  return 1;
-}
-    `,
-    // Non-async function expression
-    `
-const numberOne = function (): number {
-  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;
-};
-    `,
-    // Non-async function that returns a promise
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1226
-    `
-function 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;
-}
-    `,
-    // Async function expression with await
-    `
-const numberOne = async function (): Promise<number> {
-  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;
-};
-    `,
-    // Async function declaration with promise return
-    `
-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);
-};
-    `,
-    // 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);
-};
-    `,
-    // 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 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);
-};
-    `,
-    // 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);
-};
-    `,
-    // 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);
-};
-    `,
-    // 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),
-    ),
-  );
-}
-    `,
-    `
-function* test6() {
-  yield* syncGenerator();
-}
-    `,
-    `
-function* syncGenerator() {
-  yield 1;
-}
-    `,
-    `
-async function* asyncGenerator() {
-  await Promise.resolve();
-  yield 1;
-}
-async function* test1() {
-  yield* asyncGenerator();
-}
-    `,
-    `
-async function* asyncGenerator() {
-  await Promise.resolve();
-  yield 1;
-}
-async function* test1() {
-  yield* asyncGenerator();
-  yield* 2;
-}
-    `,
-    `
-async function* test(source: AsyncIterable<any>) {
-  yield* source;
-}
-    `,
-    `
-async function* test(source: Iterable<any> & AsyncIterable<any>) {
-  yield* source;
-}
-    `,
-    `
-async function* test(source: Iterable<any> | AsyncIterable<any>) {
-  yield* source;
-}
-    `,
-    `
-type MyType = {
-  [Symbol.iterator](): Iterator<any>;
-  [Symbol.asyncIterator](): AsyncIterator<any>;
-};
-async function* test(source: MyType) {
-  yield* source;
-}
-    `,
-    `
-type MyType = {
-  [Symbol.asyncIterator]: () => AsyncIterator<any>;
-};
-async function* test(source: MyType) {
-  yield* source;
-}
-    `,
-    `
-type MyFunctionType = () => AsyncIterator<any>;
-type MyType = {
-  [Symbol.asyncIterator]: MyFunctionType;
-};
-async function* test(source: MyType) {
-  yield* source;
-}
-    `,
-    `
-async function* foo(): Promise<string> {
-  return new Promise(res => res(\`hello\`));
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/5458
-    `
-      async function* f() {
-        let x!: Omit<
-          {
-            [Symbol.asyncIterator](): AsyncIterator<any>;
-          },
-          'z'
-        >;
-        yield* x;
-      }
-    `,
-    `
-      const fn = async () => {
-        await using foo = new Bar();
-      };
-    `,
-    `
-      async function* test1() {
-        yield Promise.resolve(1);
-      }
-    `,
-    `
-      function asyncFunction() {
-        return Promise.resolve(1);
-      }
-      async function* test1() {
-        yield asyncFunction();
-      }
-    `,
-    `
-      declare const asyncFunction: () => Promise<void>;
-      async function* test1() {
-        yield asyncFunction();
-      }
-    `,
-    `
-      async function* test1() {
-        yield new Promise(() => {});
-      }
-    `,
-  ],
-
   invalid: [
     {
       // Async function declaration with no await
@@ -264,18 +25,18 @@ async function numberOne(): Promise<number> {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async function 'numberOne'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
 function numberOne(): number {
   return 1;
 }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -290,18 +51,18 @@ const numberOne = async function (): Promise<number> {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async function 'numberOne'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
 const numberOne = function (): number {
   return 1;
 };
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -312,14 +73,14 @@ const numberOne = function (): number {
       code: 'const numberOne = async (): Promise<number> => 1;',
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async arrow function 'numberOne'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
-              output: 'const numberOne = (): number => 1;',
               messageId: 'removeAsync',
+              output: 'const numberOne = (): number => 1;',
             },
           ],
         },
@@ -334,18 +95,18 @@ async function values(): Promise<Array<number>> {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async function 'values'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
 function values(): Array<number> {
   return [1];
 }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -362,10 +123,10 @@ function values(): Array<number> {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -391,18 +152,18 @@ async function* foo(): void {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
 function* foo(): void {
   doSomething();
 }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -416,10 +177,10 @@ async function* foo() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -443,10 +204,10 @@ const foo = async function* () {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -468,10 +229,10 @@ async function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'asyncGenerator'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -493,10 +254,10 @@ async function* asyncGenerator(source: Iterable<any>) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'asyncGenerator'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -523,10 +284,10 @@ async function* asyncGenerator(source: Iterable<any> | AsyncIterable<any>) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'asyncGenerator'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -556,10 +317,10 @@ async function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'asyncGenerator'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -586,10 +347,10 @@ async function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'asyncGenerator'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -611,10 +372,10 @@ function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async arrow function 'fn'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -637,10 +398,10 @@ function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -663,10 +424,10 @@ function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -688,10 +449,10 @@ function* asyncGenerator() {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: {
             name: "Async generator function 'foo'",
           },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -706,120 +467,249 @@ function* asyncGenerator() {
       ],
     },
   ],
-});
-// base eslint tests
-// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/tests/lib/rules/require-await.js#L25-L274
-ruleTester.run('require-await', rule, {
+
   valid: [
+    // Non-async function declaration
     `
-async function foo() {
-  await doSomething();
+function numberOne(): number {
+  return 1;
 }
     `,
+    // Non-async function expression
     `
-(async function () {
-  await doSomething();
-});
+const numberOne = function (): number {
+  return 1;
+};
     `,
+    // Non-async arrow function expression (concise-body)
     `
-async () => {
-  await doSomething();
+      const numberOne = (): number => 1;
+    `,
+    // Non-async arrow function expression (block-body)
+    `
+const numberOne = (): number => {
+  return 1;
 };
     `,
-    'async () => await doSomething();',
+    // Non-async function that returns a promise
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1226
     `
-({
-  async foo() {
-    await doSomething();
-  },
-});
+function 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;
+}
+    `,
+    // Async function expression with await
+    `
+const numberOne = async function (): Promise<number> {
+  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;
+};
+    `,
+    // Async function declaration with promise return
+    `
+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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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 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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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),
+    ),
+  );
+}
+    `,
+    `
+function* test6() {
+  yield* syncGenerator();
+}
+    `,
+    `
+function* syncGenerator() {
+  yield 1;
+}
+    `,
+    `
+async function* asyncGenerator() {
+  await Promise.resolve();
+  yield 1;
+}
+async function* test1() {
+  yield* asyncGenerator();
+}
+    `,
+    `
+async function* asyncGenerator() {
+  await Promise.resolve();
+  yield 1;
+}
+async function* test1() {
+  yield* asyncGenerator();
+  yield* 2;
+}
+    `,
+    `
+async function* test(source: AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+async function* test(source: Iterable<any> & AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+async function* test(source: Iterable<any> | AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+type MyType = {
+  [Symbol.iterator](): Iterator<any>;
+  [Symbol.asyncIterator](): AsyncIterator<any>;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+type MyType = {
+  [Symbol.asyncIterator]: () => AsyncIterator<any>;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+type MyFunctionType = () => AsyncIterator<any>;
+type MyType = {
+  [Symbol.asyncIterator]: MyFunctionType;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+async function* foo(): Promise<string> {
+  return new Promise(res => res(\`hello\`));
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/5458
+    `
+      async function* f() {
+        let x!: Omit<
+          {
+            [Symbol.asyncIterator](): AsyncIterator<any>;
+          },
+          'z'
+        >;
+        yield* x;
+      }
     `,
     `
-class A {
-  async foo() {
-    await doSomething();
-  }
-}
+      const fn = async () => {
+        await using foo = new Bar();
+      };
     `,
     `
-(class {
-  async foo() {
-    await doSomething();
-  }
-});
+      async function* test1() {
+        yield Promise.resolve(1);
+      }
     `,
     `
-async function foo() {
-  await (async () => {
-    await doSomething();
-  });
-}
+      function asyncFunction() {
+        return Promise.resolve(1);
+      }
+      async function* test1() {
+        yield asyncFunction();
+      }
     `,
-    // empty functions are ok.
-    'async function foo() {}',
-    'async () => {};',
-    // normal functions are ok.
     `
-function foo() {
-  doSomething();
-}
+      declare const asyncFunction: () => Promise<void>;
+      async function* test1() {
+        yield asyncFunction();
+      }
     `,
-    // for-await-of
     `
-async function foo() {
-  for await (x of xs);
-}
+      async function* test1() {
+        yield new Promise(() => {});
+      }
     `,
-    // -- global await
-    {
-      code: 'await foo();',
-    },
-    {
-      code: `
-for await (let num of asyncIterable) {
-  console.log(num);
-}
-      `,
-    },
-    {
-      code: `
-        async function* run() {
-          await new Promise(resolve => setTimeout(resolve, 100));
-          yield 'Hello';
-          console.log('World');
-        }
-      `,
-    },
-    {
-      code: 'async function* run() {}',
-    },
-    {
-      code: 'const foo = async function* () {};',
-    },
-    // Note: There are three test cases for async generators in the
-    // ESLint repository that are considered valid. Because we have
-    // type information, we can consider those cases to be invalid.
-    // There are test cases in here to confirm that they are invalid.
-    //
-    // See https://github.com/typescript-eslint/typescript-eslint/pull/1782
-    //
-    // The cases are:
-    //
-    //  1.
-    //  async function* run() {
-    //    yield* anotherAsyncGenerator();
-    //  }
-    //
-    //  2.
-    //  const foo = async function* () {
-    //   console.log('bar');
-    //  };
-    //
-    //  3.
-    //  async function* run() {
-    //    console.log('bar');
-    //  }
   ],
+});
+// base eslint tests
+// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/tests/lib/rules/require-await.js#L25-L274
+ruleTester.run('require-await', rule, {
   invalid: [
     {
       code: `
@@ -829,8 +719,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async function 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -852,8 +742,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async function' },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -875,8 +765,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async arrow function' },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -894,8 +784,8 @@ for await (let num of asyncIterable) {
       code: 'async () => doSomething();',
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async arrow function' },
+          messageId: 'missingAwait',
           suggestions: [
             { messageId: 'removeAsync', output: '() => doSomething();' },
           ],
@@ -912,8 +802,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async method 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -939,8 +829,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async method 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -966,8 +856,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async method 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -993,8 +883,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async method 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -1020,8 +910,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async method' },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -1047,8 +937,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async function 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -1074,8 +964,8 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async arrow function' },
+          messageId: 'missingAwait',
           suggestions: [
             {
               messageId: 'removeAsync',
@@ -1101,10 +991,11 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async method 'async'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
         const obj = {
           async: function foo() {
@@ -1112,7 +1003,6 @@ for await (let num of asyncIterable) {
           },
         };
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -1128,16 +1018,16 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: "Async function 'foo'" },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
         /* test */ function foo() {
           doSomething();
         }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -1155,10 +1045,11 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async method' },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
         class A {
           a = 0
@@ -1167,7 +1058,6 @@ for await (let num of asyncIterable) {
           }
         }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -1183,17 +1073,17 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async arrow function' },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
         foo
         ;() => {
           return 0;
         }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
@@ -1210,10 +1100,11 @@ for await (let num of asyncIterable) {
       `,
       errors: [
         {
-          messageId: 'missingAwait',
           data: { name: 'Async method' },
+          messageId: 'missingAwait',
           suggestions: [
             {
+              messageId: 'removeAsync',
               output: `
         class A {
           foo() {}
@@ -1222,11 +1113,120 @@ for await (let num of asyncIterable) {
           }
         }
       `,
-              messageId: 'removeAsync',
             },
           ],
         },
       ],
     },
   ],
+  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();
+  });
+}
+    `,
+    // 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);
+}
+      `,
+    },
+    {
+      code: `
+        async function* run() {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          yield 'Hello';
+          console.log('World');
+        }
+      `,
+    },
+    {
+      code: 'async function* run() {}',
+    },
+    {
+      code: 'const foo = async function* () {};',
+    },
+    // Note: There are three test cases for async generators in the
+    // ESLint repository that are considered valid. Because we have
+    // type information, we can consider those cases to be invalid.
+    // There are test cases in here to confirm that they are invalid.
+    //
+    // See https://github.com/typescript-eslint/typescript-eslint/pull/1782
+    //
+    // The cases are:
+    //
+    //  1.
+    //  async function* run() {
+    //    yield* anotherAsyncGenerator();
+    //  }
+    //
+    //  2.
+    //  const foo = async function* () {
+    //   console.log('bar');
+    //  };
+    //
+    //  3.
+    //  async function* run() {
+    //    console.log('bar');
+    //  }
+  ],
 });
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 769edd44f11e..0a46ed700ea4 100644
--- a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
@@ -8,249 +8,96 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('restrict-plus-operands', rule, {
-  valid: [
-    'let x = 5;',
-    "let y = '10';",
-    'let z = 8.2;',
-    "let w = '6.5';",
-    'let foo = 5 + 10;',
-    "let foo = '5.5' + '10';",
-    "let foo = parseInt('5.5', 10) + 10;",
-    "let foo = parseFloat('5.5', 10) + 10;",
-    'let foo = 1n + 1n;',
-    'let foo = BigInt(1) + 1n;',
-    `
-      let foo = 1n;
-      foo + 2n;
-    `,
-    `
-function test(s: string, n: number): number {
-  return 2;
-}
-let foo = test('5.5', 10) + 10;
-    `,
-    `
-let x = 5;
-let z = 8.2;
-let foo = x + z;
-    `,
-    `
-let w = '6.5';
-let y = '10';
-let foo = y + w;
-    `,
-    'let foo = 1 + 1;',
-    "let foo = '1' + '1';",
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = pair.first + 10;
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = pair.first + (10 as number);
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = '5.5' + pair.second;
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = ('5.5' as string) + pair.second;
-    `,
-    `
-      const foo =
-        'hello' +
-        (someBoolean ? 'a' : 'b') +
-        (() => (someBoolean ? 'c' : 'd'))() +
-        'e';
-    `,
-    'const balls = true;',
-    'balls === true;',
-    // https://github.com/typescript-eslint/typescript-eslint/issues/230
-    `
-function foo<T extends string>(a: T) {
-  return a + '';
-}
-    `,
-    `
-function foo<T extends 'a' | 'b'>(a: T) {
-  return a + '';
-}
-    `,
-    `
-function foo<T extends number>(a: T) {
-  return a + 1;
-}
-    `,
-    `
-function foo<T extends 1>(a: T) {
-  return a + 1;
-}
-    `,
-    `
-declare const a: {} & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: string & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: 'string literal' & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: {} & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: number & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: 42 & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: {} & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: bigint & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: 42n & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-function A(s: string) {
-  return \`a\${s}b\` as const;
-}
-const b = A('') + '!';
-    `,
-    `
-declare const a: \`template\${string}\`;
-declare const b: '';
-const x = a + b;
-    `,
-    `
-const a: \`template\${0}\`;
-declare const b: '';
-const x = a + b;
-    `,
+  invalid: [
     {
-      code: `
-        declare const a: RegExp;
-        declare const b: string;
-        const x = a + b;
-      `,
-      options: [
+      code: "let foo = '1' + 1;",
+      errors: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: true,
-          allowNullish: false,
+          column: 11,
+          data: {
+            left: 'string',
+            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+          },
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
+      options: [{ allowNumberAndString: false }],
     },
     {
-      code: `
-        const a = /regexp/;
-        declare const b: string;
-        const x = a + b;
-      `,
-      options: [
+      code: "let foo = '1' + 1;",
+      errors: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: true,
-          allowNullish: false,
+          column: 11,
+          data: {
+            left: 'string',
+            right: 'number',
+            stringLike: 'string',
+          },
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
-    },
-    // TypeScript handles this case, so we don't have to
-    {
-      code: `
-const f = (a: RegExp, b: RegExp) => a + b;
-      `,
       options: [
         {
-          allowRegExp: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
-      code: `
-let foo: string | undefined;
-foo = foo + 'some data';
-      `,
-      options: [
+      code: 'let foo = [] + {};',
+      errors: [
         {
-          allowNullish: true,
+          column: 11,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
+          },
+          endColumn: 13,
+          line: 1,
+          messageId: 'invalid',
         },
-      ],
-    },
-    {
-      code: `
-let foo: string | null;
-foo = foo + 'some data';
-      `,
-      options: [
         {
-          allowNullish: true,
+          column: 16,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
+          },
+          endColumn: 18,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-let foo: string | null | undefined;
-foo = foo + 'some data';
-      `,
-      options: [
+      code: "let foo = 5 + '10';",
+      errors: [
         {
-          allowNullish: true,
+          column: 11,
+          data: {
+            left: 'number',
+            right: 'string',
+            stringLike: 'string',
+          },
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
-    },
-    {
-      code: `
-let foo = '';
-foo += 0;
-      `,
       options: [
         {
           allowAny: false,
@@ -258,150 +105,221 @@ foo += 0;
           allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          skipCompoundAssignments: true,
         },
       ],
     },
     {
-      code: `
-let foo = 0;
-foo += '';
-      `,
-      options: [
+      code: 'let foo = [] + 5;',
+      errors: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          skipCompoundAssignments: true,
+          column: 11,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
+          },
+          endColumn: 13,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-const f = (a: any, b: any) => a + b;
-      `,
-      options: [
+      code: 'let foo = [] + [];',
+      errors: [
         {
-          allowAny: true,
+          column: 11,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
+          },
+          endColumn: 13,
+          line: 1,
+          messageId: 'invalid',
+        },
+        {
+          column: 16,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
+          },
+          endColumn: 18,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-const f = (a: any, b: string) => a + b;
-      `,
-      options: [
+      code: 'let foo = 5 + [3];',
+      errors: [
         {
-          allowAny: true,
+          column: 15,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'number[]',
+          },
+          endColumn: 18,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-const f = (a: any, b: bigint) => a + b;
-      `,
-      options: [
+      code: "let foo = '5' + {};",
+      errors: [
         {
-          allowAny: true,
+          column: 17,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
+          },
+          endColumn: 19,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-const f = (a: any, b: number) => a + b;
-      `,
-      options: [
+      code: "let foo = 5.5 + '5';",
+      errors: [
         {
-          allowAny: true,
+          column: 11,
+          data: {
+            left: 'number',
+            right: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+          },
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
+      options: [{ allowNumberAndString: false }],
     },
     {
-      code: `
-const f = (a: any, b: boolean) => a + b;
-      `,
-      options: [
+      code: "let foo = '5.5' + 5;",
+      errors: [
         {
-          allowAny: true,
-          allowBoolean: true,
+          column: 11,
+          data: {
+            left: 'string',
+            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+          },
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-const f = (a: string, b: string | number) => a + b;
+let x = 5;
+let y = '10';
+let foo = x + y;
       `,
-      options: [
+      errors: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumberAndString: true,
-          allowRegExp: true,
+          column: 11,
+          data: {
+            left: 'number',
+            right: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+          },
+          line: 4,
+          messageId: 'mismatched',
         },
       ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-const f = (a: string | number, b: number) => a + b;
+let x = 5;
+let y = '10';
+let foo = y + x;
       `,
-      options: [
+      errors: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumberAndString: true,
-          allowRegExp: true,
+          column: 11,
+          data: {
+            left: 'string',
+            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+          },
+          line: 4,
+          messageId: 'mismatched',
         },
       ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-const f = (a: string | number, b: string | number) => a + b;
+let x = 5;
+let foo = x + {};
       `,
-      options: [
+      errors: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumberAndString: true,
-          allowRegExp: true,
+          column: 15,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
+          },
+          line: 3,
+          messageId: 'invalid',
         },
       ],
     },
-  ],
-  invalid: [
     {
-      code: "let foo = '1' + 1;",
+      code: `
+let y = '10';
+let foo = [] + y;
+      `,
       errors: [
         {
+          column: 11,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike:
               'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
           },
-          messageId: 'mismatched',
-          line: 1,
-          column: 11,
+          line: 3,
+          messageId: 'invalid',
         },
       ],
-      options: [{ allowNumberAndString: false }],
     },
     {
-      code: "let foo = '1' + 1;",
+      code: `
+let pair = { first: 5, second: '10' };
+let foo = pair + pair;
+      `,
       errors: [
         {
+          column: 11,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike: 'string',
+            type: '{ first: number; second: string; }',
           },
-          messageId: 'mismatched',
-          line: 1,
-          column: 11,
+          endColumn: 15,
+          line: 3,
+          messageId: 'invalid',
+        },
+        {
+          column: 18,
+          data: {
+            stringLike: 'string',
+            type: '{ first: number; second: string; }',
+          },
+          endColumn: 22,
+          line: 3,
+          messageId: 'invalid',
         },
       ],
       options: [
@@ -415,44 +333,21 @@ const f = (a: string | number, b: string | number) => a + b;
       ],
     },
     {
-      code: 'let foo = [] + {};',
+      code: `
+type Valued = { value: number };
+let value: Valued = { value: 0 };
+let combined = value + 0;
+      `,
       errors: [
         {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
-          },
-          column: 11,
-          endColumn: 13,
-          line: 1,
-          messageId: 'invalid',
-        },
-        {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
-          },
           column: 16,
-          endColumn: 18,
-          line: 1,
-          messageId: 'invalid',
-        },
-      ],
-    },
-    {
-      code: "let foo = 5 + '10';",
-      errors: [
-        {
           data: {
-            left: 'number',
-            right: 'string',
             stringLike: 'string',
+            type: 'Valued',
           },
-          messageId: 'mismatched',
-          line: 1,
-          column: 11,
+          endColumn: 21,
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
@@ -466,216 +361,303 @@ const f = (a: string | number, b: string | number) => a + b;
       ],
     },
     {
-      code: 'let foo = [] + 5;',
+      code: 'let foo = 1n + 1;',
       errors: [
         {
+          column: 11,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
+            left: 'bigint',
+            right: 'number',
           },
-          messageId: 'invalid',
           line: 1,
-          column: 11,
-          endColumn: 13,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
     {
-      code: 'let foo = [] + [];',
+      code: 'let foo = 1 + 1n;',
       errors: [
         {
+          column: 11,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
+            left: 'number',
+            right: 'bigint',
           },
-          messageId: 'invalid',
           line: 1,
-          endColumn: 13,
-          column: 11,
+          messageId: 'bigintAndNumber',
         },
+      ],
+    },
+    {
+      code: `
+        let foo = 1n;
+        foo + 1;
+      `,
+      errors: [
         {
+          column: 9,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
+            left: 'bigint',
+            right: 'number',
           },
-          messageId: 'invalid',
-          line: 1,
-          endColumn: 18,
-          column: 16,
+          line: 3,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
     {
-      code: 'let foo = 5 + [3];',
+      code: `
+        let foo = 1;
+        foo + 1n;
+      `,
       errors: [
         {
+          column: 9,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'number[]',
+            left: 'number',
+            right: 'bigint',
           },
-          column: 15,
-          endColumn: 18,
-          line: 1,
-          messageId: 'invalid',
+          line: 3,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/230
     {
-      code: "let foo = '5' + {};",
+      code: `
+function foo<T extends string>(a: T) {
+  return a + 1;
+}
+      `,
       errors: [
         {
+          column: 10,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
+            left: 'string',
+            right: 'number',
+            stringLike: 'string',
           },
-          messageId: 'invalid',
-          line: 1,
-          endColumn: 19,
-          column: 17,
+          line: 3,
+          messageId: 'mismatched',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
-      code: "let foo = 5.5 + '5';",
+      code: `
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + 1;
+}
+      `,
       errors: [
         {
+          column: 10,
           data: {
-            left: 'number',
-            right: 'string',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            left: 'string',
+            right: 'number',
+            stringLike: 'string',
           },
+          line: 3,
           messageId: 'mismatched',
-          line: 1,
-          column: 11,
         },
       ],
-      options: [{ allowNumberAndString: false }],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+        },
+      ],
     },
     {
-      code: "let foo = '5.5' + 5;",
+      code: `
+function foo<T extends number>(a: T) {
+  return a + '';
+}
+      `,
       errors: [
         {
+          column: 10,
           data: {
-            left: 'string',
-            right: 'number',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            left: 'number',
+            right: 'string',
+            stringLike: 'string',
           },
+          line: 3,
           messageId: 'mismatched',
-          line: 1,
-          column: 11,
         },
       ],
-      options: [{ allowNumberAndString: false }],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+        },
+      ],
     },
     {
       code: `
-let x = 5;
-let y = '10';
-let foo = x + y;
+function foo<T extends 1>(a: T) {
+  return a + '';
+}
       `,
       errors: [
         {
+          column: 10,
           data: {
             left: 'number',
             right: 'string',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            stringLike: 'string',
           },
+          line: 3,
           messageId: 'mismatched',
-          line: 4,
-          column: 11,
         },
       ],
-      options: [{ allowNumberAndString: false }],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+        },
+      ],
     },
     {
       code: `
-let x = 5;
-let y = '10';
-let foo = y + x;
+        declare const a: \`template\${number}\`;
+        declare const b: number;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            right: 'number',
             left: 'string',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            right: 'number',
+            stringLike: 'string',
           },
+          line: 4,
           messageId: 'mismatched',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+        },
+      ],
+    },
+    {
+      code: `
+        declare const a: never;
+        declare const b: string;
+        const x = a + b;
+      `,
+      errors: [
+        {
+          column: 19,
+          data: {
+            stringLike: 'string',
+            type: 'never',
+          },
           line: 4,
-          column: 11,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
-      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-let x = 5;
-let foo = x + {};
+        declare const a: never & string;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
+            stringLike: 'string',
+            type: 'never',
           },
+          line: 4,
           messageId: 'invalid',
-          line: 3,
-          column: 15,
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let y = '10';
-let foo = [] + y;
+        declare const a: boolean & string;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
+            stringLike: 'string',
+            type: 'never',
           },
+          line: 4,
           messageId: 'invalid',
-          line: 3,
-          column: 11,
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let pair = { first: 5, second: '10' };
-let foo = pair + pair;
+        declare const a: any & string;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: '{ first: number; second: string; }',
-          },
-          column: 11,
-          endColumn: 15,
-          line: 3,
-          messageId: 'invalid',
-        },
-        {
-          data: {
-            stringLike: 'string',
-            type: '{ first: number; second: string; }',
+            type: 'any',
           },
-          column: 18,
-          endColumn: 22,
-          line: 3,
+          line: 4,
           messageId: 'invalid',
         },
       ],
@@ -683,26 +665,25 @@ let foo = pair + pair;
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-type Valued = { value: number };
-let value: Valued = { value: 0 };
-let combined = value + 0;
+        declare const a: { a: 1 } & { b: 2 };
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'Valued',
+            type: '{ a: 1; } & { b: 2; }',
           },
-          column: 16,
-          endColumn: 21,
           line: 4,
           messageId: 'invalid',
         },
@@ -711,1062 +692,1081 @@ let combined = value + 0;
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
-      code: 'let foo = 1n + 1;',
+      code: `
+        interface A {
+          a: 1;
+        }
+        declare const a: A;
+        declare const b: string;
+        const x = a + b;
+      `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'bigint',
-            right: 'number',
+            stringLike: 'string',
+            type: 'A',
           },
-          messageId: 'bigintAndNumber',
-          line: 1,
-          column: 11,
+          line: 7,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
-      code: 'let foo = 1 + 1n;',
+      code: `
+        interface A {
+          a: 1;
+        }
+        interface A2 extends A {
+          b: 2;
+        }
+        declare const a: A2;
+        declare const b: string;
+        const x = a + b;
+      `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'number',
-            right: 'bigint',
+            stringLike: 'string',
+            type: 'A2',
           },
-          messageId: 'bigintAndNumber',
-          line: 1,
-          column: 11,
+          line: 10,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-        let foo = 1n;
-        foo + 1;
+        type A = { a: 1 } & { b: 2 };
+        declare const a: A;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'bigint',
-            right: 'number',
+            stringLike: 'string',
+            type: 'A',
           },
-          messageId: 'bigintAndNumber',
-          line: 3,
-          column: 9,
+          line: 5,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-        let foo = 1;
-        foo + 1n;
+        declare const a: { a: 1 } & { b: 2 };
+        declare const b: number;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'number',
-            right: 'bigint',
+            stringLike: 'string',
+            type: '{ a: 1; } & { b: 2; }',
           },
-          messageId: 'bigintAndNumber',
-          line: 3,
-          column: 9,
+          line: 4,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/230
     {
       code: `
-function foo<T extends string>(a: T) {
-  return a + 1;
-}
+        declare const a: never;
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike: 'string',
+            type: 'never',
           },
-          messageId: 'mismatched',
-          line: 3,
-          column: 10,
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-function foo<T extends 'a' | 'b'>(a: T) {
-  return a + 1;
-}
+        declare const a: any;
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike: 'string',
+            type: 'any',
           },
-          messageId: 'mismatched',
-          line: 3,
-          column: 10,
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-function foo<T extends number>(a: T) {
-  return a + '';
-}
+        declare const a: { a: 1 } & { b: 2 };
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'number',
-            right: 'string',
             stringLike: 'string',
+            type: '{ a: 1; } & { b: 2; }',
           },
-          messageId: 'mismatched',
-          line: 3,
-          column: 10,
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-function foo<T extends 1>(a: T) {
-  return a + '';
-}
+        declare const a: RegExp;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'number',
-            right: 'string',
             stringLike: 'string',
+            type: 'RegExp',
           },
-          messageId: 'mismatched',
-          line: 3,
-          column: 10,
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: \`template\${number}\`;
-        declare const b: number;
+        const a = /regexp/;
+        declare const b: string;
         const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike: 'string',
+            type: 'RegExp',
           },
-          messageId: 'mismatched',
           line: 4,
-          column: 19,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: never;
+        declare const a: Symbol;
         declare const b: string;
         const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'never',
+            type: 'Symbol',
           },
-          messageId: 'invalid',
           line: 4,
-          column: 19,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: never & string;
+        declare const a: symbol;
         declare const b: string;
         const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'never',
+            type: 'symbol',
           },
-          messageId: 'invalid',
           line: 4,
-          column: 19,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: boolean & string;
+        declare const a: unique symbol;
         declare const b: string;
         const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'never',
+            type: 'unique symbol',
           },
-          messageId: 'invalid',
           line: 4,
-          column: 19,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: any & string;
+        const a = Symbol('');
         declare const b: string;
         const x = a + b;
       `,
       errors: [
         {
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'any',
+            type: 'unique symbol',
           },
-          messageId: 'invalid',
           line: 4,
-          column: 19,
+          messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: string;
-        const x = a + b;
+let foo: string | undefined;
+foo += 'some data';
       `,
       errors: [
         {
+          column: 1,
           data: {
             stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
+            type: 'string | undefined',
           },
+          line: 3,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
+          skipCompoundAssignments: false,
         },
       ],
     },
     {
       code: `
-        interface A {
-          a: 1;
-        }
-        declare const a: A;
-        declare const b: string;
-        const x = a + b;
+let foo: string | null;
+foo += 'some data';
       `,
       errors: [
         {
+          column: 1,
           data: {
             stringLike: 'string',
-            type: 'A',
+            type: 'string | null',
           },
+          line: 3,
           messageId: 'invalid',
-          line: 7,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        interface A {
-          a: 1;
-        }
-        interface A2 extends A {
-          b: 2;
-        }
-        declare const a: A2;
-        declare const b: string;
-        const x = a + b;
+let foo: string = '';
+foo += 1;
       `,
       errors: [
         {
+          column: 1,
           data: {
+            left: 'string',
+            right: 'number',
             stringLike: 'string',
-            type: 'A2',
           },
-          messageId: 'invalid',
-          line: 10,
-          column: 19,
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        type A = { a: 1 } & { b: 2 };
-        declare const a: A;
-        declare const b: string;
-        const x = a + b;
+let foo = 0;
+foo += '';
       `,
       errors: [
         {
+          column: 1,
           data: {
+            left: 'number',
+            right: 'string',
             stringLike: 'string',
-            type: 'A',
           },
-          messageId: 'invalid',
-          line: 5,
-          column: 19,
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: number;
-        const x = a + b;
+const f = (a: any, b: boolean) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
-          },
+          column: 39,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
-          allowAny: false,
+          allowAny: true,
           allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: never;
-        declare const b: bigint;
-        const x = a + b;
+const f = (a: any, b: []) => a + b;
       `,
       errors: [
         {
+          column: 34,
           data: {
-            stringLike: 'string',
-            type: 'never',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '[]',
           },
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-        declare const a: any;
-        declare const b: bigint;
-        const x = a + b;
+const f = (a: any, b: boolean) => a + b;
       `,
       errors: [
         {
+          column: 35,
           data: {
-            stringLike: 'string',
+            stringLike:
+              'string, allowing a string + any of: `boolean`, `null`, `RegExp`, `undefined`',
             type: 'any',
           },
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
+          allowBoolean: true,
         },
       ],
     },
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: bigint;
-        const x = a + b;
+const f = (a: any, b: any) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
-          },
+          column: 31,
+          line: 2,
+          messageId: 'invalid',
+        },
+        {
+          column: 35,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: RegExp;
-        declare const b: string;
-        const x = a + b;
+const f = (a: any, b: string) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: 'RegExp',
-          },
+          column: 34,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        const a = /regexp/;
-        declare const b: string;
-        const x = a + b;
+const f = (a: any, b: bigint) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: 'RegExp',
-          },
+          column: 34,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: Symbol;
-        declare const b: string;
-        const x = a + b;
+const f = (a: any, b: number) => a + b;
+      `,
+      errors: [
+        {
+          column: 34,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+        },
+      ],
+    },
+    {
+      code: `
+const f = (a: any, b: boolean) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: 'Symbol',
-          },
+          column: 35,
+          line: 2,
+          messageId: 'invalid',
+        },
+        {
+          column: 39,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        declare const a: symbol;
-        declare const b: string;
-        const x = a + b;
+const f = (a: number, b: RegExp) => a + b;
       `,
       errors: [
         {
-          data: {
-            stringLike: 'string',
-            type: 'symbol',
-          },
+          column: 41,
+          line: 2,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
+          allowRegExp: true,
         },
       ],
     },
     {
       code: `
-        declare const a: unique symbol;
-        declare const b: string;
-        const x = a + b;
+let foo: string | boolean;
+foo = foo + 'some data';
       `,
       errors: [
         {
+          column: 7,
           data: {
-            stringLike: 'string',
-            type: 'unique symbol',
+            stringLike:
+              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
+            type: 'string | boolean',
           },
+          line: 3,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
-          allowAny: false,
           allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-        const a = Symbol('');
-        declare const b: string;
-        const x = a + b;
+let foo: boolean;
+foo = foo + 'some data';
       `,
       errors: [
         {
+          column: 7,
           data: {
-            stringLike: 'string',
-            type: 'unique symbol',
+            stringLike:
+              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
+            type: 'boolean',
           },
+          line: 3,
           messageId: 'invalid',
-          line: 4,
-          column: 19,
         },
       ],
       options: [
         {
-          allowAny: false,
           allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
         },
       ],
     },
     {
       code: `
-let foo: string | undefined;
-foo += 'some data';
+const f = (a: any, b: unknown) => a + b;
       `,
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          allowNullish: false,
-          skipCompoundAssignments: false,
-        },
-      ],
       errors: [
         {
+          column: 39,
           data: {
-            stringLike: 'string',
-            type: 'string | undefined',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'unknown',
           },
+          line: 2,
           messageId: 'invalid',
-          line: 3,
-          column: 1,
+        },
+      ],
+      options: [
+        {
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowRegExp: true,
         },
       ],
     },
+  ],
+  valid: [
+    'let x = 5;',
+    "let y = '10';",
+    'let z = 8.2;',
+    "let w = '6.5';",
+    'let foo = 5 + 10;',
+    "let foo = '5.5' + '10';",
+    "let foo = parseInt('5.5', 10) + 10;",
+    "let foo = parseFloat('5.5', 10) + 10;",
+    'let foo = 1n + 1n;',
+    'let foo = BigInt(1) + 1n;',
+    `
+      let foo = 1n;
+      foo + 2n;
+    `,
+    `
+function test(s: string, n: number): number {
+  return 2;
+}
+let foo = test('5.5', 10) + 10;
+    `,
+    `
+let x = 5;
+let z = 8.2;
+let foo = x + z;
+    `,
+    `
+let w = '6.5';
+let y = '10';
+let foo = y + w;
+    `,
+    'let foo = 1 + 1;',
+    "let foo = '1' + '1';",
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = pair.first + 10;
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = pair.first + (10 as number);
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = '5.5' + pair.second;
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = ('5.5' as string) + pair.second;
+    `,
+    `
+      const foo =
+        'hello' +
+        (someBoolean ? 'a' : 'b') +
+        (() => (someBoolean ? 'c' : 'd'))() +
+        'e';
+    `,
+    'const balls = true;',
+    'balls === true;',
+    // https://github.com/typescript-eslint/typescript-eslint/issues/230
+    `
+function foo<T extends string>(a: T) {
+  return a + '';
+}
+    `,
+    `
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + '';
+}
+    `,
+    `
+function foo<T extends number>(a: T) {
+  return a + 1;
+}
+    `,
+    `
+function foo<T extends 1>(a: T) {
+  return a + 1;
+}
+    `,
+    `
+declare const a: {} & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: string & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: 'string literal' & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: {} & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: number & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: 42 & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: {} & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: bigint & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: 42n & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+function A(s: string) {
+  return \`a\${s}b\` as const;
+}
+const b = A('') + '!';
+    `,
+    `
+declare const a: \`template\${string}\`;
+declare const b: '';
+const x = a + b;
+    `,
+    `
+const a: \`template\${0}\`;
+declare const b: '';
+const x = a + b;
+    `,
     {
       code: `
-let foo: string | null;
-foo += 'some data';
+        declare const a: RegExp;
+        declare const b: string;
+        const x = a + b;
       `,
-      errors: [
-        {
-          data: {
-            stringLike: 'string',
-            type: 'string | null',
-          },
-          messageId: 'invalid',
-          line: 3,
-          column: 1,
-        },
-      ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
           allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: true,
         },
       ],
     },
     {
       code: `
-let foo: string = '';
-foo += 1;
+        const a = /regexp/;
+        declare const b: string;
+        const x = a + b;
       `,
-      errors: [
-        {
-          data: {
-            left: 'string',
-            right: 'number',
-            stringLike: 'string',
-          },
-          messageId: 'mismatched',
-          line: 3,
-          column: 1,
-        },
-      ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
           allowNullish: false,
           allowNumberAndString: false,
-          allowRegExp: false,
+          allowRegExp: true,
         },
       ],
     },
+    // TypeScript handles this case, so we don't have to
     {
       code: `
-let foo = 0;
-foo += '';
+const f = (a: RegExp, b: RegExp) => a + b;
       `,
-      errors: [
-        {
-          data: {
-            left: 'number',
-            right: 'string',
-            stringLike: 'string',
-          },
-          messageId: 'mismatched',
-          line: 3,
-          column: 1,
-        },
-      ],
       options: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
+          allowRegExp: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
+let foo: string | undefined;
+foo = foo + 'some data';
       `,
       options: [
         {
-          allowAny: true,
-          allowBoolean: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 39,
+          allowNullish: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: []) => a + b;
+let foo: string | null;
+foo = foo + 'some data';
       `,
       options: [
         {
-          allowAny: true,
-        },
-      ],
-      errors: [
-        {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '[]',
-          },
-          messageId: 'invalid',
-          line: 2,
-          column: 34,
+          allowNullish: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
+let foo: string | null | undefined;
+foo = foo + 'some data';
       `,
       options: [
         {
-          allowAny: false,
-          allowBoolean: true,
-        },
-      ],
-      errors: [
-        {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'any',
-          },
-          messageId: 'invalid',
-          line: 2,
-          column: 35,
+          allowNullish: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: any) => a + b;
+let foo = '';
+foo += 0;
       `,
       options: [
         {
           allowAny: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 31,
-        },
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 35,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+          skipCompoundAssignments: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: string) => a + b;
+let foo = 0;
+foo += '';
       `,
       options: [
         {
           allowAny: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 34,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+          skipCompoundAssignments: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: bigint) => a + b;
+const f = (a: any, b: any) => a + b;
       `,
       options: [
         {
-          allowAny: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 34,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: number) => a + b;
+const f = (a: any, b: string) => a + b;
       `,
       options: [
         {
-          allowAny: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 34,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
+const f = (a: any, b: bigint) => a + b;
       `,
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 35,
-        },
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 39,
-        },
-      ],
       options: [
         {
-          allowAny: false,
-          allowBoolean: false,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-const f = (a: number, b: RegExp) => a + b;
+const f = (a: any, b: number) => a + b;
       `,
-      errors: [
-        {
-          messageId: 'invalid',
-          line: 2,
-          column: 41,
-        },
-      ],
       options: [
         {
-          allowRegExp: true,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-let foo: string | boolean;
-foo = foo + 'some data';
+const f = (a: any, b: boolean) => a + b;
       `,
-      errors: [
-        {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
-            type: 'string | boolean',
-          },
-          messageId: 'invalid',
-          line: 3,
-          column: 7,
-        },
-      ],
       options: [
         {
-          allowBoolean: false,
+          allowAny: true,
+          allowBoolean: true,
         },
       ],
     },
     {
       code: `
-let foo: boolean;
-foo = foo + 'some data';
+const f = (a: string, b: string | number) => a + b;
       `,
-      errors: [
-        {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
-            type: 'boolean',
-          },
-          messageId: 'invalid',
-          line: 3,
-          column: 7,
-        },
-      ],
       options: [
         {
-          allowBoolean: false,
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumberAndString: true,
+          allowRegExp: true,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: unknown) => a + b;
+const f = (a: string | number, b: number) => a + b;
       `,
       options: [
         {
           allowAny: true,
           allowBoolean: true,
           allowNullish: true,
+          allowNumberAndString: true,
           allowRegExp: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+const f = (a: string | number, b: string | number) => a + b;
+      `,
+      options: [
         {
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'unknown',
-          },
-          messageId: 'invalid',
-          line: 2,
-          column: 39,
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumberAndString: true,
+          allowRegExp: true,
         },
       ],
     },
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 c60c2be4b0aa..41c6e460ff4e 100644
--- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -8,13 +8,274 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('restrict-template-expressions', rule, {
+  invalid: [
+    {
+      code: `
+        const msg = \`arg = \${123}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: '123' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNumber: false }],
+    },
+    {
+      code: `
+        const msg = \`arg = \${false}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'false' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowBoolean: false }],
+    },
+    {
+      code: `
+        const msg = \`arg = \${null}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'null' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNullish: false }],
+    },
+    {
+      code: `
+        declare const arg: number[];
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'number[]' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+    },
+    {
+      code: `
+        const msg = \`arg = \${[, 2]}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: '(number | undefined)[]' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowArray: true, allowNullish: false }],
+    },
+    {
+      code: `
+        declare const arg: [number | undefined, string];
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: '[number | undefined, string]' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowArray: true, allowNullish: false }],
+    },
+    {
+      code: `
+        declare const arg: number;
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'number' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNumber: false }],
+    },
+    {
+      code: `
+        declare const arg: boolean;
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'boolean' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowBoolean: false }],
+    },
+    {
+      code: `
+        const arg = {};
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        { column: 30, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
+      ],
+      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
+    },
+    {
+      code: `
+        declare const arg: { a: string } & { b: string };
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: '{ a: string; } & { b: string; }' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+    },
+    {
+      code: `
+        function test<T extends {}>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      errors: [
+        { column: 27, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
+      ],
+      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
+    },
+    {
+      code: `
+        function test<TWithNoConstraint>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      errors: [
+        {
+          column: 27,
+          data: { type: 'T' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumber: true,
+        },
+      ],
+    },
+    {
+      code: `
+        function test(arg: any) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      errors: [
+        {
+          column: 27,
+          data: { type: 'any' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumber: true,
+        },
+      ],
+    },
+    {
+      code: `
+        const arg = new RegExp('foo');
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'RegExp' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowRegExp: false }],
+    },
+    {
+      code: `
+        const arg = /foo/;
+        const msg = \`arg = \${arg}\`;
+      `,
+      errors: [
+        {
+          column: 30,
+          data: { type: 'RegExp' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowRegExp: false }],
+    },
+    {
+      code: `
+        declare const value: never;
+        const stringy = \`\${value}\`;
+      `,
+      errors: [
+        {
+          column: 28,
+          data: { type: 'never' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNever: false }],
+    },
+    // TS 3.9 change
+    {
+      code: `
+        function test<T extends any>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      errors: [
+        {
+          column: 27,
+          data: { type: 'unknown' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowAny: true }],
+    },
+  ],
+
   valid: [
     // Base case
     `
@@ -49,566 +310,305 @@ ruleTester.run('restrict-template-expressions', rule, {
     `,
     // allowNumber
     {
-      options: [{ allowNumber: true }],
       code: `
         const arg = 123;
         const msg = \`arg = \${arg}\`;
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         const arg = 123;
         const msg = \`arg = \${arg || 'default'}\`;
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         const arg = 123n;
         const msg = \`arg = \${arg || 'default'}\`;
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         function test<T extends number>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         function test<T extends number & { _kind: 'MyBrandedNumber' }>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         function test<T extends bigint>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowNumber: true }],
     },
     {
-      options: [{ allowNumber: true }],
       code: `
         function test<T extends string | number>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowNumber: true }],
     },
     // allowBoolean
     {
-      options: [{ allowBoolean: true }],
       code: `
         const arg = true;
         const msg = \`arg = \${arg}\`;
       `,
+      options: [{ allowBoolean: true }],
     },
     {
-      options: [{ allowBoolean: true }],
       code: `
         const arg = true;
         const msg = \`arg = \${arg || 'default'}\`;
       `,
+      options: [{ allowBoolean: true }],
     },
     {
-      options: [{ allowBoolean: true }],
       code: `
         function test<T extends boolean>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowBoolean: true }],
     },
     {
-      options: [{ allowBoolean: true }],
       code: `
         function test<T extends string | boolean>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowBoolean: true }],
     },
     // allowArray
     {
-      options: [{ allowArray: true }],
       code: `
         const arg = [];
         const msg = \`arg = \${arg}\`;
       `,
+      options: [{ allowArray: true }],
     },
     {
-      options: [{ allowArray: true }],
       code: `
         const arg = [];
         const msg = \`arg = \${arg || 'default'}\`;
       `,
+      options: [{ allowArray: true }],
     },
     {
-      options: [{ allowArray: true }],
       code: `
         function test<T extends string[]>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowArray: true }],
     },
     {
-      options: [{ allowArray: true }],
       code: `
         declare const arg: [number, string];
         const msg = \`arg = \${arg}\`;
       `,
+      options: [{ allowArray: true }],
     },
     {
-      options: [{ allowArray: true }],
       code: `
         const arg = [1, 'a'] as const;
         const msg = \`arg = \${arg || 'default'}\`;
       `,
+      options: [{ allowArray: true }],
     },
     {
-      options: [{ allowArray: true }],
       code: `
         function test<T extends [string, string]>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
+      options: [{ allowArray: true }],
     },
     {
       code: `
         declare const arg: [number | undefined, string];
         const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNullish: true, allowArray: true }],
+      options: [{ allowArray: true, allowNullish: true }],
     },
     // allowAny
     {
-      options: [{ allowAny: true }],
       code: `
         const arg: any = 123;
         const msg = \`arg = \${arg}\`;
       `,
+      options: [{ allowAny: true }],
     },
-    {
-      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'}\`;
-      `,
-    },
-    // allowNullish
-    {
-      options: [{ allowNullish: true }],
-      code: `
-        const arg = null;
-        const msg = \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowNullish: true }],
-      code: `
-        declare const arg: string | null | undefined;
-        const msg = \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowNullish: true }],
-      code: `
-        function test<T extends null | undefined>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-    },
-    {
-      options: [{ allowNullish: true }],
-      code: `
-        function test<T extends string | null>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-    },
-    // allowRegExp
-    {
-      options: [{ allowRegExp: true }],
-      code: `
-        const arg = new RegExp('foo');
-        const msg = \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowRegExp: true }],
-      code: `
-        const arg = /foo/;
-        const msg = \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowRegExp: true }],
-      code: `
-        declare const arg: string | RegExp;
-        const msg = \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowRegExp: true }],
-      code: `
-        function test<T extends RegExp>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-    },
-    {
-      options: [{ allowRegExp: true }],
-      code: `
-        function test<T extends string | RegExp>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-    },
-    // allowNever
-    {
-      options: [{ allowNever: true }],
-      code: `
-        declare const value: never;
-        const stringy = \`\${value}\`;
-      `,
-    },
-    {
-      options: [{ allowNever: true }],
-      code: `
-        const arg = 'hello';
-        const msg = typeof arg === 'string' ? arg : \`arg = \${arg}\`;
-      `,
-    },
-    {
-      options: [{ allowNever: true }],
-      code: `
-        function test(arg: 'one' | 'two') {
-          switch (arg) {
-            case 'one':
-              return 1;
-            case 'two':
-              return 2;
-            default:
-              throw new Error(\`Unrecognised arg: \${arg}\`);
-          }
-        }
-      `,
-    },
-    {
-      options: [{ allowNever: true }],
-      code: `
-        // more variants may be added to Foo in the future
-        type Foo = { type: 'a'; value: number };
-
-        function checkFoosAreMatching(foo1: Foo, foo2: Foo) {
-          if (foo1.type !== foo2.type) {
-            // since Foo currently only has one variant, this code is never run, and \`foo1.type\` has type \`never\`.
-            throw new Error(\`expected \${foo1.type}, found \${foo2.type}\`);
-          }
-        }
-      `,
-    },
-    // allow ALL
-    {
-      options: [
-        {
-          allowNumber: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowRegExp: true,
-          allowNever: true,
-        },
-      ],
-      code: `
-        type All = string | number | boolean | null | undefined | RegExp | never;
-        function test<T extends All>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-    },
-    'const msg = `arg = ${false}`;',
-    'const msg = `arg = ${null}`;',
-    'const msg = `arg = ${undefined}`;',
-    'const msg = `arg = ${123}`;',
-    "const msg = `arg = ${'abc'}`;",
-  ],
-
-  invalid: [
     {
       code: `
-        const msg = \`arg = \${123}\`;
+        const arg: any = undefined;
+        const msg = \`arg = \${arg || 'some-default'}\`;
       `,
-      options: [{ allowNumber: false }],
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: '123' },
-          line: 2,
-          column: 30,
-        },
-      ],
+      options: [{ allowAny: true }],
     },
     {
       code: `
-        const msg = \`arg = \${false}\`;
+        const user = JSON.parse('{ "name": "foo" }');
+        const msg = \`arg = \${user.name}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'false' },
-          line: 2,
-          column: 30,
-        },
-      ],
-      options: [{ allowBoolean: false }],
+      options: [{ allowAny: true }],
     },
     {
       code: `
-        const msg = \`arg = \${null}\`;
+        const user = JSON.parse('{ "name": "foo" }');
+        const msg = \`arg = \${user.name || 'the user with no name'}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'null' },
-          line: 2,
-          column: 30,
-        },
-      ],
-      options: [{ allowNullish: false }],
+      options: [{ allowAny: true }],
     },
+    // allowNullish
     {
       code: `
-        declare const arg: number[];
+        const arg = null;
         const msg = \`arg = \${arg}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'number[]' },
-          line: 3,
-          column: 30,
-        },
-      ],
+      options: [{ allowNullish: true }],
     },
     {
       code: `
-        const msg = \`arg = \${[, 2]}\`;
+        declare const arg: string | null | undefined;
+        const msg = \`arg = \${arg}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: '(number | undefined)[]' },
-          line: 2,
-          column: 30,
-        },
-      ],
-      options: [{ allowNullish: false, allowArray: true }],
+      options: [{ allowNullish: true }],
     },
     {
       code: `
-        declare const arg: [number | undefined, string];
-        const msg = \`arg = \${arg}\`;
+        function test<T extends null | undefined>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: '[number | undefined, string]' },
-          line: 3,
-          column: 30,
-        },
-      ],
-      options: [{ allowNullish: false, allowArray: true }],
+      options: [{ allowNullish: true }],
     },
     {
       code: `
-        declare const arg: number;
-        const msg = \`arg = \${arg}\`;
+        function test<T extends string | null>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
       `,
-      options: [{ allowNumber: false }],
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'number' },
-          line: 3,
-          column: 30,
-        },
-      ],
+      options: [{ allowNullish: true }],
     },
+    // allowRegExp
     {
       code: `
-        declare const arg: boolean;
+        const arg = new RegExp('foo');
         const msg = \`arg = \${arg}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'boolean' },
-          line: 3,
-          column: 30,
-        },
-      ],
-      options: [{ allowBoolean: false }],
+      options: [{ allowRegExp: true }],
     },
     {
-      options: [{ allowNumber: true, allowBoolean: true, allowNullish: true }],
       code: `
-        const arg = {};
+        const arg = /foo/;
         const msg = \`arg = \${arg}\`;
       `,
-      errors: [
-        { messageId: 'invalidType', data: { type: '{}' }, line: 3, column: 30 },
-      ],
+      options: [{ allowRegExp: true }],
     },
     {
       code: `
-        declare const arg: { a: string } & { b: string };
+        declare const arg: string | RegExp;
         const msg = \`arg = \${arg}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: '{ a: string; } & { b: string; }' },
-          line: 3,
-          column: 30,
-        },
-      ],
+      options: [{ allowRegExp: true }],
     },
     {
-      options: [{ allowNumber: true, allowBoolean: true, allowNullish: true }],
       code: `
-        function test<T extends {}>(arg: T) {
+        function test<T extends RegExp>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      errors: [
-        { messageId: 'invalidType', data: { type: '{}' }, line: 3, column: 27 },
-      ],
+      options: [{ allowRegExp: true }],
     },
     {
-      options: [
-        {
-          allowAny: false,
-          allowNumber: true,
-          allowBoolean: true,
-          allowNullish: true,
-        },
-      ],
       code: `
-        function test<TWithNoConstraint>(arg: T) {
+        function test<T extends string | RegExp>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'T' },
-          line: 3,
-          column: 27,
-        },
-      ],
+      options: [{ allowRegExp: true }],
     },
+    // allowNever
     {
-      options: [
-        {
-          allowAny: false,
-          allowNumber: true,
-          allowBoolean: true,
-          allowNullish: true,
-        },
-      ],
       code: `
-        function test(arg: any) {
-          return \`arg = \${arg}\`;
-        }
+        declare const value: never;
+        const stringy = \`\${value}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'any' },
-          line: 3,
-          column: 27,
-        },
-      ],
+      options: [{ allowNever: true }],
     },
     {
-      options: [{ allowRegExp: false }],
       code: `
-        const arg = new RegExp('foo');
-        const msg = \`arg = \${arg}\`;
+        const arg = 'hello';
+        const msg = typeof arg === 'string' ? arg : \`arg = \${arg}\`;
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'RegExp' },
-          line: 3,
-          column: 30,
-        },
-      ],
+      options: [{ allowNever: true }],
     },
     {
-      options: [{ allowRegExp: false }],
       code: `
-        const arg = /foo/;
-        const msg = \`arg = \${arg}\`;
+        function test(arg: 'one' | 'two') {
+          switch (arg) {
+            case 'one':
+              return 1;
+            case 'two':
+              return 2;
+            default:
+              throw new Error(\`Unrecognised arg: \${arg}\`);
+          }
+        }
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'RegExp' },
-          line: 3,
-          column: 30,
-        },
-      ],
+      options: [{ allowNever: true }],
     },
     {
-      options: [{ allowNever: false }],
       code: `
-        declare const value: never;
-        const stringy = \`\${value}\`;
+        // more variants may be added to Foo in the future
+        type Foo = { type: 'a'; value: number };
+
+        function checkFoosAreMatching(foo1: Foo, foo2: Foo) {
+          if (foo1.type !== foo2.type) {
+            // since Foo currently only has one variant, this code is never run, and \`foo1.type\` has type \`never\`.
+            throw new Error(\`expected \${foo1.type}, found \${foo2.type}\`);
+          }
+        }
       `,
-      errors: [
-        {
-          messageId: 'invalidType',
-          data: { type: 'never' },
-          line: 3,
-          column: 28,
-        },
-      ],
+      options: [{ allowNever: true }],
     },
-    // TS 3.9 change
+    // allow ALL
     {
-      options: [{ allowAny: true }],
       code: `
-        function test<T extends any>(arg: T) {
+        type All = string | number | boolean | null | undefined | RegExp | never;
+        function test<T extends All>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'invalidType',
-          data: { type: 'unknown' },
-          line: 3,
-          column: 27,
+          allowBoolean: true,
+          allowNever: true,
+          allowNullish: true,
+          allowNumber: true,
+          allowRegExp: true,
         },
       ],
     },
+    'const msg = `arg = ${false}`;',
+    'const msg = `arg = ${null}`;',
+    'const msg = `arg = ${undefined}`;',
+    'const msg = `arg = ${123}`;',
+    "const msg = `arg = ${'abc'}`;",
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/return-await.test.ts b/packages/eslint-plugin/tests/rules/return-await.test.ts
index adde6284a2f3..393288621640 100644
--- a/packages/eslint-plugin/tests/rules/return-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/return-await.test.ts
@@ -1,4 +1,5 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/return-await';
@@ -9,214 +10,318 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 // default rule is in-try-catch
 ruleTester.run('return-await', rule, {
-  valid: [
-    'return;', // No function in scope, so behave like return in a commonjs module
-    `
-      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');
-        }
-      }
-    `,
+  invalid: [
     {
       code: `
         async function test() {
-          if (Math.random() < 0.33) {
-            return await Promise.resolve(1);
-          } else if (Math.random() < 0.5) {
-            return Promise.resolve(2);
-          }
-
-          try {
-          } catch (e) {
-            return await Promise.resolve(3);
-          } finally {
-            console.log('cleanup');
-          }
+          return await 1;
         }
       `,
-      options: ['error-handling-correctness-only'],
-    },
-    `
-      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');
+      errors: [
+        {
+          line: 3,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: `
+        async function test() {
+          return 1;
         }
-      }
-    `,
+      `,
+    },
     {
-      options: ['in-try-catch'],
       code: `
-        function test() {
-          return 1;
+        async function test() {
+          const foo = 1;
+          return await { foo };
+        }
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: `
+        async function test() {
+          const foo = 1;
+          return { foo };
         }
       `,
     },
     {
-      options: ['in-try-catch'],
       code: `
         async function test() {
-          return 1;
+          const foo = 1;
+          return await foo;
+        }
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: `
+        async function test() {
+          const foo = 1;
+          return foo;
         }
       `,
     },
     {
-      options: ['in-try-catch'],
-      code: 'const test = () => 1;',
+      code: 'const test = async () => await 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => 1;',
     },
     {
-      options: ['in-try-catch'],
-      code: 'const test = async () => 1;',
+      code: 'const test = async () => await /* comment */ 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => /* comment */ 1;',
     },
     {
-      options: ['in-try-catch'],
       code: `
-        async function test() {
-          return Promise.resolve(1);
-        }
+const fn = (): any => null;
+async function test() {
+  return await fn();
+}
       `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'nonPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'nonPromiseAwait',
+              output: `
+const fn = (): any => null;
+async function test() {
+  return fn();
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
-      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');
-          }
-        }
+const fn = (): unknown => null;
+async function test() {
+  return await fn();
+}
       `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'nonPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'nonPromiseAwait',
+              output: `
+const fn = (): unknown => null;
+async function test() {
+  return fn();
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
-      options: ['in-try-catch'],
-      code: `
+      code: 'const test = async () => await Promise.resolve(1);',
+      errors: [
+        {
+          line: 1,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => Promise.resolve(1);',
+    },
+
+    ...['error-handling-correctness-only', 'always', 'in-try-catch'].map(
+      option =>
+        ({
+          code: `
         async function test() {
           try {
-            throw 'foo';
-          } catch (e) {
             return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
         }
       `,
-    },
-    {
-      options: ['in-try-catch'],
-      code: `
+          errors: [
+            {
+              line: 4,
+              messageId: 'requiredPromiseAwait',
+              suggestions: [
+                {
+                  messageId: 'requiredPromiseAwaitSuggestion',
+                  output: `
         async function test() {
           try {
-            throw 'foo';
+            return await Promise.resolve(1);
           } catch (e) {
-            throw 'foo2';
+            return Promise.resolve(2);
           } finally {
-            return Promise.resolve(1);
+            console.log('cleanup');
           }
         }
       `,
-    },
-    {
-      options: ['in-try-catch'],
-      code: `
+                },
+              ],
+            },
+            {
+              line: 6,
+              messageId: 'requiredPromiseAwait',
+              suggestions: [
+                {
+                  messageId: 'requiredPromiseAwaitSuggestion',
+                  output: `
         async function test() {
           try {
-            const one = await Promise.resolve(1);
-            return one;
+            return Promise.resolve(1);
           } catch (e) {
-            const two = await Promise.resolve(2);
-            return two;
+            return await Promise.resolve(2);
           } finally {
             console.log('cleanup');
           }
         }
       `,
-    },
-    {
-      options: ['never'],
+                },
+              ],
+            },
+          ],
+          options: [option],
+          output: null,
+        }) satisfies InvalidTestCase<
+          'requiredPromiseAwait' | 'requiredPromiseAwaitSuggestion',
+          [string]
+        >,
+    ),
+
+    {
       code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      output: `
         async function test() {
           return Promise.resolve(1);
         }
       `,
     },
     {
-      options: ['never'],
-      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');
-          }
+          return await 1;
+        }
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      options: ['in-try-catch'],
+      output: `
+        async function test() {
+          return 1;
         }
       `,
     },
     {
-      options: ['always'],
+      code: 'const test = async () => await 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      options: ['in-try-catch'],
+      output: 'const test = async () => 1;',
+    },
+    {
+      code: 'const test = async () => await Promise.resolve(1);',
+      errors: [
+        {
+          line: 1,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      options: ['in-try-catch'],
+      output: 'const test = async () => Promise.resolve(1);',
+    },
+    {
       code: `
         async function test() {
           return await Promise.resolve(1);
         }
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      options: ['in-try-catch'],
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
     },
     {
-      options: ['always'],
-      code: 'const test = async () => await Promise.resolve(1);',
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      options: ['never'],
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
     },
     {
-      options: ['always'],
       code: `
         async function test() {
           try {
@@ -228,1076 +333,1106 @@ ruleTester.run('return-await', rule, {
           }
         }
       `,
-    },
-    {
-      options: ['always'],
-      code: `
-        declare function foo(): Promise<boolean>;
-
-        function bar(baz: boolean): Promise<boolean> | boolean {
-          if (baz) {
-            return true;
-          } else {
-            return foo();
+      errors: [
+        {
+          line: 4,
+          messageId: 'disallowedPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'disallowedPromiseAwaitSuggestion',
+              output: `
+        async function test() {
+          try {
+            return 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('{}');
+            },
+          ],
+        },
+        {
+          line: 6,
+          messageId: 'disallowedPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'disallowedPromiseAwaitSuggestion',
+              output: `
+        async function test() {
           try {
-            return JSON.parse(res);
-          } catch (error) {
-            return res;
+            return await Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
         }
       `,
+            },
+          ],
+        },
+      ],
+      options: ['never'],
+      output: null,
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8663
     {
       code: `
         async function test() {
-          const res = await Promise.resolve('{}');
-          try {
-            async function nested() {
-              return Promise.resolve('ok');
-            }
-            return await nested();
-          } catch (error) {
-            return Promise.resolve('error');
-          }
+          return await Promise.resolve(1);
         }
       `,
-    },
-    {
-      code: `
-async function f() {
-  try {
-  } catch {
-    try {
-    } catch {
-      return Promise.reject();
-    }
-  }
-}
+      errors: [
+        {
+          line: 3,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      options: ['never'],
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
       `,
     },
     {
       code: `
-async function f() {
-  try {
-  } finally {
-    try {
-    } catch {
-      return Promise.reject();
-    }
-  }
-}
+        async function test() {
+          return await 1;
+        }
       `,
-    },
-    {
-      code: `
-async function f() {
-  try {
-  } finally {
-    try {
-    } finally {
-      try {
-      } catch {
-        return Promise.reject();
-      }
-    }
-  }
-}
+      errors: [
+        {
+          line: 3,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      options: ['always'],
+      output: `
+        async function test() {
+          return 1;
+        }
       `,
     },
     {
       code: `
-declare const bleh: any;
-async function f() {
-  using something = bleh;
-  return await Promise.resolve(2);
-}
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'requiredPromiseAwait',
+        },
+      ],
+      options: ['always'],
+      output: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
       `,
     },
     {
-      code: `
-declare const bleh: any;
-async function f() {
-  await using something = bleh;
-  return await Promise.resolve(2);
-}
-      `,
-    },
-    {
-      code: `
-declare const bleh: any;
-async function f() {
-  using something = bleh;
-  {
-    return await Promise.resolve(2);
-  }
-}
-      `,
-    },
-    {
-      code: `
-declare const bleh: any;
-async function f() {
-  return Promise.resolve(2);
-  using something = bleh;
-}
-      `,
+      code: 'const test = async () => Promise.resolve(1);',
+      errors: [
+        {
+          line: 1,
+          messageId: 'requiredPromiseAwait',
+        },
+      ],
+      options: ['always'],
+      output: 'const test = async () => await Promise.resolve(1);',
     },
     {
-      code: `
-declare const bleh: any;
-async function f() {
-  return await Promise.resolve(2);
-  using something = bleh;
+      code: noFormat`
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo()) ? bar() : baz();
 }
       `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+        },
+      ],
       options: ['always'],
-    },
-    {
-      code: `
-declare function asyncFn(): Promise<unknown>;
-async function returnAwait() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  return await asyncFn();
+      output: `
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo()) ? await bar() : await baz();
 }
       `,
-      options: ['in-try-catch'],
     },
     {
-      code: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  async function innerFunction() {
-    return asyncFn();
-  }
+      code: noFormat`
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo())
+    ? (
+      bar ? bar() : baz()
+    ) : baz ? baz() : bar();
 }
       `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  const innerFunction = async () => asyncFn();
+      errors: [
+        {
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 10,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 10,
+          messageId: 'requiredPromiseAwait',
+        },
+      ],
+      options: ['always'],
+      output: `
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo())
+    ? (
+      bar ? await bar() : await baz()
+    ) : baz ? await baz() : await bar();
 }
       `,
-      options: ['in-try-catch'],
-    },
-    {
-      // intentionally invalid AST - return is outside a function.
-      // We just want to be sure this doesn't crash.
-      code: `
-using foo = 1 as any;
-return Promise.resolve(42);
-      `,
     },
     {
-      // intentionally invalid AST - return is outside a function.
-      // We just want to be sure this doesn't crash.
       code: `
-{
-  using foo = 1 as any;
-  return Promise.resolve(42);
+async function foo() {}
+async function bar() {}
+async function buzz() {
+  return (await foo()) ? await 1 : bar();
 }
       `,
-    },
-  ],
-  invalid: [
-    {
-      code: `
-        async function test() {
-          return await 1;
-        }
-      `,
-      output: `
-        async function test() {
-          return 1;
-        }
-      `,
       errors: [
         {
-          line: 3,
+          line: 5,
           messageId: 'nonPromiseAwait',
         },
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+        },
       ],
+      options: ['always'],
+      output: `
+async function foo() {}
+async function bar() {}
+async function buzz() {
+  return (await foo()) ? 1 : await bar();
+}
+      `,
     },
     {
       code: `
-        async function test() {
-          const foo = 1;
-          return await { foo };
-        }
-      `,
-      output: `
-        async function test() {
-          const foo = 1;
-          return { foo };
-        }
+async function foo() {}
+async function bar() {}
+async function baz() {}
+const buzz = async () => ((await foo()) ? bar() : baz());
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'nonPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
         },
       ],
+      options: ['always'],
+      output: `
+async function foo() {}
+async function bar() {}
+async function baz() {}
+const buzz = async () => ((await foo()) ? await bar() : await baz());
+      `,
     },
     {
       code: `
-        async function test() {
-          const foo = 1;
-          return await foo;
-        }
-      `,
-      output: `
-        async function test() {
-          const foo = 1;
-          return foo;
-        }
+async function foo() {}
+async function bar() {}
+const buzz = async () => ((await foo()) ? await 1 : bar());
       `,
       errors: [
         {
           line: 4,
           messageId: 'nonPromiseAwait',
         },
-      ],
-    },
-    {
-      code: 'const test = async () => await 1;',
-      output: 'const test = async () => 1;',
-      errors: [
         {
-          line: 1,
-          messageId: 'nonPromiseAwait',
+          line: 4,
+          messageId: 'requiredPromiseAwait',
         },
       ],
+      options: ['always'],
+      output: `
+async function foo() {}
+async function bar() {}
+const buzz = async () => ((await foo()) ? 1 : await bar());
+      `,
     },
     {
-      code: 'const test = async () => await /* comment */ 1;',
-      output: 'const test = async () => /* comment */ 1;',
+      // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+      code: `
+async function test<T>(): Promise<T> {
+  const res = await fetch('...');
+  try {
+    return res.json() as Promise<T>;
+  } catch (err) {
+    throw Error('Request Failed.');
+  }
+}
+      `,
       errors: [
         {
-          line: 1,
-          messageId: 'nonPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function test<T>(): Promise<T> {
+  const res = await fetch('...');
+  try {
+    return await (res.json() as Promise<T>);
+  } catch (err) {
+    throw Error('Request Failed.');
+  }
+}
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
       code: `
-const fn = (): any => null;
-async function test() {
-  return await fn();
-}
+        async function test() {
+          try {
+            const callback1 = function () {};
+            const callback2 = async function () {};
+            function callback3() {}
+            async function callback4() {}
+            const callback5 = () => {};
+            const callback6 = async () => {};
+            return Promise.resolve('try');
+          } finally {
+            return Promise.resolve('finally');
+          }
+        }
       `,
-      output: null,
       errors: [
         {
-          line: 4,
-          messageId: 'nonPromiseAwait',
+          line: 10,
+          messageId: 'requiredPromiseAwait',
           suggestions: [
             {
-              messageId: 'nonPromiseAwait',
+              messageId: 'requiredPromiseAwaitSuggestion',
               output: `
-const fn = (): any => null;
-async function test() {
-  return fn();
-}
+        async function test() {
+          try {
+            const callback1 = function () {};
+            const callback2 = async function () {};
+            function callback3() {}
+            async function callback4() {}
+            const callback5 = () => {};
+            const callback6 = async () => {};
+            return await Promise.resolve('try');
+          } finally {
+            return Promise.resolve('finally');
+          }
+        }
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
       code: `
-const fn = (): unknown => null;
-async function test() {
-  return await fn();
-}
+        async function bar() {}
+        async function foo() {
+          try {
+            return undefined || bar();
+          } catch {}
+        }
       `,
-      output: null,
       errors: [
         {
-          line: 4,
-          messageId: 'nonPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
           suggestions: [
             {
-              messageId: 'nonPromiseAwait',
+              messageId: 'requiredPromiseAwaitSuggestion',
               output: `
-const fn = (): unknown => null;
-async function test() {
-  return fn();
-}
+        async function bar() {}
+        async function foo() {
+          try {
+            return await (undefined || bar());
+          } catch {}
+        }
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
-      code: 'const test = async () => await Promise.resolve(1);',
-      output: 'const test = async () => Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-    },
-
-    ...['error-handling-correctness-only', 'always', 'in-try-catch'].map(
-      option =>
-        ({
-          code: `
-        async function test() {
-          try {
-            return Promise.resolve(1);
-          } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
-        }
-      `,
-          output: null,
-          errors: [
-            {
-              line: 4,
-              messageId: 'requiredPromiseAwait',
-              suggestions: [
-                {
-                  messageId: 'requiredPromiseAwaitSuggestion',
-                  output: `
-        async function test() {
+      code: `
+        async function bar() {}
+        async function foo() {
           try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
+            return bar() || undefined || bar();
+          } catch {}
         }
       `,
-                },
-              ],
-            },
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
             {
-              line: 6,
-              messageId: 'requiredPromiseAwait',
-              suggestions: [
-                {
-                  messageId: 'requiredPromiseAwaitSuggestion',
-                  output: `
-        async function test() {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+        async function bar() {}
+        async function foo() {
           try {
-            return Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
+            return await (bar() || undefined || bar());
+          } catch {}
         }
       `,
-                },
-              ],
             },
           ],
-          options: [option],
-        }) satisfies InvalidTestCase<
-          'requiredPromiseAwait' | 'requiredPromiseAwaitSuggestion',
-          [string]
-        >,
-    ),
-
+        },
+      ],
+      output: null,
+    },
     {
       code: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      output: `
-        async function test() {
-          return Promise.resolve(1);
-        }
+async function bar() {}
+async function func1() {
+  try {
+    return null ?? bar();
+  } catch {}
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function bar() {}
+async function func1() {
+  try {
+    return await (null ?? bar());
+  } catch {}
+}
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
-      options: ['in-try-catch'],
       code: `
-        async function test() {
-          return await 1;
-        }
-      `,
-      output: `
-        async function test() {
-          return 1;
-        }
+async function bar() {}
+async function func2() {
+  try {
+    return 1 && bar();
+  } catch {}
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'nonPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function bar() {}
+async function func2() {
+  try {
+    return await (1 && bar());
+  } catch {}
+}
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
-      options: ['in-try-catch'],
-      code: 'const test = async () => await 1;',
-      output: 'const test = async () => 1;',
+      code: `
+const foo = {
+  bar: async function () {},
+};
+async function func3() {
+  try {
+    return foo.bar();
+  } catch {}
+}
+      `,
       errors: [
         {
-          line: 1,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-    },
-    {
-      options: ['in-try-catch'],
-      code: 'const test = async () => await Promise.resolve(1);',
-      output: 'const test = async () => Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'disallowedPromiseAwait',
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+const foo = {
+  bar: async function () {},
+};
+async function func3() {
+  try {
+    return await foo.bar();
+  } catch {}
+}
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
-      options: ['in-try-catch'],
       code: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      output: `
-        async function test() {
-          return Promise.resolve(1);
+        class X {
+          async bar() {
+            return;
+          }
+          async func2() {
+            try {
+              return this.bar();
+            } catch {}
+          }
         }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
+          line: 8,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+        class X {
+          async bar() {
+            return;
+          }
+          async func2() {
+            try {
+              return await this.bar();
+            } catch {}
+          }
+        }
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
-      options: ['never'],
       code: `
         async function test() {
-          return await 1;
-        }
-      `,
-      output: `
-        async function test() {
-          return 1;
+          const res = await Promise.resolve('{}');
+          try {
+            async function nested() {
+              return Promise.resolve('ok');
+            }
+            return await nested();
+          } catch (error) {
+            return await Promise.resolve('error');
+          }
         }
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'nonPromiseAwait',
+          line: 10,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
-    },
-    {
-      options: ['never'],
-      code: `
+      output: `
         async function test() {
+          const res = await Promise.resolve('{}');
           try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
+            async function nested() {
+              return Promise.resolve('ok');
+            }
+            return await nested();
+          } catch (error) {
+            return Promise.resolve('error');
           }
         }
       `,
-      output: null,
+    },
+    {
+      code: `
+async function f() {
+  try {
+    try {
+    } finally {
+      // affects error handling of outer catch
+      return Promise.reject();
+    }
+  } catch {}
+}
+      `,
       errors: [
         {
-          line: 4,
-          messageId: 'disallowedPromiseAwait',
+          line: 7,
+          messageId: 'requiredPromiseAwait',
           suggestions: [
             {
-              messageId: 'disallowedPromiseAwaitSuggestion',
+              messageId: 'requiredPromiseAwaitSuggestion',
               output: `
-        async function test() {
-          try {
-            return Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
-        }
+async function f() {
+  try {
+    try {
+    } finally {
+      // affects error handling of outer catch
+      return await Promise.reject();
+    }
+  } catch {}
+}
       `,
             },
           ],
         },
+      ],
+      output: null,
+    },
+    {
+      code: `
+async function f() {
+  try {
+    try {
+    } catch {
+      // affects error handling of outer catch
+      return Promise.reject();
+    }
+  } catch {}
+}
+      `,
+      errors: [
         {
-          line: 6,
-          messageId: 'disallowedPromiseAwait',
+          line: 7,
+          messageId: 'requiredPromiseAwait',
           suggestions: [
             {
-              messageId: 'disallowedPromiseAwaitSuggestion',
+              messageId: 'requiredPromiseAwaitSuggestion',
               output: `
-        async function test() {
-          try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
-        }
+async function f() {
+  try {
+    try {
+    } catch {
+      // affects error handling of outer catch
+      return await Promise.reject();
+    }
+  } catch {}
+}
       `,
             },
           ],
         },
       ],
+      output: null,
     },
     {
-      options: ['never'],
       code: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      output: `
-        async function test() {
-          return Promise.resolve(1);
-        }
+async function f() {
+  try {
+  } catch {
+    try {
+    } finally {
+      try {
+      } catch {
+        return Promise.reject();
+      }
+    }
+  } finally {
+  }
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function f() {
+  try {
+  } catch {
+    try {
+    } finally {
+      try {
+      } catch {
+        return await Promise.reject();
+      }
+    }
+  } finally {
+  }
+}
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
-      options: ['always'],
       code: `
-        async function test() {
-          return await 1;
-        }
-      `,
-      output: `
-        async function test() {
-          return 1;
-        }
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    using something = bleh;
+    if (anotherCondition) {
+      return Promise.resolve(2);
+    }
+  }
+}
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-    },
-    {
-      options: ['always'],
-      code: `
-        async function test() {
-          return Promise.resolve(1);
-        }
-      `,
-      output: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      errors: [
-        {
-          line: 3,
+          line: 7,
           messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    using something = bleh;
+    if (anotherCondition) {
+      return await Promise.resolve(2);
+    }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
-    },
-    {
       options: ['always'],
-      code: 'const test = async () => Promise.resolve(1);',
-      output: 'const test = async () => await Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
+      output: null,
     },
     {
-      options: ['always'],
-      code: noFormat`
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo()) ? bar() : baz();
-}
-      `,
-      output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo()) ? await bar() : await baz();
+      code: `
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    await using something = bleh;
+    if (anotherCondition) {
+      return Promise.resolve(2);
+    }
+  }
 }
       `,
       errors: [
         {
           line: 7,
           messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    await using something = bleh;
+    if (anotherCondition) {
+      return await Promise.resolve(2);
+    }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
+      options: ['always'],
+      output: null,
     },
     {
-      options: ['always'],
-      code: noFormat`
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo())
-    ? (
-      bar ? bar() : baz()
-    ) : baz ? baz() : bar();
-}
-      `,
-      output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo())
-    ? (
-      bar ? await bar() : await baz()
-    ) : baz ? await baz() : await bar();
+      code: `
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    using something = bleh;
+  } else if (anotherCondition) {
+    return Promise.resolve(2);
+  }
 }
       `,
       errors: [
         {
-          line: 9,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 9,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 10,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 10,
+          line: 7,
           messageId: 'requiredPromiseAwait',
         },
       ],
-    },
-    {
       options: ['always'],
-      code: `
-async function foo() {}
-async function bar() {}
-async function buzz() {
-  return (await foo()) ? await 1 : bar();
-}
-      `,
       output: `
-async function foo() {}
-async function bar() {}
-async function buzz() {
-  return (await foo()) ? 1 : await bar();
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    using something = bleh;
+  } else if (anotherCondition) {
+    return await Promise.resolve(2);
+  }
 }
       `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'nonPromiseAwait',
-        },
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
     },
     {
-      options: ['always'],
       code: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-const buzz = async () => ((await foo()) ? bar() : baz());
-      `,
-      output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-const buzz = async () => ((await foo()) ? await bar() : await baz());
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  async function innerFunction() {
+    return await asyncFn();
+  }
+}
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
+          line: 11,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
+      options: ['in-try-catch'],
+      output: `
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  async function innerFunction() {
+    return asyncFn();
+  }
+}
+      `,
     },
     {
-      options: ['always'],
       code: `
-async function foo() {}
-async function bar() {}
-const buzz = async () => ((await foo()) ? await 1 : bar());
-      `,
-      output: `
-async function foo() {}
-async function bar() {}
-const buzz = async () => ((await foo()) ? 1 : await bar());
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  const innerFunction = async () => await asyncFn();
+}
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'nonPromiseAwait',
-        },
-        {
-          line: 4,
-          messageId: 'requiredPromiseAwait',
+          line: 10,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
+      options: ['in-try-catch'],
+      output: `
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
     },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-      code: `
-async function test<T>(): Promise<T> {
-  const res = await fetch('...');
-  try {
-    return res.json() as Promise<T>;
-  } catch (err) {
-    throw Error('Request Failed.');
-  }
+  };
+
+  const innerFunction = async () => asyncFn();
 }
       `,
-      output: null,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function test<T>(): Promise<T> {
-  const res = await fetch('...');
-  try {
-    return await (res.json() as Promise<T>);
-  } catch (err) {
-    throw Error('Request Failed.');
-  }
-}
-      `,
-            },
-          ],
-        },
-      ],
     },
+  ],
+  valid: [
+    'return;', // No function in scope, so behave like return in a commonjs module
+    `
+      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');
+        }
+      }
+    `,
     {
       code: `
         async function test() {
+          if (Math.random() < 0.33) {
+            return await Promise.resolve(1);
+          } else if (Math.random() < 0.5) {
+            return Promise.resolve(2);
+          }
+
           try {
-            const callback1 = function () {};
-            const callback2 = async function () {};
-            function callback3() {}
-            async function callback4() {}
-            const callback5 = () => {};
-            const callback6 = async () => {};
-            return Promise.resolve('try');
+          } catch (e) {
+            return await Promise.resolve(3);
           } finally {
-            return Promise.resolve('finally');
+            console.log('cleanup');
           }
         }
       `,
-      output: null,
-      errors: [
-        {
-          line: 10,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
+      options: ['error-handling-correctness-only'],
+    },
+    `
+      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: `
+        function test() {
+          return 1;
+        }
+      `,
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
         async function test() {
-          try {
-            const callback1 = function () {};
-            const callback2 = async function () {};
-            function callback3() {}
-            async function callback4() {}
-            const callback5 = () => {};
-            const callback6 = async () => {};
-            return await Promise.resolve('try');
-          } finally {
-            return Promise.resolve('finally');
-          }
+          return 1;
         }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['in-try-catch'],
+    },
+    {
+      code: 'const test = () => 1;',
+      options: ['in-try-catch'],
+    },
+    {
+      code: 'const test = async () => 1;',
+      options: ['in-try-catch'],
     },
     {
       code: `
-        async function bar() {}
-        async function foo() {
-          try {
-            return undefined || bar();
-          } catch {}
+        async function test() {
+          return Promise.resolve(1);
         }
       `,
-      output: null,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-        async function bar() {}
-        async function foo() {
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
+        async function test() {
           try {
-            return await (undefined || bar());
-          } catch {}
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['in-try-catch'],
     },
     {
       code: `
-        async function bar() {}
-        async function foo() {
+        async function test() {
           try {
-            return bar() || undefined || bar();
-          } catch {}
+            throw 'foo';
+          } catch (e) {
+            return Promise.resolve(1);
+          }
         }
       `,
-      output: null,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-        async function bar() {}
-        async function foo() {
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
+        async function test() {
           try {
-            return await (bar() || undefined || bar());
-          } catch {}
+            throw 'foo';
+          } catch (e) {
+            throw 'foo2';
+          } finally {
+            return Promise.resolve(1);
+          }
         }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['in-try-catch'],
     },
     {
       code: `
-async function bar() {}
-async function func1() {
-  try {
-    return null ?? bar();
-  } catch {}
-}
-      `,
-      output: null,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function bar() {}
-async function func1() {
-  try {
-    return await (null ?? bar());
-  } catch {}
-}
+        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: `
-async function bar() {}
-async function func2() {
-  try {
-    return 1 && bar();
-  } catch {}
-}
-      `,
-      output: null,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function bar() {}
-async function func2() {
-  try {
-    return await (1 && bar());
-  } catch {}
-}
+        async function test() {
+          return Promise.resolve(1);
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['never'],
+    },
+    {
+      code: 'const test = async () => Promise.resolve(1);',
+      options: ['never'],
     },
     {
       code: `
-const foo = {
-  bar: async function () {},
-};
-async function func3() {
-  try {
-    return foo.bar();
-  } catch {}
-}
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
+        }
       `,
-      output: null,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-const foo = {
-  bar: async function () {},
-};
-async function func3() {
-  try {
-    return await foo.bar();
-  } catch {}
-}
+      options: ['never'],
+    },
+    {
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['always'],
+    },
+    {
+      code: 'const test = async () => await Promise.resolve(1);',
+      options: ['always'],
     },
     {
       code: `
-        class X {
-          async bar() {
-            return;
-          }
-          async func2() {
-            try {
-              return this.bar();
-            } catch {}
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
         }
       `,
-      output: null,
-      errors: [
-        {
-          line: 8,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-        class X {
-          async bar() {
-            return;
-          }
-          async func2() {
-            try {
-              return await this.bar();
-            } catch {}
+      options: ['always'],
+    },
+    {
+      code: `
+        declare function foo(): Promise<boolean>;
+
+        function bar(baz: boolean): Promise<boolean> | boolean {
+          if (baz) {
+            return true;
+          } else {
+            return foo();
           }
         }
       `,
-            },
-          ],
-        },
-      ],
+      options: ['always'],
     },
     {
       code: `
-        async function test() {
+        async function test(): Promise<string> {
           const res = await Promise.resolve('{}');
           try {
-            async function nested() {
-              return Promise.resolve('ok');
-            }
-            return await nested();
+            return JSON.parse(res);
           } catch (error) {
-            return await Promise.resolve('error');
+            return res;
           }
         }
       `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      output: `
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8663
+    {
+      code: `
         async function test() {
           const res = await Promise.resolve('{}');
           try {
@@ -1315,238 +1450,109 @@ async function func3() {
       code: `
 async function f() {
   try {
+  } catch {
     try {
-    } finally {
-      // affects error handling of outer catch
+    } catch {
       return Promise.reject();
     }
-  } catch {}
-}
-      `,
-      output: null,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-    try {
-    } finally {
-      // affects error handling of outer catch
-      return await Promise.reject();
-    }
-  } catch {}
+  }
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
 async function f() {
   try {
+  } finally {
     try {
     } catch {
-      // affects error handling of outer catch
       return Promise.reject();
     }
-  } catch {}
-}
-      `,
-      output: null,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-    try {
-    } catch {
-      // affects error handling of outer catch
-      return await Promise.reject();
-    }
-  } catch {}
+  }
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
 async function f() {
   try {
-  } catch {
-    try {
-    } finally {
-      try {
-      } catch {
-        return Promise.reject();
-      }
-    }
   } finally {
-  }
-}
-      `,
-      output: null,
-      errors: [
-        {
-          line: 9,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-  } catch {
     try {
     } finally {
       try {
       } catch {
-        return await Promise.reject();
+        return Promise.reject();
       }
     }
-  } finally {
   }
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  if (cond) {
-    using something = bleh;
-    if (anotherCondition) {
-      return Promise.resolve(2);
-    }
-  }
+  using something = bleh;
+  return await Promise.resolve(2);
 }
       `,
-      options: ['always'],
-      output: null,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
+    },
+    {
+      code: `
 declare const bleh: any;
 async function f() {
-  if (cond) {
-    using something = bleh;
-    if (anotherCondition) {
-      return await Promise.resolve(2);
-    }
-  }
+  await using something = bleh;
+  return await Promise.resolve(2);
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  if (cond) {
-    await using something = bleh;
-    if (anotherCondition) {
-      return Promise.resolve(2);
-    }
+  using something = bleh;
+  {
+    return await Promise.resolve(2);
   }
 }
       `,
-      options: ['always'],
-      output: null,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
+    },
+    {
+      code: `
 declare const bleh: any;
 async function f() {
-  if (cond) {
-    await using something = bleh;
-    if (anotherCondition) {
-      return await Promise.resolve(2);
-    }
-  }
+  return Promise.resolve(2);
+  using something = bleh;
 }
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  if (cond) {
-    using something = bleh;
-  } else if (anotherCondition) {
-    return Promise.resolve(2);
-  }
+  return await Promise.resolve(2);
+  using something = bleh;
 }
       `,
       options: ['always'],
-      output: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    using something = bleh;
-  } else if (anotherCondition) {
-    return await Promise.resolve(2);
-  }
-}
-      `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
     },
     {
       code: `
 declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
+async function returnAwait() {
   using _ = {
     [Symbol.dispose]: () => {
       console.log('dispose');
     },
   };
 
-  async function innerFunction() {
-    return await asyncFn();
-  }
+  return await asyncFn();
 }
       `,
       options: ['in-try-catch'],
-      output: `
+    },
+    {
+      code: `
 declare function asyncFn(): Promise<unknown>;
 async function outerFunction() {
   using _ = {
@@ -1560,12 +1566,7 @@ async function outerFunction() {
   }
 }
       `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
+      options: ['in-try-catch'],
     },
     {
       code: `
@@ -1577,28 +1578,28 @@ async function outerFunction() {
     },
   };
 
-  const innerFunction = async () => await asyncFn();
+  const innerFunction = async () => asyncFn();
 }
       `,
       options: ['in-try-catch'],
-      output: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
     },
-  };
-
-  const innerFunction = async () => asyncFn();
+    {
+      // intentionally invalid AST - return is outside a function.
+      // We just want to be sure this doesn't crash.
+      code: `
+using foo = 1 as any;
+return Promise.resolve(42);
+      `,
+    },
+    {
+      // intentionally invalid AST - return is outside a function.
+      // We just want to be sure this doesn't crash.
+      code: `
+{
+  using foo = 1 as any;
+  return Promise.resolve(42);
 }
       `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
index ef03e4a900c5..3fc5d7491a7b 100644
--- a/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
@@ -2,12 +2,14 @@ import type {
   InvalidTestCase,
   ValidTestCase,
 } from '@typescript-eslint/rule-tester';
+
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import type {
   MessageIds,
   Options,
 } from '../../src/rules/sort-type-constituents';
+
 import rule from '../../src/rules/sort-type-constituents';
 
 const ruleTester = new RuleTester();
@@ -93,118 +95,118 @@ const invalid = (
   return [
     {
       code: `type T = B ${operator} A;`,
-      output: `type T = A ${operator} B;`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = A ${operator} B;`,
     },
     {
       code: `type T = 'B' ${operator} 'A';`,
-      output: `type T = 'A' ${operator} 'B';`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = 'A' ${operator} 'B';`,
     },
     {
       code: `type T = 2 ${operator} 1;`,
-      output: `type T = 1 ${operator} 2;`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = 1 ${operator} 2;`,
     },
     {
       code: noFormat`type T = (B) ${operator} (A);`,
-      output: `type T = A ${operator} B;`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = A ${operator} B;`,
     },
     {
       code: `type T = { b: string } ${operator} { a: string };`,
-      output: `type T = { a: string } ${operator} { b: string };`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = { a: string } ${operator} { b: string };`,
     },
     {
       code: `type T = [1, 2, 4] ${operator} [1, 2, 3];`,
-      output: `type T = [1, 2, 3] ${operator} [1, 2, 4];`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = [1, 2, 3] ${operator} [1, 2, 4];`,
     },
     {
       code: `type T = (() => void) ${operator} (() => string);`,
-      output: `type T = (() => string) ${operator} (() => void);`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = (() => string) ${operator} (() => void);`,
     },
     {
       code: `type T = () => void ${operator} string;`,
-      output: `type T = () => string ${operator} void;`,
       errors: [
         {
-          messageId: 'notSorted',
           data: {
             type,
           },
+          messageId: 'notSorted',
         },
       ],
+      output: `type T = () => string ${operator} void;`,
     },
     {
       code: `type T = () => undefined ${operator} null;`,
-      output: `type T = () => null ${operator} undefined;`,
       errors: [
         {
-          messageId: 'notSorted',
           data: {
             type,
           },
+          messageId: 'notSorted',
         },
       ],
+      output: `type T = () => null ${operator} undefined;`,
     },
     {
       code: noFormat`
@@ -231,31 +233,30 @@ type T =
   ${operator} null
   ${operator} string
   ${operator} any;
-      `,
-      output: `
-type T =
-  A ${operator} B ${operator} C.D ${operator} D.E ${operator} number[] ${operator} string[] ${operator} any ${operator} string ${operator} readonly number[] ${operator} readonly string[] ${operator} 'a' ${operator} 'b' ${operator} "a" ${operator} "b" ${operator} (() => string) ${operator} (() => void) ${operator} { a: string } ${operator} { b: string } ${operator} [1, 2, 3] ${operator} [1, 2, 4] ${operator} null ${operator} undefined;
       `,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `
+type T =
+  A ${operator} B ${operator} C.D ${operator} D.E ${operator} number[] ${operator} string[] ${operator} any ${operator} string ${operator} readonly number[] ${operator} readonly string[] ${operator} 'a' ${operator} 'b' ${operator} "a" ${operator} "b" ${operator} (() => string) ${operator} (() => void) ${operator} { a: string } ${operator} { b: string } ${operator} [1, 2, 3] ${operator} [1, 2, 4] ${operator} null ${operator} undefined;
+      `,
     },
     {
       code: `type T = B ${operator} /* comment */ A;`,
-      output: null,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
           suggestions: [
             {
               messageId: 'suggestFix',
@@ -264,60 +265,127 @@ type T =
           ],
         },
       ],
+      output: null,
     },
     {
       code: `type T = (() => /* comment */ A) ${operator} B;`,
-      output: `type T = B ${operator} (() => /* comment */ A);`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
           suggestions: null,
         },
       ],
+      output: `type T = B ${operator} (() => /* comment */ A);`,
     },
     {
       code: `type Expected = (new (x: number) => boolean) ${operator} string;`,
-      output: `type Expected = string ${operator} (new (x: number) => boolean);`,
       errors: [
         {
           messageId: 'notSortedNamed',
         },
       ],
+      output: `type Expected = string ${operator} (new (x: number) => boolean);`,
     },
     {
       code: `type T = (| A) ${operator} B;`,
-      output: `type T = B ${operator} (| A);`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = B ${operator} (| A);`,
     },
     {
       code: `type T = (& A) ${operator} B;`,
-      output: `type T = B ${operator} (& A);`,
       errors: [
         {
-          messageId: 'notSortedNamed',
           data: {
-            type,
             name: 'T',
+            type,
           },
+          messageId: 'notSortedNamed',
         },
       ],
+      output: `type T = B ${operator} (& A);`,
     },
   ];
 };
 
 ruleTester.run('sort-type-constituents', rule, {
+  invalid: [
+    ...invalid('|'),
+    ...invalid('&'),
+    {
+      code: 'type T = (B | C) & A;',
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Intersection',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      output: `type T = A & (B | C);`,
+    },
+    {
+      code: "type A<T> = (T extends number ? 'hi' : 'there') | string;",
+      errors: [
+        {
+          data: {
+            name: 'A',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      output: "type A<T> = string | (T extends number ? 'hi' : 'there');",
+    },
+    {
+      code: "type T = 'DeletedAt' | 'DeleteForever';",
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      options: [
+        {
+          caseSensitive: true,
+        },
+      ],
+      output: "type T = 'DeleteForever' | 'DeletedAt';",
+    },
+    {
+      code: 'type T = { a: string } | { A: string } | { B: string };',
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      options: [
+        {
+          caseSensitive: true,
+        },
+      ],
+      output: 'type T = { A: string } | { B: string } | { a: string };',
+    },
+  ],
   valid: [
     ...valid('|'),
     {
@@ -386,70 +454,4 @@ type T = 1 | string | {} | A;
     },
     "type A<T> = string | (T extends number ? 'hi' : 'there');",
   ],
-  invalid: [
-    ...invalid('|'),
-    ...invalid('&'),
-    {
-      code: 'type T = (B | C) & A;',
-      output: `type T = A & (B | C);`,
-      errors: [
-        {
-          messageId: 'notSortedNamed',
-          data: {
-            type: 'Intersection',
-            name: 'T',
-          },
-        },
-      ],
-    },
-    {
-      output: "type A<T> = string | (T extends number ? 'hi' : 'there');",
-      code: "type A<T> = (T extends number ? 'hi' : 'there') | string;",
-      errors: [
-        {
-          messageId: 'notSortedNamed',
-          data: {
-            type: 'Union',
-            name: 'A',
-          },
-        },
-      ],
-    },
-    {
-      code: "type T = 'DeletedAt' | 'DeleteForever';",
-      output: "type T = 'DeleteForever' | 'DeletedAt';",
-      errors: [
-        {
-          messageId: 'notSortedNamed',
-          data: {
-            type: 'Union',
-            name: 'T',
-          },
-        },
-      ],
-      options: [
-        {
-          caseSensitive: true,
-        },
-      ],
-    },
-    {
-      code: 'type T = { a: string } | { A: string } | { B: string };',
-      output: 'type T = { A: string } | { B: string } | { a: string };',
-      errors: [
-        {
-          messageId: 'notSortedNamed',
-          data: {
-            type: 'Union',
-            name: 'T',
-          },
-        },
-      ],
-      options: [
-        {
-          caseSensitive: true,
-        },
-      ],
-    },
-  ],
 });
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 601a74ee88c2..51d1369cf12f 100644
--- a/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
@@ -1,13 +1,13 @@
 /* eslint-disable deprecation/deprecation -- TODO - migrate this test away from `batchedSingleLineTests` */
 
-import * as path from 'node:path';
-
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
+import * as path from 'node:path';
 
 import type {
   MessageId,
   Options,
 } from '../../src/rules/strict-boolean-expressions';
+
 import rule from '../../src/rules/strict-boolean-expressions';
 import { batchedSingleLineTests, getFixturesRootDir } from '../RuleTester';
 
@@ -15,2807 +15,2814 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('strict-boolean-expressions', rule, {
-  valid: [
-    // boolean in boolean context
-    "true ? 'a' : 'b';",
-    `
-if (false) {
-}
-    `,
-    'while (true) {}',
-    'for (; false; ) {}',
-    '!true;',
-    'false || 123;',
-    "true && 'foo';",
-    '!(false || true);',
-    'true && false ? true : false;',
-    '(false && true) || false;',
-    '(false && true) || [];',
-    '(false && 1) || (true && 2);',
-    `
-declare const x: boolean;
-if (x) {
-}
-    `,
-    '(x: boolean) => !x;',
-    '<T extends boolean>(x: T) => (x ? 1 : 0);',
-    `
-declare const x: never;
-if (x) {
-}
-    `,
-
-    // string in boolean context
-    `
-if ('') {
-}
-    `,
-    "while ('x') {}",
-    "for (; ''; ) {}",
-    "('' && '1') || x;",
-    `
-declare const x: string;
-if (x) {
-}
-    `,
-    '(x: string) => !x;',
-    '<T extends string>(x: T) => (x ? 1 : 0);',
-
-    // number in boolean context
-    `
-if (0) {
-}
-    `,
-    'while (1n) {}',
-    'for (; Infinity; ) {}',
-    '(0 / 0 && 1 + 2) || x;',
-    `
-declare const x: number;
-if (x) {
-}
-    `,
-    '(x: bigint) => !x;',
-    '<T extends number>(x: T) => (x ? 1 : 0);',
-
-    // nullable object in boolean context
-    `
-declare const x: null | object;
-if (x) {
-}
-    `,
-    '(x?: { a: any }) => !x;',
-    '<T extends {} | null | undefined>(x: T) => (x ? 1 : 0);',
-
-    // nullable boolean in boolean context
-    {
-      options: [{ allowNullableBoolean: true }],
-      code: `
-        declare const x: boolean | null;
-        if (x) {
-        }
-      `,
-    },
-    {
-      options: [{ allowNullableBoolean: true }],
-      code: `
-        (x?: boolean) => !x;
-      `,
-    },
-    {
-      options: [{ allowNullableBoolean: true }],
-      code: `
-        <T extends boolean | null | undefined>(x: T) => (x ? 1 : 0);
+  invalid: [
+    // non-boolean in RHS of test expression
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        if (true && (1 + 1)) {}
+        while (false || "a" + "b") {}
+        (x: object) => true || false || x ? true : false;
       `,
-    },
+      errors: [
+        {
+          column: 14,
+          line: 2,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: 'if (true && ((1 + 1) !== 0)) {}',
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: 'if (true && (!Number.isNaN((1 + 1)))) {}',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: 'if (true && (Boolean((1 + 1)))) {}',
+            },
+          ],
+        },
+        {
+          column: 25,
+          line: 3,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: '        while (false || (("a" + "b").length > 0)) {}',
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: '        while (false || (("a" + "b") !== "")) {}',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: '        while (false || (Boolean(("a" + "b")))) {}',
+            },
+          ],
+        },
+        { column: 41, line: 4, messageId: 'conditionErrorObject' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+    }),
 
-    // nullable string in boolean context
-    {
-      options: [{ allowNullableString: true }],
-      code: `
-        declare const x: string | null;
-        if (x) {
-        }
-      `,
-    },
+    // check if all and only the outermost operands are checked
     {
-      options: [{ allowNullableString: true }],
-      code: `
-        (x?: string) => !x;
-      `,
+      code: noFormat`if (('' && {}) || (0 && void 0)) { }`,
+      errors: [
+        {
+          column: 6,
+          line: 1,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `if (((''.length > 0) && {}) || (0 && void 0)) { }`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `if ((('' !== "") && {}) || (0 && void 0)) { }`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `if (((Boolean('')) && {}) || (0 && void 0)) { }`,
+            },
+          ],
+        },
+        { column: 12, line: 1, messageId: 'conditionErrorObject' },
+        {
+          column: 20,
+          line: 1,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `if (('' && {}) || ((0 !== 0) && void 0)) { }`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `if (('' && {}) || ((!Number.isNaN(0)) && void 0)) { }`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `if (('' && {}) || ((Boolean(0)) && void 0)) { }`,
+            },
+          ],
+        },
+        { column: 25, line: 1, messageId: 'conditionErrorNullish' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+      output: null,
     },
     {
-      options: [{ allowNullableString: true }],
-      code: `
-        <T extends string | null | undefined>(x: T) => (x ? 1 : 0);
+      code: noFormat`
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || (0 && void 0)) { }
       `,
-    },
-
-    // nullable number in boolean context
-    {
-      options: [{ allowNullableNumber: true }],
-      code: `
-        declare const x: number | null;
-        if (x) {
-        }
+      errors: [
+        {
+          column: 6,
+          line: 3,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (((''.length > 0) && foo) || (0 && void 0)) { }
       `,
-    },
-    {
-      options: [{ allowNullableNumber: true }],
-      code: `
-        (x?: number) => !x;
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if ((('' !== "") && foo) || (0 && void 0)) { }
       `,
-    },
-    {
-      options: [{ allowNullableNumber: true }],
-      code: `
-        <T extends number | null | undefined>(x: T) => (x ? 1 : 0);
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (((Boolean('')) && foo) || (0 && void 0)) { }
       `,
-    },
-
-    // any in boolean context
-    {
-      options: [{ allowAny: true }],
-      code: `
-        declare const x: any;
-        if (x) {
-        }
-      `,
-    },
-    {
-      options: [{ allowAny: true }],
-      code: `
-        x => !x;
-      `,
-    },
-    {
-      options: [{ allowAny: true }],
-      code: `
-        <T extends any>(x: T) => (x ? 1 : 0);
-      `,
-    },
-
-    // logical operator
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        1 && true && 'x' && {};
-      `,
-    },
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        let x = 0 || false || '' || null;
-      `,
-    },
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        if (1 && true && 'x') void 0;
-      `,
-    },
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        if (0 || false || '') void 0;
-      `,
-    },
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        1 && true && 'x' ? {} : null;
-      `,
-    },
-    {
-      options: [{ allowString: true, allowNumber: true }],
-      code: `
-        0 || false || '' ? null : {};
-      `,
-    },
-
-    // nullable enum in boolean context
-    {
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (theEnum) {
-        }
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-
-    // nullable mixed enum in boolean context
-    {
-      // falsy number and truthy string
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => (value ? 1 : 0);
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      // falsy string and truthy number
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      // truthy string and truthy number
-      code: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      // falsy string and falsy number
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      options: [{ allowNullableEnum: true }],
-    },
-
-    {
-      code: `
-declare const x: string[] | null;
-// eslint-disable-next-line
-if (x) {
-}
-      `,
-      options: [
-        {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
-    },
-
-    `
-function f(arg: 'a' | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-function f(arg: 'a' | 'b' | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    {
-      code: `
-declare const x: 1 | null;
-declare const y: 1;
-if (x) {
-}
-if (y) {
-}
-      `,
-      options: [
-        {
-          allowNumber: true,
-        },
-      ],
-    },
-    `
-function f(arg: 1 | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-function f(arg: 1 | 2 | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-interface Options {
-  readonly enableSomething?: true;
-}
-
-function f(opts: Options): void {
-  if (opts.enableSomething) console.log('Do something');
-}
-    `,
-    `
-declare const x: true | null;
-if (x) {
-}
-    `,
-    {
-      code: `
-declare const x: 'a' | null;
-declare const y: 'a';
-if (x) {
-}
-if (y) {
-}
-      `,
-      options: [
-        {
-          allowString: true,
+            },
+          ],
         },
-      ],
-    },
-    `
-declare const foo: boolean & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare const foo: true & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare const foo: false & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts a;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    `
-declare function assert(a: boolean, b: unknown): asserts b is string;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    // Intentional TS error - cannot assert a parameter in a binding pattern.
-    `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert(a: boolean, { b }: { b: unknown }): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(nullableString, boo);
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(...nullableString, nullableString);
-    `,
-    `
-declare function assert(
-  this: object,
-  a: number,
-  b?: unknown,
-  c?: unknown,
-): asserts c;
-declare const nullableString: string | null;
-declare const foo: number;
-const o: { assert: typeof assert } = {
-  assert,
-};
-o.assert(foo, nullableString);
-    `,
-    {
-      code: `
-declare function assert(x: unknown): x is string;
-declare const nullableString: string | null;
-assert(nullableString);
-      `,
-    },
-    {
-      code: `
-class ThisAsserter {
-  assertThis(this: unknown, arg2: unknown): asserts this {}
-}
-
-declare const lol: string | number | unknown | null;
-
-const thisAsserter: ThisAsserter = new ThisAsserter();
-thisAsserter.assertThis(lol);
-      `,
-    },
-    {
-      code: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(...args: any[]): void;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString);
-      `,
-    },
-    // Intentional TS error - A rest parameter must be last in a parameter list.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(...a: boolean[], b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    // Intentional TS error - A type predicate cannot reference a rest parameter.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(a: boolean, ...b: unknown[]): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    // Intentional TS error - An assertion function must have a parameter to assert.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(): asserts x;
-declare const nullableString: string | null;
-assert(nullableString);
-    `,
-    `
-function assert(one: unknown): asserts one;
-function assert(one: unknown, two: unknown): asserts two;
-function assert(...args: unknown[]) {
-  throw new Error('not implemented');
-}
-declare const nullableString: string | null;
-assert(nullableString);
-assert('one', nullableString);
-    `,
-    // Intentional use of `any` to test a function call with no call signatures.
-    `
-declare const assert: any;
-declare const nullableString: string | null;
-assert(nullableString);
-    `,
-    // Coverage for absent "test expression".
-    // Ensure that no crash or false positive occurs
-    `
-      for (let x = 0; ; x++) {
-        break;
-      }
-    `,
-  ],
-
-  invalid: [
-    // non-boolean in RHS of test expression
-    ...batchedSingleLineTests<MessageId, Options>({
-      options: [
-        { allowString: false, allowNumber: false, allowNullableObject: false },
-      ],
-      code: noFormat`
-        if (true && (1 + 1)) {}
-        while (false || "a" + "b") {}
-        (x: object) => true || false || x ? true : false;
-      `,
-      errors: [
         {
+          column: 21,
+          line: 3,
           messageId: 'conditionErrorNumber',
-          line: 2,
-          column: 14,
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: 'if (true && ((1 + 1) !== 0)) {}',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((0 !== 0) && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: 'if (true && (!Number.isNaN((1 + 1)))) {}',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((!Number.isNaN(0)) && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: 'if (true && (Boolean((1 + 1)))) {}',
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((Boolean(0)) && void 0)) { }
+      `,
             },
           ],
         },
+        { column: 26, line: 3, messageId: 'conditionErrorNullish' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+      output: null,
+    },
+    {
+      code: noFormat`
+declare const foo: false & { __BRAND: 'Foo' };
+if (('' && {}) || (foo && void 0)) { }
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorString',
+          column: 6,
           line: 3,
-          column: 25,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: '        while (false || (("a" + "b").length > 0)) {}',
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if (((''.length > 0) && {}) || (foo && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: '        while (false || (("a" + "b") !== "")) {}',
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if ((('' !== "") && {}) || (foo && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        while (false || (Boolean(("a" + "b")))) {}',
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if (((Boolean('')) && {}) || (foo && void 0)) { }
+      `,
             },
           ],
         },
-        { messageId: 'conditionErrorObject', line: 4, column: 41 },
+        { column: 12, line: 3, messageId: 'conditionErrorObject' },
+        { column: 27, line: 3, messageId: 'conditionErrorNullish' },
       ],
-    }),
-
-    // check if all and only the outermost operands are checked
-    {
       options: [
-        { allowString: false, allowNumber: false, allowNullableObject: false },
+        { allowNullableObject: false, allowNumber: false, allowString: false },
       ],
-      code: noFormat`if (('' && {}) || (0 && void 0)) { }`,
       output: null,
+    },
+
+    // shouldn't check last logical operand when used for control flow
+    {
+      code: "'asd' && 123 && [] && null;",
       errors: [
         {
-          messageId: 'conditionErrorString',
+          column: 1,
           line: 1,
-          column: 6,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `if (((''.length > 0) && {}) || (0 && void 0)) { }`,
+              output: "('asd'.length > 0) && 123 && [] && null;",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `if ((('' !== "") && {}) || (0 && void 0)) { }`,
+              output: '(\'asd\' !== "") && 123 && [] && null;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `if (((Boolean('')) && {}) || (0 && void 0)) { }`,
+              output: "(Boolean('asd')) && 123 && [] && null;",
             },
           ],
         },
-        { messageId: 'conditionErrorObject', line: 1, column: 12 },
         {
-          messageId: 'conditionErrorNumber',
+          column: 10,
           line: 1,
-          column: 20,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: `if (('' && {}) || ((0 !== 0) && void 0)) { }`,
+              output: "'asd' && (123 !== 0) && [] && null;",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: `if (('' && {}) || ((!Number.isNaN(0)) && void 0)) { }`,
+              output: "'asd' && (!Number.isNaN(123)) && [] && null;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `if (('' && {}) || ((Boolean(0)) && void 0)) { }`,
+              output: "'asd' && (Boolean(123)) && [] && null;",
             },
           ],
         },
-        { messageId: 'conditionErrorNullish', line: 1, column: 25 },
+        {
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
       ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
     {
-      options: [
-        { allowString: false, allowNumber: false, allowNullableObject: false },
-      ],
-      code: noFormat`
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || (0 && void 0)) { }
-      `,
-      output: null,
+      code: "'asd' || 123 || [] || null;",
       errors: [
         {
+          column: 1,
+          line: 1,
           messageId: 'conditionErrorString',
-          line: 3,
-          column: 6,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (((''.length > 0) && foo) || (0 && void 0)) { }
-      `,
+              output: "('asd'.length > 0) || 123 || [] || null;",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if ((('' !== "") && foo) || (0 && void 0)) { }
-      `,
+              output: '(\'asd\' !== "") || 123 || [] || null;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (((Boolean('')) && foo) || (0 && void 0)) { }
-      `,
+              output: "(Boolean('asd')) || 123 || [] || null;",
             },
           ],
         },
         {
+          column: 10,
+          line: 1,
           messageId: 'conditionErrorNumber',
-          line: 3,
-          column: 21,
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((0 !== 0) && void 0)) { }
-      `,
+              output: "'asd' || (123 !== 0) || [] || null;",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((!Number.isNaN(0)) && void 0)) { }
-      `,
+              output: "'asd' || (!Number.isNaN(123)) || [] || null;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((Boolean(0)) && void 0)) { }
-      `,
+              output: "'asd' || (Boolean(123)) || [] || null;",
             },
           ],
         },
-        { messageId: 'conditionErrorNullish', line: 3, column: 26 },
+        {
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
       ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
     {
-      options: [
-        { allowString: false, allowNumber: false, allowNullableObject: false },
-      ],
-      code: noFormat`
-declare const foo: false & { __BRAND: 'Foo' };
-if (('' && {}) || (foo && void 0)) { }
-      `,
-      output: null,
+      code: "let x = (1 && 'a' && null) || 0 || '' || {};",
       errors: [
         {
+          column: 10,
+          line: 1,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: "let x = ((1 !== 0) && 'a' && null) || 0 || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "let x = ((!Number.isNaN(1)) && 'a' && null) || 0 || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = ((Boolean(1)) && 'a' && null) || 0 || '' || {};",
+            },
+          ],
+        },
+        {
+          column: 15,
+          line: 1,
           messageId: 'conditionErrorString',
-          line: 3,
-          column: 6,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if (((''.length > 0) && {}) || (foo && void 0)) { }
-      `,
+              output:
+                "let x = (1 && ('a'.length > 0) && null) || 0 || '' || {};",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if ((('' !== "") && {}) || (foo && void 0)) { }
-      `,
+              output: "let x = (1 && ('a' !== \"\") && null) || 0 || '' || {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if (((Boolean('')) && {}) || (foo && void 0)) { }
-      `,
+              output: "let x = (1 && (Boolean('a')) && null) || 0 || '' || {};",
+            },
+          ],
+        },
+        {
+          column: 22,
+          line: 1,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 31,
+          line: 1,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: "let x = (1 && 'a' && null) || (0 !== 0) || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "let x = (1 && 'a' && null) || (!Number.isNaN(0)) || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = (1 && 'a' && null) || (Boolean(0)) || '' || {};",
+            },
+          ],
+        },
+        {
+          column: 36,
+          line: 1,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output:
+                "let x = (1 && 'a' && null) || 0 || (''.length > 0) || {};",
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: "let x = (1 && 'a' && null) || 0 || ('' !== \"\") || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = (1 && 'a' && null) || 0 || (Boolean('')) || {};",
+            },
+          ],
+        },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "return (1 || 'a' || null) && 0 && '' && {};",
+      errors: [
+        {
+          column: 9,
+          line: 1,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: "return ((1 !== 0) || 'a' || null) && 0 && '' && {};",
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "return ((!Number.isNaN(1)) || 'a' || null) && 0 && '' && {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return ((Boolean(1)) || 'a' || null) && 0 && '' && {};",
             },
           ],
         },
-        { messageId: 'conditionErrorObject', line: 3, column: 12 },
-        { messageId: 'conditionErrorNullish', line: 3, column: 27 },
-      ],
-    },
-
-    // shouldn't check last logical operand when used for control flow
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "'asd' && 123 && [] && null;",
-      output: null,
-      errors: [
         {
-          messageId: 'conditionErrorString',
+          column: 14,
           line: 1,
-          column: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: "('asd'.length > 0) && 123 && [] && null;",
+              output:
+                "return (1 || ('a'.length > 0) || null) && 0 && '' && {};",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: '(\'asd\' !== "") && 123 && [] && null;',
+              output: "return (1 || ('a' !== \"\") || null) && 0 && '' && {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "(Boolean('asd')) && 123 && [] && null;",
+              output: "return (1 || (Boolean('a')) || null) && 0 && '' && {};",
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
+          column: 21,
           line: 1,
-          column: 10,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 30,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "'asd' && (123 !== 0) && [] && null;",
+              output: "return (1 || 'a' || null) && (0 !== 0) && '' && {};",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: "'asd' && (!Number.isNaN(123)) && [] && null;",
+              output:
+                "return (1 || 'a' || null) && (!Number.isNaN(0)) && '' && {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "'asd' && (Boolean(123)) && [] && null;",
+              output: "return (1 || 'a' || null) && (Boolean(0)) && '' && {};",
             },
           ],
         },
         {
-          messageId: 'conditionErrorObject',
+          column: 35,
           line: 1,
-          column: 17,
-        },
-      ],
-    },
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "'asd' || 123 || [] || null;",
-      output: null,
-      errors: [
-        {
           messageId: 'conditionErrorString',
-          line: 1,
-          column: 1,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: "('asd'.length > 0) || 123 || [] || null;",
+              output:
+                "return (1 || 'a' || null) && 0 && (''.length > 0) && {};",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: '(\'asd\' !== "") || 123 || [] || null;',
+              output: "return (1 || 'a' || null) && 0 && ('' !== \"\") && {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "(Boolean('asd')) || 123 || [] || null;",
+              output: "return (1 || 'a' || null) && 0 && (Boolean('')) && {};",
             },
           ],
         },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "console.log((1 && []) || ('a' && {}));",
+      errors: [
         {
-          messageId: 'conditionErrorNumber',
+          column: 14,
           line: 1,
-          column: 10,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "'asd' || (123 !== 0) || [] || null;",
+              output: "console.log(((1 !== 0) && []) || ('a' && {}));",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: "'asd' || (!Number.isNaN(123)) || [] || null;",
+              output: "console.log(((!Number.isNaN(1)) && []) || ('a' && {}));",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "'asd' || (Boolean(123)) || [] || null;",
+              output: "console.log(((Boolean(1)) && []) || ('a' && {}));",
             },
           ],
         },
         {
+          column: 19,
+          line: 1,
           messageId: 'conditionErrorObject',
+        },
+        {
+          column: 27,
           line: 1,
-          column: 17,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: "console.log((1 && []) || (('a'.length > 0) && {}));",
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: 'console.log((1 && []) || ((\'a\' !== "") && {}));',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "console.log((1 && []) || ((Boolean('a')) && {}));",
+            },
+          ],
         },
       ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
+
+    // should check all logical operands when used in a condition
     {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "let x = (1 && 'a' && null) || 0 || '' || {};",
-      output: null,
+      code: "if ((1 && []) || ('a' && {})) void 0;",
       errors: [
         {
-          messageId: 'conditionErrorNumber',
+          column: 6,
           line: 1,
-          column: 10,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "let x = ((1 !== 0) && 'a' && null) || 0 || '' || {};",
+              output: "if (((1 !== 0) && []) || ('a' && {})) void 0;",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output:
-                "let x = ((!Number.isNaN(1)) && 'a' && null) || 0 || '' || {};",
+              output: "if (((!Number.isNaN(1)) && []) || ('a' && {})) void 0;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "let x = ((Boolean(1)) && 'a' && null) || 0 || '' || {};",
+              output: "if (((Boolean(1)) && []) || ('a' && {})) void 0;",
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
+          column: 11,
           line: 1,
-          column: 15,
+          messageId: 'conditionErrorObject',
+        },
+        {
+          column: 19,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output:
-                "let x = (1 && ('a'.length > 0) && null) || 0 || '' || {};",
+              output: "if ((1 && []) || (('a'.length > 0) && {})) void 0;",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: "let x = (1 && ('a' !== \"\") && null) || 0 || '' || {};",
+              output: 'if ((1 && []) || ((\'a\' !== "") && {})) void 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && (Boolean('a')) && null) || 0 || '' || {};",
+              output: "if ((1 && []) || ((Boolean('a')) && {})) void 0;",
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullish',
+          column: 26,
           line: 1,
-          column: 22,
+          messageId: 'conditionErrorObject',
         },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "let x = null || 0 || 'a' || [] ? {} : undefined;",
+      errors: [
         {
-          messageId: 'conditionErrorNumber',
+          column: 9,
           line: 1,
-          column: 31,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "let x = (1 && 'a' && null) || (0 !== 0) || '' || {};",
+              output:
+                "let x = null || (0 !== 0) || 'a' || [] ? {} : undefined;",
             },
             {
               messageId: 'conditionFixCompareNaN',
               output:
-                "let x = (1 && 'a' && null) || (!Number.isNaN(0)) || '' || {};",
+                "let x = null || (!Number.isNaN(0)) || 'a' || [] ? {} : undefined;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && 'a' && null) || (Boolean(0)) || '' || {};",
+              output:
+                "let x = null || (Boolean(0)) || 'a' || [] ? {} : undefined;",
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
+          column: 22,
           line: 1,
-          column: 36,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
               output:
-                "let x = (1 && 'a' && null) || 0 || (''.length > 0) || {};",
+                "let x = null || 0 || ('a'.length > 0) || [] ? {} : undefined;",
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: "let x = (1 && 'a' && null) || 0 || ('' !== \"\") || {};",
+              output:
+                'let x = null || 0 || (\'a\' !== "") || [] ? {} : undefined;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && 'a' && null) || 0 || (Boolean('')) || {};",
+              output:
+                "let x = null || 0 || (Boolean('a')) || [] ? {} : undefined;",
             },
           ],
         },
+        {
+          column: 29,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
       ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
     {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "return (1 || 'a' || null) && 0 && '' && {};",
-      output: null,
+      code: "return !(null || 0 || 'a' || []);",
       errors: [
         {
-          messageId: 'conditionErrorNumber',
+          column: 10,
           line: 1,
-          column: 9,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 18,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "return ((1 !== 0) || 'a' || null) && 0 && '' && {};",
+              output: "return !(null || (0 !== 0) || 'a' || []);",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output:
-                "return ((!Number.isNaN(1)) || 'a' || null) && 0 && '' && {};",
+              output: "return !(null || (!Number.isNaN(0)) || 'a' || []);",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return ((Boolean(1)) || 'a' || null) && 0 && '' && {};",
+              output: "return !(null || (Boolean(0)) || 'a' || []);",
+            },
+          ],
+        },
+        {
+          column: 23,
+          line: 1,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: "return !(null || 0 || ('a'.length > 0) || []);",
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: 'return !(null || 0 || (\'a\' !== "") || []);',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return !(null || 0 || (Boolean('a')) || []);",
             },
           ],
         },
         {
+          column: 30,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+
+    // nullish in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        null || {};
+        undefined && [];
+        declare const x: null; if (x) {}
+        (x: undefined) => !x;
+        <T extends null | undefined>(x: T) => x ? 1 : 0;
+        <T extends null>(x: T) => x ? 1 : 0;
+        <T extends undefined>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
+        { column: 1, line: 2, messageId: 'conditionErrorNullish' },
+        { column: 9, line: 3, messageId: 'conditionErrorNullish' },
+        { column: 36, line: 4, messageId: 'conditionErrorNullish' },
+        { column: 28, line: 5, messageId: 'conditionErrorNullish' },
+        { column: 47, line: 6, messageId: 'conditionErrorNullish' },
+        { column: 35, line: 7, messageId: 'conditionErrorNullish' },
+        { column: 40, line: 8, messageId: 'conditionErrorNullish' },
+      ],
+    }),
+
+    // object in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        [] || 1;
+        ({}) && "a";
+        declare const x: symbol; if (x) {}
+        (x: () => void) => !x;
+        <T extends object>(x: T) => x ? 1 : 0;
+        <T extends Object | Function>(x: T) => x ? 1 : 0;
+        <T extends { a: number }>(x: T) => x ? 1 : 0;
+        <T extends () => void>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
+        { column: 1, line: 2, messageId: 'conditionErrorObject' },
+        { column: 10, line: 3, messageId: 'conditionErrorObject' },
+        { column: 38, line: 4, messageId: 'conditionErrorObject' },
+        { column: 29, line: 5, messageId: 'conditionErrorObject' },
+        { column: 37, line: 6, messageId: 'conditionErrorObject' },
+        { column: 48, line: 7, messageId: 'conditionErrorObject' },
+        { column: 44, line: 8, messageId: 'conditionErrorObject' },
+        { column: 41, line: 9, messageId: 'conditionErrorObject' },
+      ],
+    }),
+
+    // string in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        while ("") {}
+        for (; "foo";) {}
+        declare const x: string; if (x) {}
+        (x: string) => (!x);
+        <T extends string>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
+        {
+          column: 8,
+          line: 2,
           messageId: 'conditionErrorString',
-          line: 1,
-          column: 14,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output:
-                "return (1 || ('a'.length > 0) || null) && 0 && '' && {};",
+              output: `while ("".length > 0) {}`,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: "return (1 || ('a' !== \"\") || null) && 0 && '' && {};",
+              output: `while ("" !== "") {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return (1 || (Boolean('a')) || null) && 0 && '' && {};",
+              output: `while (Boolean("")) {}`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullish',
-          line: 1,
-          column: 21,
-        },
-        {
-          messageId: 'conditionErrorNumber',
-          line: 1,
-          column: 30,
+          column: 16,
+          line: 3,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: "return (1 || 'a' || null) && (0 !== 0) && '' && {};",
+              messageId: 'conditionFixCompareStringLength',
+              output: `        for (; "foo".length > 0;) {}`,
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "return (1 || 'a' || null) && (!Number.isNaN(0)) && '' && {};",
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        for (; "foo" !== "";) {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return (1 || 'a' || null) && (Boolean(0)) && '' && {};",
+              output: `        for (; Boolean("foo");) {}`,
             },
           ],
         },
         {
+          column: 38,
+          line: 4,
           messageId: 'conditionErrorString',
-          line: 1,
-          column: 35,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output:
-                "return (1 || 'a' || null) && 0 && (''.length > 0) && {};",
+              output: `        declare const x: string; if (x.length > 0) {}`,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: "return (1 || 'a' || null) && 0 && ('' !== \"\") && {};",
+              output: `        declare const x: string; if (x !== "") {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return (1 || 'a' || null) && 0 && (Boolean('')) && {};",
+              output: `        declare const x: string; if (Boolean(x)) {}`,
             },
           ],
         },
-      ],
-    },
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "console.log((1 && []) || ('a' && {}));",
-      output: null,
-      errors: [
         {
-          messageId: 'conditionErrorNumber',
-          line: 1,
-          column: 14,
+          column: 26,
+          line: 5,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: "console.log(((1 !== 0) && []) || ('a' && {}));",
+              messageId: 'conditionFixCompareStringLength',
+              output: `        (x: string) => (x.length === 0);`,
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: "console.log(((!Number.isNaN(1)) && []) || ('a' && {}));",
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        (x: string) => (x === "");`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "console.log(((Boolean(1)) && []) || ('a' && {}));",
+              output: `        (x: string) => (!Boolean(x));`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorObject',
-          line: 1,
-          column: 19,
-        },
-        {
+          column: 37,
+          line: 6,
           messageId: 'conditionErrorString',
-          line: 1,
-          column: 27,
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: "console.log((1 && []) || (('a'.length > 0) && {}));",
+              output: `        <T extends string>(x: T) => (x.length > 0) ? 1 : 0;`,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: 'console.log((1 && []) || ((\'a\' !== "") && {}));',
+              output: `        <T extends string>(x: T) => (x !== "") ? 1 : 0;`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "console.log((1 && []) || ((Boolean('a')) && {}));",
+              output: `        <T extends string>(x: T) => (Boolean(x)) ? 1 : 0;`,
             },
           ],
         },
       ],
-    },
+      options: [{ allowString: false }],
+    }),
 
-    // should check all logical operands when used in a condition
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "if ((1 && []) || ('a' && {})) void 0;",
-      output: null,
+    // number in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        while (0n) {}
+        for (; 123;) {}
+        declare const x: number; if (x) {}
+        (x: bigint) => !x;
+        <T extends number>(x: T) => (x) ? 1 : 0;
+        ![]["length"]; // doesn't count as array.length when computed
+        declare const a: any[] & { notLength: number }; if (a.notLength) {}
+      `,
       errors: [
         {
+          column: 8,
+          line: 2,
           messageId: 'conditionErrorNumber',
-          line: 1,
-          column: 6,
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "if (((1 !== 0) && []) || ('a' && {})) void 0;",
+              // TODO: fix compare zero suggestion for bigint
+              output: `while (0n !== 0) {}`,
             },
             {
+              // TODO: remove check NaN suggestion for bigint
               messageId: 'conditionFixCompareNaN',
-              output: "if (((!Number.isNaN(1)) && []) || ('a' && {})) void 0;",
+              output: `while (!Number.isNaN(0n)) {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "if (((Boolean(1)) && []) || ('a' && {})) void 0;",
+              output: `while (Boolean(0n)) {}`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorObject',
-          line: 1,
-          column: 11,
-        },
-        {
-          messageId: 'conditionErrorString',
-          line: 1,
-          column: 19,
+          column: 16,
+          line: 3,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: "if ((1 && []) || (('a'.length > 0) && {})) void 0;",
+              messageId: 'conditionFixCompareZero',
+              output: `        for (; 123 !== 0;) {}`,
             },
             {
-              messageId: 'conditionFixCompareEmptyString',
-              output: 'if ((1 && []) || ((\'a\' !== "") && {})) void 0;',
+              messageId: 'conditionFixCompareNaN',
+              output: `        for (; !Number.isNaN(123);) {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "if ((1 && []) || ((Boolean('a')) && {})) void 0;",
+              output: `        for (; Boolean(123);) {}`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorObject',
-          line: 1,
-          column: 26,
-        },
-      ],
-    },
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "let x = null || 0 || 'a' || [] ? {} : undefined;",
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullish',
-          line: 1,
-          column: 9,
-        },
-        {
+          column: 38,
+          line: 4,
           messageId: 'conditionErrorNumber',
-          line: 1,
-          column: 17,
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output:
-                "let x = null || (0 !== 0) || 'a' || [] ? {} : undefined;",
+              output: `        declare const x: number; if (x !== 0) {}`,
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output:
-                "let x = null || (!Number.isNaN(0)) || 'a' || [] ? {} : undefined;",
+              output: `        declare const x: number; if (!Number.isNaN(x)) {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                "let x = null || (Boolean(0)) || 'a' || [] ? {} : undefined;",
+              output: `        declare const x: number; if (Boolean(x)) {}`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
-          line: 1,
-          column: 22,
+          column: 25,
+          line: 5,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "let x = null || 0 || ('a'.length > 0) || [] ? {} : undefined;",
+              messageId: 'conditionFixCompareZero',
+              // TODO: fix compare zero suggestion for bigint
+              output: `        (x: bigint) => x === 0;`,
             },
             {
-              messageId: 'conditionFixCompareEmptyString',
-              output:
-                'let x = null || 0 || (\'a\' !== "") || [] ? {} : undefined;',
+              // TODO: remove check NaN suggestion for bigint
+              messageId: 'conditionFixCompareNaN',
+              output: `        (x: bigint) => Number.isNaN(x);`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                "let x = null || 0 || (Boolean('a')) || [] ? {} : undefined;",
+              output: `        (x: bigint) => !Boolean(x);`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorObject',
-          line: 1,
-          column: 29,
+          column: 38,
+          line: 6,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        <T extends number>(x: T) => (x !== 0) ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        <T extends number>(x: T) => (!Number.isNaN(x)) ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        <T extends number>(x: T) => (Boolean(x)) ? 1 : 0;`,
+            },
+          ],
         },
-      ],
-    },
-    {
-      options: [{ allowString: false, allowNumber: false }],
-      code: "return !(null || 0 || 'a' || []);",
-      output: null,
-      errors: [
         {
-          messageId: 'conditionErrorNullish',
-          line: 1,
           column: 10,
-        },
-        {
+          line: 7,
           messageId: 'conditionErrorNumber',
-          line: 1,
-          column: 18,
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: "return !(null || (0 !== 0) || 'a' || []);",
+              output: `        []["length"] === 0; // doesn't count as array.length when computed`,
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: "return !(null || (!Number.isNaN(0)) || 'a' || []);",
+              output: `        Number.isNaN([]["length"]); // doesn't count as array.length when computed`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return !(null || (Boolean(0)) || 'a' || []);",
+              output: `        !Boolean([]["length"]); // doesn't count as array.length when computed`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
-          line: 1,
-          column: 23,
+          column: 61,
+          line: 8,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: "return !(null || 0 || ('a'.length > 0) || []);",
+              messageId: 'conditionFixCompareZero',
+              output: `        declare const a: any[] & { notLength: number }; if (a.notLength !== 0) {}`,
             },
             {
-              messageId: 'conditionFixCompareEmptyString',
-              output: 'return !(null || 0 || (\'a\' !== "") || []);',
+              messageId: 'conditionFixCompareNaN',
+              output: `        declare const a: any[] & { notLength: number }; if (!Number.isNaN(a.notLength)) {}`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: "return !(null || 0 || (Boolean('a')) || []);",
+              output: `        declare const a: any[] & { notLength: number }; if (Boolean(a.notLength)) {}`,
             },
           ],
         },
-        {
-          messageId: 'conditionErrorObject',
-          line: 1,
-          column: 30,
-        },
       ],
-    },
-
-    // nullish in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        null || {};
-        undefined && [];
-        declare const x: null; if (x) {}
-        (x: undefined) => !x;
-        <T extends null | undefined>(x: T) => x ? 1 : 0;
-        <T extends null>(x: T) => x ? 1 : 0;
-        <T extends undefined>(x: T) => x ? 1 : 0;
+      options: [{ allowNumber: false }],
+    }),
+
+    // number (array.length) in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        if (![].length) {}
+        (a: number[]) => a.length && "..."
+        <T extends unknown[]>(...a: T) => a.length || "empty";
       `,
       errors: [
-        { messageId: 'conditionErrorNullish', line: 2, column: 1 },
-        { messageId: 'conditionErrorNullish', line: 3, column: 9 },
-        { messageId: 'conditionErrorNullish', line: 4, column: 36 },
-        { messageId: 'conditionErrorNullish', line: 5, column: 28 },
-        { messageId: 'conditionErrorNullish', line: 6, column: 47 },
-        { messageId: 'conditionErrorNullish', line: 7, column: 35 },
-        { messageId: 'conditionErrorNullish', line: 8, column: 40 },
+        { column: 6, line: 2, messageId: 'conditionErrorNumber' },
+        { column: 26, line: 3, messageId: 'conditionErrorNumber' },
+        { column: 43, line: 4, messageId: 'conditionErrorNumber' },
       ],
+      options: [{ allowNumber: false }],
+      output: `
+        if ([].length === 0) {}
+        (a: number[]) => (a.length > 0) && "..."
+        <T extends unknown[]>(...a: T) => (a.length > 0) || "empty";
+      `,
     }),
 
-    // object in boolean context
+    // mixed `string | number` value in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`
-        [] || 1;
-        ({}) && "a";
-        declare const x: symbol; if (x) {}
-        (x: () => void) => !x;
-        <T extends object>(x: T) => x ? 1 : 0;
-        <T extends Object | Function>(x: T) => x ? 1 : 0;
-        <T extends { a: number }>(x: T) => x ? 1 : 0;
-        <T extends () => void>(x: T) => x ? 1 : 0;
+        declare const x: string | number; if (x) {}
+        (x: bigint | string) => !x;
+        <T extends number | bigint | string>(x: T) => x ? 1 : 0;
       `,
       errors: [
-        { messageId: 'conditionErrorObject', line: 2, column: 1 },
-        { messageId: 'conditionErrorObject', line: 3, column: 10 },
-        { messageId: 'conditionErrorObject', line: 4, column: 38 },
-        { messageId: 'conditionErrorObject', line: 5, column: 29 },
-        { messageId: 'conditionErrorObject', line: 6, column: 37 },
-        { messageId: 'conditionErrorObject', line: 7, column: 48 },
-        { messageId: 'conditionErrorObject', line: 8, column: 44 },
-        { messageId: 'conditionErrorObject', line: 9, column: 41 },
+        { column: 39, line: 2, messageId: 'conditionErrorOther' },
+        { column: 34, line: 3, messageId: 'conditionErrorOther' },
+        { column: 55, line: 4, messageId: 'conditionErrorOther' },
       ],
+      options: [{ allowNumber: true, allowString: true }],
     }),
 
-    // string in boolean context
+    // nullable boolean in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowString: false }],
       code: noFormat`
-        while ("") {}
-        for (; "foo";) {}
-        declare const x: string; if (x) {}
-        (x: string) => (!x);
-        <T extends string>(x: T) => x ? 1 : 0;
+        declare const x: boolean | null; if (x) {}
+        (x?: boolean) => !x;
+        <T extends boolean | null | undefined>(x: T) => x ? 1 : 0;
       `,
       errors: [
         {
-          messageId: 'conditionErrorString',
+          column: 38,
           line: 2,
-          column: 8,
+          messageId: 'conditionErrorNullableBoolean',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `while ("".length > 0) {}`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `while ("" !== "") {}`,
+              messageId: 'conditionFixDefaultFalse',
+              output: `declare const x: boolean | null; if (x ?? false) {}`,
             },
             {
-              messageId: 'conditionFixCastBoolean',
-              output: `while (Boolean("")) {}`,
+              messageId: 'conditionFixCompareTrue',
+              output: `declare const x: boolean | null; if (x === true) {}`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
+          column: 27,
           line: 3,
-          column: 16,
+          messageId: 'conditionErrorNullableBoolean',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `        for (; "foo".length > 0;) {}`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `        for (; "foo" !== "";) {}`,
+              messageId: 'conditionFixDefaultFalse',
+              output: `        (x?: boolean) => !(x ?? false);`,
             },
             {
-              messageId: 'conditionFixCastBoolean',
-              output: `        for (; Boolean("foo");) {}`,
+              messageId: 'conditionFixCompareFalse',
+              output: `        (x?: boolean) => x === false;`,
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
+          column: 57,
           line: 4,
-          column: 38,
+          messageId: 'conditionErrorNullableBoolean',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `        declare const x: string; if (x.length > 0) {}`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `        declare const x: string; if (x !== "") {}`,
+              messageId: 'conditionFixDefaultFalse',
+              output: `        <T extends boolean | null | undefined>(x: T) => (x ?? false) ? 1 : 0;`,
             },
             {
-              messageId: 'conditionFixCastBoolean',
-              output: `        declare const x: string; if (Boolean(x)) {}`,
+              messageId: 'conditionFixCompareTrue',
+              output: `        <T extends boolean | null | undefined>(x: T) => (x === true) ? 1 : 0;`,
             },
           ],
         },
+      ],
+      options: [{ allowNullableBoolean: false }],
+    }),
+
+    // nullable object in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: object | null; if (x) {}
+        (x?: { a: number }) => !x;
+        <T extends {} | null | undefined>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorString',
-          line: 5,
-          column: 26,
+          column: 37,
+          line: 2,
+          messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `        (x: string) => (x.length === 0);`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `        (x: string) => (x === "");`,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `        (x: string) => (!Boolean(x));`,
+              messageId: 'conditionFixCompareNullish',
+              output: 'declare const x: object | null; if (x != null) {}',
             },
           ],
         },
         {
-          messageId: 'conditionErrorString',
-          line: 6,
-          column: 37,
+          column: 33,
+          line: 3,
+          messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `        <T extends string>(x: T) => (x.length > 0) ? 1 : 0;`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `        <T extends string>(x: T) => (x !== "") ? 1 : 0;`,
+              messageId: 'conditionFixCompareNullish',
+              output: `        (x?: { a: number }) => x == null;`,
             },
+          ],
+        },
+        {
+          column: 52,
+          line: 4,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
             {
-              messageId: 'conditionFixCastBoolean',
-              output: `        <T extends string>(x: T) => (Boolean(x)) ? 1 : 0;`,
+              messageId: 'conditionFixCompareNullish',
+              output: `        <T extends {} | null | undefined>(x: T) => (x != null) ? 1 : 0;`,
             },
           ],
         },
       ],
+      options: [{ allowNullableObject: false }],
     }),
 
-    // number in boolean context
+    // nullable string in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowNumber: false }],
       code: noFormat`
-        while (0n) {}
-        for (; 123;) {}
-        declare const x: number; if (x) {}
-        (x: bigint) => !x;
-        <T extends number>(x: T) => (x) ? 1 : 0;
-        ![]["length"]; // doesn't count as array.length when computed
-        declare const a: any[] & { notLength: number }; if (a.notLength) {}
+        declare const x: string | null; if (x) {}
+        (x?: string) => !x;
+        <T extends string | null | undefined>(x: T) => x ? 1 : 0;
+        function foo(x: '' | 'bar' | null) { if (!x) {} }
       `,
       errors: [
         {
-          messageId: 'conditionErrorNumber',
+          column: 37,
           line: 2,
-          column: 8,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              // TODO: fix compare zero suggestion for bigint
-              output: `while (0n !== 0) {}`,
+              messageId: 'conditionFixCompareNullish',
+              output: 'declare const x: string | null; if (x != null) {}',
             },
             {
-              // TODO: remove check NaN suggestion for bigint
-              messageId: 'conditionFixCompareNaN',
-              output: `while (!Number.isNaN(0n)) {}`,
+              messageId: 'conditionFixDefaultEmptyString',
+              output: 'declare const x: string | null; if (x ?? "") {}',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `while (Boolean(0n)) {}`,
+              output: 'declare const x: string | null; if (Boolean(x)) {}',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
+          column: 26,
           line: 3,
-          column: 16,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        for (; 123 !== 0;) {}`,
+              messageId: 'conditionFixCompareNullish',
+              output: '        (x?: string) => x == null;',
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        for (; !Number.isNaN(123);) {}`,
+              messageId: 'conditionFixDefaultEmptyString',
+              output: '        (x?: string) => !(x ?? "");',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        for (; Boolean(123);) {}`,
+              output: '        (x?: string) => !Boolean(x);',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
+          column: 56,
           line: 4,
-          column: 38,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        declare const x: number; if (x !== 0) {}`,
+              messageId: 'conditionFixCompareNullish',
+              output:
+                '        <T extends string | null | undefined>(x: T) => (x != null) ? 1 : 0;',
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        declare const x: number; if (!Number.isNaN(x)) {}`,
+              messageId: 'conditionFixDefaultEmptyString',
+              output:
+                '        <T extends string | null | undefined>(x: T) => (x ?? "") ? 1 : 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        declare const x: number; if (Boolean(x)) {}`,
+              output:
+                '        <T extends string | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
+          column: 51,
           line: 5,
-          column: 25,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              // TODO: fix compare zero suggestion for bigint
-              output: `        (x: bigint) => x === 0;`,
+              messageId: 'conditionFixCompareNullish',
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (x == null) {} }",
             },
             {
-              // TODO: remove check NaN suggestion for bigint
-              messageId: 'conditionFixCompareNaN',
-              output: `        (x: bigint) => Number.isNaN(x);`,
+              messageId: 'conditionFixDefaultEmptyString',
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (!(x ?? \"\")) {} }",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        (x: bigint) => !Boolean(x);`,
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (!Boolean(x)) {} }",
             },
           ],
         },
+      ],
+    }),
+
+    // nullable number in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: number | null; if (x) {}
+        (x?: number) => !x;
+        <T extends number | null | undefined>(x: T) => x ? 1 : 0;
+        function foo(x: 0 | 1 | null) { if (!x) {} }
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorNumber',
-          line: 6,
-          column: 38,
+          column: 37,
+          line: 2,
+          messageId: 'conditionErrorNullableNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: 'declare const x: number | null; if (x != null) {}',
+            },
+            {
+              messageId: 'conditionFixDefaultZero',
+              output: 'declare const x: number | null; if (x ?? 0) {}',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: 'declare const x: number | null; if (Boolean(x)) {}',
+            },
+          ],
+        },
+        {
+          column: 26,
+          line: 3,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        <T extends number>(x: T) => (x !== 0) ? 1 : 0;`,
+              messageId: 'conditionFixCompareNullish',
+              output: '        (x?: number) => x == null;',
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        <T extends number>(x: T) => (!Number.isNaN(x)) ? 1 : 0;`,
+              messageId: 'conditionFixDefaultZero',
+              output: '        (x?: number) => !(x ?? 0);',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        <T extends number>(x: T) => (Boolean(x)) ? 1 : 0;`,
+              output: '        (x?: number) => !Boolean(x);',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
-          line: 7,
-          column: 10,
+          column: 56,
+          line: 4,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        []["length"] === 0; // doesn't count as array.length when computed`,
+              messageId: 'conditionFixCompareNullish',
+              output:
+                '        <T extends number | null | undefined>(x: T) => (x != null) ? 1 : 0;',
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        Number.isNaN([]["length"]); // doesn't count as array.length when computed`,
+              messageId: 'conditionFixDefaultZero',
+              output:
+                '        <T extends number | null | undefined>(x: T) => (x ?? 0) ? 1 : 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        !Boolean([]["length"]); // doesn't count as array.length when computed`,
+              output:
+                '        <T extends number | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNumber',
-          line: 8,
-          column: 61,
+          column: 46,
+          line: 5,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        declare const a: any[] & { notLength: number }; if (a.notLength !== 0) {}`,
+              messageId: 'conditionFixCompareNullish',
+              output:
+                '        function foo(x: 0 | 1 | null) { if (x == null) {} }',
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        declare const a: any[] & { notLength: number }; if (!Number.isNaN(a.notLength)) {}`,
+              messageId: 'conditionFixDefaultZero',
+              output:
+                '        function foo(x: 0 | 1 | null) { if (!(x ?? 0)) {} }',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        declare const a: any[] & { notLength: number }; if (Boolean(a.notLength)) {}`,
+              output:
+                '        function foo(x: 0 | 1 | null) { if (!Boolean(x)) {} }',
             },
           ],
         },
       ],
     }),
 
-    // number (array.length) in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowNumber: false }],
-      code: noFormat`
-        if (![].length) {}
-        (a: number[]) => a.length && "..."
-        <T extends unknown[]>(...a: T) => a.length || "empty";
+    // nullable enum in boolean context
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum != null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This,
+          That,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This,
+          That,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 'a',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 'a',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
       `,
       errors: [
-        { messageId: 'conditionErrorNumber', line: 2, column: 6 },
-        { messageId: 'conditionErrorNumber', line: 3, column: 26 },
-        { messageId: 'conditionErrorNumber', line: 4, column: 43 },
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
       ],
+      options: [{ allowNullableEnum: false }],
       output: `
-        if ([].length === 0) {}
-        (a: number[]) => (a.length > 0) && "..."
-        <T extends unknown[]>(...a: T) => (a.length > 0) || "empty";
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
       `,
-    }),
+    },
 
-    // mixed `string | number` value in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowString: true, allowNumber: true }],
-      code: noFormat`
-        declare const x: string | number; if (x) {}
-        (x: bigint | string) => !x;
-        <T extends number | bigint | string>(x: T) => x ? 1 : 0;
+    // nullable mixed enum in boolean context
+    {
+      // falsy number and truthy string
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
+        }
+        (value?: ExampleEnum) => (value ? 1 : 0);
       `,
       errors: [
-        { messageId: 'conditionErrorOther', line: 2, column: 39 },
-        { messageId: 'conditionErrorOther', line: 3, column: 34 },
-        { messageId: 'conditionErrorOther', line: 4, column: 55 },
+        {
+          column: 35,
+          endColumn: 40,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
+        },
       ],
-    }),
-
-    // nullable boolean in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowNullableBoolean: false }],
-      code: noFormat`
-        declare const x: boolean | null; if (x) {}
-        (x?: boolean) => !x;
-        <T extends boolean | null | undefined>(x: T) => x ? 1 : 0;
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
+        }
+        (value?: ExampleEnum) => ((value != null) ? 1 : 0);
+      `,
+    },
+    {
+      // falsy string and truthy number
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
       `,
       errors: [
         {
-          messageId: 'conditionErrorNullableBoolean',
-          line: 2,
-          column: 38,
-          suggestions: [
-            {
-              messageId: 'conditionFixDefaultFalse',
-              output: `declare const x: boolean | null; if (x ?? false) {}`,
-            },
-            {
-              messageId: 'conditionFixCompareTrue',
-              output: `declare const x: boolean | null; if (x === true) {}`,
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableBoolean',
-          line: 3,
-          column: 27,
-          suggestions: [
-            {
-              messageId: 'conditionFixDefaultFalse',
-              output: `        (x?: boolean) => !(x ?? false);`,
-            },
-            {
-              messageId: 'conditionFixCompareFalse',
-              output: `        (x?: boolean) => x === false;`,
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableBoolean',
-          line: 4,
-          column: 57,
-          suggestions: [
-            {
-              messageId: 'conditionFixDefaultFalse',
-              output: `        <T extends boolean | null | undefined>(x: T) => (x ?? false) ? 1 : 0;`,
-            },
-            {
-              messageId: 'conditionFixCompareTrue',
-              output: `        <T extends boolean | null | undefined>(x: T) => (x === true) ? 1 : 0;`,
-            },
-          ],
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
         },
       ],
-    }),
-
-    // nullable object in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      options: [{ allowNullableObject: false }],
-      code: noFormat`
-        declare const x: object | null; if (x) {}
-        (x?: { a: number }) => !x;
-        <T extends {} | null | undefined>(x: T) => x ? 1 : 0;
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
+      `,
+    },
+    {
+      // truthy string and truthy number
+      code: `
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
       `,
       errors: [
         {
-          messageId: 'conditionErrorNullableObject',
-          line: 2,
-          column: 37,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: object | null; if (x != null) {}',
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableObject',
-          line: 3,
-          column: 33,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `        (x?: { a: number }) => x == null;`,
-            },
-          ],
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
         },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
+      `,
+    },
+    {
+      // falsy string and falsy number
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorNullableObject',
-          line: 4,
-          column: 52,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `        <T extends {} | null | undefined>(x: T) => (x != null) ? 1 : 0;`,
-            },
-          ],
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
         },
       ],
-    }),
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
+      `,
+    },
 
-    // nullable string in boolean context
+    // any in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`
-        declare const x: string | null; if (x) {}
-        (x?: string) => !x;
-        <T extends string | null | undefined>(x: T) => x ? 1 : 0;
-        function foo(x: '' | 'bar' | null) { if (!x) {} }
+        if (x) {}
+        x => !x;
+        <T extends any>(x: T) => x ? 1 : 0;
+        <T>(x: T) => x ? 1 : 0;
       `,
       errors: [
         {
-          messageId: 'conditionErrorNullableString',
+          column: 5,
           line: 2,
-          column: 37,
+          messageId: 'conditionErrorAny',
           suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: string | null; if (x != null) {}',
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: 'declare const x: string | null; if (x ?? "") {}',
-            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: 'declare const x: string | null; if (Boolean(x)) {}',
+              output: 'if (Boolean(x)) {}',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullableString',
+          column: 15,
           line: 3,
-          column: 26,
+          messageId: 'conditionErrorAny',
           suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: '        (x?: string) => x == null;',
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: '        (x?: string) => !(x ?? "");',
-            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        (x?: string) => !Boolean(x);',
+              output: '        x => !(Boolean(x));',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullableString',
+          column: 34,
           line: 4,
-          column: 56,
+          messageId: 'conditionErrorAny',
           suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (x != null) ? 1 : 0;',
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (x ?? "") ? 1 : 0;',
-            },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
+              output: '        <T extends any>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullableString',
+          column: 22,
           line: 5,
-          column: 51,
+          messageId: 'conditionErrorAny',
           suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (x == null) {} }",
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (!(x ?? \"\")) {} }",
-            },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (!Boolean(x)) {} }",
+              output: '        <T>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
       ],
     }),
 
-    // nullable number in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
+    // noStrictNullCheck
+    {
+      code: `
+declare const x: string[] | null;
+if (x) {
+}
+      `,
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
+        },
+        {
+          column: 5,
+          line: 3,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      output: null,
+    },
+
+    // automatic semicolon insertion test
+    {
       code: noFormat`
-        declare const x: number | null; if (x) {}
-        (x?: number) => !x;
-        <T extends number | null | undefined>(x: T) => x ? 1 : 0;
-        function foo(x: 0 | 1 | null) { if (!x) {} }
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        obj || 0
+        obj && 1 || 0
       `,
       errors: [
         {
-          messageId: 'conditionErrorNullableNumber',
-          line: 2,
-          column: 37,
+          column: 10,
+          line: 3,
+          messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: number | null; if (x != null) {}',
-            },
-            {
-              messageId: 'conditionFixDefaultZero',
-              output: 'declare const x: number | null; if (x ?? 0) {}',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: 'declare const x: number | null; if (Boolean(x)) {}',
+              output: `
+        declare const obj: { x: number } | null;
+        (obj == null) ? 1 : 0
+        !obj
+        obj || 0
+        obj && 1 || 0
+      `,
             },
           ],
         },
         {
-          messageId: 'conditionErrorNullableNumber',
-          line: 3,
-          column: 26,
+          column: 10,
+          line: 4,
+          messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: '        (x?: number) => x == null;',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        obj == null
+        obj || 0
+        obj && 1 || 0
+      `,
             },
+          ],
+        },
+        {
+          column: 9,
+          line: 5,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
             {
-              messageId: 'conditionFixDefaultZero',
-              output: '        (x?: number) => !(x ?? 0);',
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        ;(obj != null) || 0
+        obj && 1 || 0
+      `,
             },
+          ],
+        },
+        {
+          column: 9,
+          line: 6,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
             {
-              messageId: 'conditionFixCastBoolean',
-              output: '        (x?: number) => !Boolean(x);',
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        obj || 0
+        ;(obj != null) && 1 || 0
+      `,
             },
           ],
         },
+      ],
+      options: [{ allowNullableObject: false }],
+      output: null,
+    },
+    {
+      code: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString);
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorNullableNumber',
+          column: 8,
           line: 4,
-          column: 56,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output:
-                '        <T extends number | null | undefined>(x: T) => (x != null) ? 1 : 0;',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString != null);
+      `,
             },
             {
-              messageId: 'conditionFixDefaultZero',
-              output:
-                '        <T extends number | null | undefined>(x: T) => (x ?? 0) ? 1 : 0;',
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString ?? "");
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                '        <T extends number | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(Boolean(nullableString));
+      `,
             },
           ],
         },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString);
+      `,
+      errors: [
         {
-          messageId: 'conditionErrorNullableNumber',
-          line: 5,
-          column: 46,
+          column: 13,
+          line: 4,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output:
-                '        function foo(x: 0 | 1 | null) { if (x == null) {} }',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
+      `,
             },
             {
-              messageId: 'conditionFixDefaultZero',
-              output:
-                '        function foo(x: 0 | 1 | null) { if (!(x ?? 0)) {} }',
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                '        function foo(x: 0 | 1 | null) { if (!Boolean(x)) {} }',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
+      `,
             },
           ],
         },
       ],
-    }),
-
-    // nullable enum in boolean context
+      output: null,
+    },
     {
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum) {
-        }
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString);
       `,
       errors: [
         {
-          line: 7,
           column: 13,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 20,
+          line: 5,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
+      `,
+            },
+          ],
         },
       ],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum != null) {
-        }
-      `,
+      output: null,
     },
     {
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString);
       `,
       errors: [
         {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
+          column: 13,
+          line: 4,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
+      `,
+            },
+          ],
         },
       ],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      output: null,
     },
     {
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This,
-          That,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString);
       `,
       errors: [
         {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(Boolean(maybeString));
+      `,
+            },
+          ],
         },
       ],
-      output: `
-        enum ExampleEnum {
-          This,
-          That,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      output: null,
     },
     {
-      options: [{ allowNullableEnum: false }],
+      // The implementation signature doesn't count towards the call signatures
       code: `
-        enum ExampleEnum {
-          This = '',
-          That = 'a',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString);
       `,
       errors: [
         {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 'a',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
+          column: 18,
+          line: 18,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, Boolean(nullableString));
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
-      options: [{ allowNullableEnum: false }],
+      // The implementation signature doesn't count towards the call signatures
       code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString, 'more', 'args', 'afterwards');
       `,
       errors: [
         {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
+          column: 18,
+          line: 19,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString != null, 'more', 'args', 'afterwards');
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString ?? "", 'more', 'args', 'afterwards');
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, Boolean(nullableString), 'more', 'args', 'afterwards');
+      `,
+            },
+          ],
         },
       ],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      output: null,
     },
     {
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
       `,
       errors: [
         {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
+          line: 6,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString ?? "");
+      `,
+            },
+
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, Boolean(nullableString));
+      `,
+            },
+          ],
         },
       ],
-      output: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      output: null,
     },
+  ],
+
+  valid: [
+    // boolean in boolean context
+    "true ? 'a' : 'b';",
+    `
+if (false) {
+}
+    `,
+    'while (true) {}',
+    'for (; false; ) {}',
+    '!true;',
+    'false || 123;',
+    "true && 'foo';",
+    '!(false || true);',
+    'true && false ? true : false;',
+    '(false && true) || false;',
+    '(false && true) || [];',
+    '(false && 1) || (true && 2);',
+    `
+declare const x: boolean;
+if (x) {
+}
+    `,
+    '(x: boolean) => !x;',
+    '<T extends boolean>(x: T) => (x ? 1 : 0);',
+    `
+declare const x: never;
+if (x) {
+}
+    `,
+
+    // string in boolean context
+    `
+if ('') {
+}
+    `,
+    "while ('x') {}",
+    "for (; ''; ) {}",
+    "('' && '1') || x;",
+    `
+declare const x: string;
+if (x) {
+}
+    `,
+    '(x: string) => !x;',
+    '<T extends string>(x: T) => (x ? 1 : 0);',
+
+    // number in boolean context
+    `
+if (0) {
+}
+    `,
+    'while (1n) {}',
+    'for (; Infinity; ) {}',
+    '(0 / 0 && 1 + 2) || x;',
+    `
+declare const x: number;
+if (x) {
+}
+    `,
+    '(x: bigint) => !x;',
+    '<T extends number>(x: T) => (x ? 1 : 0);',
+
+    // nullable object in boolean context
+    `
+declare const x: null | object;
+if (x) {
+}
+    `,
+    '(x?: { a: any }) => !x;',
+    '<T extends {} | null | undefined>(x: T) => (x ? 1 : 0);',
+
+    // nullable boolean in boolean context
     {
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 14,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 7,
-          endColumn: 21,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
+        declare const x: boolean | null;
+        if (x) {
         }
       `,
+      options: [{ allowNullableBoolean: true }],
     },
-
-    // nullable mixed enum in boolean context
     {
-      // falsy number and truthy string
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => (value ? 1 : 0);
-      `,
-      errors: [
-        {
-          line: 6,
-          column: 35,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 6,
-          endColumn: 40,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => ((value != null) ? 1 : 0);
+        (x?: boolean) => !x;
       `,
+      options: [{ allowNullableBoolean: true }],
     },
     {
-      // falsy string and truthy number
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      errors: [
-        {
-          line: 6,
-          column: 36,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 6,
-          endColumn: 41,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
+        <T extends boolean | null | undefined>(x: T) => (x ? 1 : 0);
       `,
+      options: [{ allowNullableBoolean: true }],
     },
+
+    // nullable string in boolean context
     {
-      // truthy string and truthy number
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      errors: [
-        {
-          line: 6,
-          column: 36,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 6,
-          endColumn: 41,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
+        declare const x: string | null;
+        if (x) {
         }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
       `,
+      options: [{ allowNullableString: true }],
     },
     {
-      // falsy string and falsy number
-      options: [{ allowNullableEnum: false }],
       code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      errors: [
-        {
-          line: 6,
-          column: 36,
-          messageId: 'conditionErrorNullableEnum',
-          endLine: 6,
-          endColumn: 41,
-        },
-      ],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
+        (x?: string) => !x;
       `,
+      options: [{ allowNullableString: true }],
     },
-
-    // any in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        if (x) {}
-        x => !x;
-        <T extends any>(x: T) => x ? 1 : 0;
-        <T>(x: T) => x ? 1 : 0;
-      `,
-      errors: [
-        {
-          messageId: 'conditionErrorAny',
-          line: 2,
-          column: 5,
-          suggestions: [
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: 'if (Boolean(x)) {}',
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorAny',
-          line: 3,
-          column: 15,
-          suggestions: [
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: '        x => !(Boolean(x));',
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorAny',
-          line: 4,
-          column: 34,
-          suggestions: [
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: '        <T extends any>(x: T) => (Boolean(x)) ? 1 : 0;',
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorAny',
-          line: 5,
-          column: 22,
-          suggestions: [
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: '        <T>(x: T) => (Boolean(x)) ? 1 : 0;',
-            },
-          ],
-        },
-      ],
-    }),
-
-    // noStrictNullCheck
     {
       code: `
-declare const x: string[] | null;
-if (x) {
-}
+        <T extends string | null | undefined>(x: T) => (x ? 1 : 0);
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'noStrictNullCheck',
-          line: 0,
-          column: 1,
-        },
-        {
-          messageId: 'conditionErrorObject',
-          line: 3,
-          column: 5,
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
+      options: [{ allowNullableString: true }],
     },
 
-    // automatic semicolon insertion test
-    {
-      options: [{ allowNullableObject: false }],
-      code: noFormat`
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        obj || 0
-        obj && 1 || 0
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableObject',
-          line: 3,
-          column: 10,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        (obj == null) ? 1 : 0
-        !obj
-        obj || 0
-        obj && 1 || 0
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableObject',
-          line: 4,
-          column: 10,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        obj == null
-        obj || 0
-        obj && 1 || 0
+    // nullable number in boolean context
+    {
+      code: `
+        declare const x: number | null;
+        if (x) {
+        }
       `,
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableObject',
-          line: 5,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        ;(obj != null) || 0
-        obj && 1 || 0
+      options: [{ allowNullableNumber: true }],
+    },
+    {
+      code: `
+        (x?: number) => !x;
       `,
-            },
-          ],
-        },
-        {
-          messageId: 'conditionErrorNullableObject',
-          line: 6,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        obj || 0
-        ;(obj != null) && 1 || 0
+      options: [{ allowNullableNumber: true }],
+    },
+    {
+      code: `
+        <T extends number | null | undefined>(x: T) => (x ? 1 : 0);
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ allowNullableNumber: true }],
     },
+
+    // any in boolean context
     {
       code: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString);
+        declare const x: any;
+        if (x) {
+        }
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          line: 4,
-          column: 8,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString != null);
+      options: [{ allowAny: true }],
+    },
+    {
+      code: `
+        x => !x;
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString ?? "");
+      options: [{ allowAny: true }],
+    },
+    {
+      code: `
+        <T extends any>(x: T) => (x ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(Boolean(nullableString));
+      options: [{ allowAny: true }],
+    },
+
+    // logical operator
+    {
+      code: `
+        1 && true && 'x' && {};
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
       code: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString);
+        let x = 0 || false || '' || null;
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          line: 4,
-          column: 13,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
+      options: [{ allowNumber: true, allowString: true }],
+    },
+    {
+      code: `
+        if (1 && true && 'x') void 0;
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
+      options: [{ allowNumber: true, allowString: true }],
+    },
+    {
+      code: `
+        if (0 || false || '') void 0;
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
+      options: [{ allowNumber: true, allowString: true }],
+    },
+    {
+      code: `
+        1 && true && 'x' ? {} : null;
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
       code: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString);
+        0 || false || '' ? null : {};
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          line: 5,
-          column: 13,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
+      options: [{ allowNumber: true, allowString: true }],
+    },
+
+    // nullable enum in boolean context
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (theEnum) {
+        }
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
     },
+
+    // nullable mixed enum in boolean context
     {
+      // falsy number and truthy string
       code: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString);
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          line: 4,
-          column: 13,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
-      `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
-      `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
+        }
+        (value?: ExampleEnum) => (value ? 1 : 0);
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ allowNullableEnum: true }],
     },
     {
+      // falsy string and truthy number
       code: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString);
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
       `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString != null);
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      // truthy string and truthy number
+      code: `
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString ?? "");
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      // falsy string and falsy number
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
+      options: [{ allowNullableEnum: true }],
+    },
 
-someAssert(Boolean(maybeString));
+    {
+      code: `
+declare const x: string[] | null;
+// eslint-disable-next-line
+if (x) {
+}
       `,
-            },
-          ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      options: [
+        {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
         },
       ],
     },
+
+    `
+function f(arg: 'a' | null) {
+  if (arg) console.log(arg);
+}
+    `,
+    `
+function f(arg: 'a' | 'b' | null) {
+  if (arg) console.log(arg);
+}
+    `,
     {
-      // The implementation signature doesn't count towards the call signatures
       code: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+declare const x: 1 | null;
+declare const y: 1;
+if (x) {
+}
+if (y) {
 }
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString);
       `,
-      output: null,
-      errors: [
+      options: [
         {
-          messageId: 'conditionErrorNullableString',
-          line: 18,
-          column: 18,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+          allowNumber: true,
+        },
+      ],
+    },
+    `
+function f(arg: 1 | null) {
+  if (arg) console.log(arg);
 }
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString != null);
-      `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+    `,
+    `
+function f(arg: 1 | 2 | null) {
+  if (arg) console.log(arg);
+}
+    `,
+    `
+interface Options {
+  readonly enableSomething?: true;
 }
 
-declare const nullableString: string | null;
-assert(3 as any, nullableString ?? "");
-      `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+function f(opts: Options): void {
+  if (opts.enableSomething) console.log('Do something');
+}
+    `,
+    `
+declare const x: true | null;
+if (x) {
+}
+    `,
+    {
+      code: `
+declare const x: 'a' | null;
+declare const y: 'a';
+if (x) {
+}
+if (y) {
 }
-
-declare const nullableString: string | null;
-assert(3 as any, Boolean(nullableString));
       `,
-            },
-          ],
+      options: [
+        {
+          allowString: true,
         },
       ],
     },
-    {
-      // The implementation signature doesn't count towards the call signatures
-      code: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+    `
+declare const foo: boolean & { __BRAND: 'Foo' };
+if (foo) {
 }
-
+    `,
+    `
+declare const foo: true & { __BRAND: 'Foo' };
+if (foo) {
+}
+    `,
+    `
+declare const foo: false & { __BRAND: 'Foo' };
+if (foo) {
+}
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts a;
 declare const nullableString: string | null;
-assert(3 as any, nullableString, 'more', 'args', 'afterwards');
-      `,
-      output: null,
-      errors: [
-        {
-          messageId: 'conditionErrorNullableString',
-          line: 19,
-          column: 18,
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    `
+declare function assert(a: boolean, b: unknown): asserts b is string;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    // Intentional TS error - cannot assert a parameter in a binding pattern.
+    `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert(a: boolean, { b }: { b: unknown }): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(nullableString, boo);
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(...nullableString, nullableString);
+    `,
+    `
+declare function assert(
   this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
+  a: number,
+  b?: unknown,
+  c?: unknown,
+): asserts c;
 declare const nullableString: string | null;
-assert(3 as any, nullableString != null, 'more', 'args', 'afterwards');
+declare const foo: number;
+const o: { assert: typeof assert } = {
+  assert,
+};
+o.assert(foo, nullableString);
+    `,
+    {
+      code: `
+declare function assert(x: unknown): x is string;
+declare const nullableString: string | null;
+assert(nullableString);
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
+    },
+    {
+      code: `
+class ThisAsserter {
+  assertThis(this: unknown, arg2: unknown): asserts this {}
 }
 
-declare const nullableString: string | null;
-assert(3 as any, nullableString ?? "", 'more', 'args', 'afterwards');
+declare const lol: string | number | unknown | null;
+
+const thisAsserter: ThisAsserter = new ThisAsserter();
+thisAsserter.assertThis(lol);
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
+    },
+    {
+      code: `
 function assert(this: object, a: number, b: unknown): asserts b;
 function assert(a: bigint, b: unknown): asserts b;
 function assert(this: object, a: string, two: string): asserts two;
@@ -2826,68 +2833,61 @@ function assert(
   c: bigint,
   d: object,
 ): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+function assert(...args: any[]): void;
 
 function assert(...args: any[]) {
   throw new Error('lol');
 }
 
 declare const nullableString: string | null;
-assert(3 as any, Boolean(nullableString), 'more', 'args', 'afterwards');
+assert(3 as any, nullableString);
       `,
-            },
-          ],
-        },
-      ],
     },
-    {
-      code: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+    // Intentional TS error - A rest parameter must be last in a parameter list.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(...a: boolean[], b: unknown): asserts b;
 declare const nullableString: string | null;
 declare const boo: boolean;
 assert(boo, nullableString);
-      `,
-      output: null,
-      errors: [
-        {
-          line: 6,
-          messageId: 'conditionErrorNullableString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+    `,
+    // Intentional TS error - A type predicate cannot reference a rest parameter.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(a: boolean, ...b: unknown[]): asserts b;
 declare const nullableString: string | null;
 declare const boo: boolean;
-assert(boo, nullableString != null);
-      `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+assert(boo, nullableString);
+    `,
+    // Intentional TS error - An assertion function must have a parameter to assert.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(): asserts x;
 declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString ?? "");
-      `,
-            },
-
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
+assert(nullableString);
+    `,
+    `
+function assert(one: unknown): asserts one;
+function assert(one: unknown, two: unknown): asserts two;
+function assert(...args: unknown[]) {
+  throw new Error('not implemented');
+}
 declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, Boolean(nullableString));
-      `,
-            },
-          ],
-        },
-      ],
-    },
+assert(nullableString);
+assert('one', nullableString);
+    `,
+    // Intentional use of `any` to test a function call with no call signatures.
+    `
+declare const assert: any;
+declare const nullableString: string | null;
+assert(nullableString);
+    `,
+    // Coverage for absent "test expression".
+    // Ensure that no crash or false positive occurs
+    `
+      for (let x = 0; ; x++) {
+        break;
+      }
+    `,
   ],
 });
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 7d912ddc0690..05a19743f04e 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,5 @@
-import path from 'node:path';
-
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
+import path from 'node:path';
 
 import switchExhaustivenessCheck from '../../src/rules/switch-exhaustiveness-check';
 
@@ -9,355 +8,38 @@ const rootPath = path.join(process.cwd(), 'tests/fixtures/');
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 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;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
-    break;
-  }
-  case 'Tuesday': {
-    result = 2;
-    break;
-  }
-  case 'Wednesday': {
-    result = 3;
-    break;
-  }
-  case 'Thursday': {
-    result = 4;
-    break;
-  }
-  case 'Friday': {
-    result = 5;
-    break;
-  }
-  case 'Saturday': {
-    result = 6;
-    break;
-  }
-  case 'Sunday': {
-    result = 7;
-    break;
-  }
-}
-    `,
-    // Other primitive literals work too
-    `
-type Num = 0 | 1 | 2;
-
-function test(value: Num): number {
-  switch (value) {
-    case 0:
-      return 0;
-    case 1:
-      return 1;
-    case 2:
-      return 2;
-  }
-}
-    `,
-    `
-type Bool = true | false;
-
-function test(value: Bool): number {
-  switch (value) {
-    case true:
-      return 1;
-    case false:
-      return 0;
-  }
-}
-    `,
-    `
-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;
-  }
-}
-    `,
-    // Works with type references
-    `
-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;
-  }
-}
-    `,
-    // Works with `typeof`
-    `
-const A = 'a';
-const B = 1;
-const C = true;
-
-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;
-  }
-}
-    `,
-    // Switch contains default clause.
-    `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
-    break;
-  }
-  default: {
-    result = 42;
-  }
-}
-    `,
-    // Exhaustiveness check only works for union types...
-    `
-const day = 'Monday' as string;
-let result = 0;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
-    break;
-  }
-  case 'Tuesday': {
-    result = 2;
-    break;
-  }
-}
-    `,
-    // ... and enums (at least for now).
-    `
-enum Enum {
-  A,
-  B,
-}
-
-function test(value: Enum): number {
-  switch (value) {
-    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 };
-
-function test(value: ObjectUnion): number {
-  switch (value.a) {
-    case 1:
-      return 1;
-  }
-}
-    `,
-    // switch with default clause on non-union type
-    {
-      code: `
-declare const value: number;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
-}
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    // switch with default clause on string type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: string;
-switch (value) {
-  case 'foo':
-    return 0;
-  case 'bar':
-    return 1;
-  default:
-    return -1;
-}
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on number type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: number;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
-}
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on bigint type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: bigint;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
-}
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on symbol type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: symbol;
-const foo = Symbol('foo');
-switch (value) {
-  case foo:
-    return 0;
-  default:
-    return -1;
-}
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on union with number +
-    // "allowDefaultCaseForExhaustiveSwitch" option
+  invalid: [
     {
       code: `
-declare const value: 0 | 1 | number;
+declare const value: 'literal';
 switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
 declare const value: 'literal';
 switch (value) {
-  case 'literal':
-    return 0;
+case "literal": { throw new Error('Not implemented yet: "literal" case') }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+            },
+          ],
         },
       ],
-    },
-    {
-      code: `
-declare const value: null;
-switch (value) {
-  case null:
-    return 0;
-}
-      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -367,44 +49,28 @@ switch (value) {
     },
     {
       code: `
-declare const value: undefined;
+declare const value: 'literal' & { _brand: true };
 switch (value) {
-  case undefined:
-    return 0;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: null | undefined;
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: 'literal' & { _brand: true };
 switch (value) {
-  case null:
-    return 0;
-  case undefined:
-    return 0;
+case "literal": { throw new Error('Not implemented yet: "literal" case') }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+            },
+          ],
         },
       ],
-    },
-    {
-      code: `
-declare const value: 'literal' & { _brand: true };
-switch (value) {
-  case 'literal':
-    break;
-}
-      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -418,29 +84,28 @@ declare const value: ('literal' & { _brand: true }) | 1;
 switch (value) {
   case 'literal':
     break;
-  case 1:
-    break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: (1 & { _brand: true }) | 'literal' | null;
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: ('literal' & { _brand: true }) | 1;
 switch (value) {
   case 'literal':
     break;
-  case 1:
-    break;
-  case null:
-    break;
+  case 1: { throw new Error('Not implemented yet: 1 case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -454,29 +119,28 @@ declare const value: '1' | '2' | number;
 switch (value) {
   case '1':
     break;
-  case '2':
-    break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
 declare const value: '1' | '2' | number;
 switch (value) {
   case '1':
     break;
-  case '2':
-    break;
-  default:
-    break;
+  case "2": { throw new Error('Not implemented yet: "2" case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: true,
@@ -490,117 +154,275 @@ declare const value: '1' | '2' | number;
 switch (value) {
   case '1':
     break;
-  case '2':
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
     break;
-  default:
+  case "2": { throw new Error('Not implemented yet: "2" case') }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: '1' | '2' | (number & { foo: 'bar' });
+declare const value: (string & { foo: 'bar' }) | '1';
 switch (value) {
   case '1':
     break;
-  case '2':
-    break;
-  default:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: (string & { foo: 'bar' }) | '1';
+switch (value) {
+  case '1':
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: '1' | '2' | number;
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
 switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
-  default:
-    break;
 }
       `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+switch (value) {
+case undefined: { throw new Error('Not implemented yet: undefined case') }
+case null: { throw new Error('Not implemented yet: null case') }
+case "1": { throw new Error('Not implemented yet: "1" case') }
+case 1: { throw new Error('Not implemented yet: 1 case') }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+switch (value) {
+default: { throw new Error('default case') }
+}
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: number | null | undefined;
+declare const value: string | number;
 switch (value) {
-  case null:
+  case 1:
     break;
-  case undefined:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: string | number;
+switch (value) {
+  case 1:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: '1' | '2' | number;
+declare const value: number;
+declare const a: number;
 switch (value) {
-  case '1':
+  case a:
     break;
-  default:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 4,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: number;
+declare const a: number;
+switch (value) {
+  case a:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: (string & { foo: 'bar' }) | '1';
+declare const value: bigint;
 switch (value) {
-  case '1':
+  case 10n:
+    break;
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: bigint;
+switch (value) {
+  case 10n:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
+declare const value: symbol;
+const a = Symbol('a');
+switch (value) {
+  case a:
+    break;
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 4,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: symbol;
 const a = Symbol('a');
-declare const value: typeof a | 2;
 switch (value) {
   case a:
     break;
-  case 2:
-    break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -610,156 +432,231 @@ switch (value) {
     },
     {
       code: `
-declare const value: string | number;
+const a = Symbol('aa');
+const b = Symbol('bb');
+declare const value: typeof a | typeof b | 1;
 switch (value) {
   case 1:
     break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: string | number;
+          column: 9,
+          line: 5,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const a = Symbol('aa');
+const b = Symbol('bb');
+declare const value: typeof a | typeof b | 1;
 switch (value) {
+  case 1:
+    break;
+  case a: { throw new Error('Not implemented yet: a case') }
+  case b: { throw new Error('Not implemented yet: b case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: string | number;
+const a = Symbol('a');
+declare const value: typeof a | string;
 switch (value) {
-  default:
+  case a:
     break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: number;
-declare const a: number;
+          column: 9,
+          line: 4,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const a = Symbol('a');
+declare const value: typeof a | string;
 switch (value) {
   case a:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: bigint;
+declare const value: boolean;
 switch (value) {
-  case 10n:
-    break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: symbol;
-const a = Symbol('a');
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean;
 switch (value) {
-  case a:
-    break;
+case false: { throw new Error('Not implemented yet: false case') }
+case true: { throw new Error('Not implemented yet: true case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-declare const value: symbol;
-const a = Symbol('a');
+declare const value: boolean | 1;
 switch (value) {
-  case a:
+  case false:
     break;
-  default:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | 1;
+switch (value) {
+  case false:
     break;
+  case true: { throw new Error('Not implemented yet: true case') }
+  case 1: { throw new Error('Not implemented yet: 1 case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
+declare const value: boolean | number;
 switch (value) {
-  case a:
-    break;
-  default:
+  case 1:
     break;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | number;
+switch (value) {
+  case 1:
+    break;
+  case false: { throw new Error('Not implemented yet: false case') }
+  case true: { throw new Error('Not implemented yet: true case') }
+}
+      `,
+            },
+          ],
         },
-      ],
-    },
-    {
-      code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | number;
 switch (value) {
-  default:
+  case 1:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: boolean | 1;
+declare const value: object;
 switch (value) {
   case 1:
     break;
-  default:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: object;
+switch (value) {
+  case 1:
     break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -769,74 +666,133 @@ switch (value) {
     },
     {
       code: `
-declare const value: boolean | 1;
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1 | string;
 switch (value) {
   case 1:
     break;
-  case true:
+  case Aaa.Foo:
     break;
-  case false:
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 7,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1 | string;
+switch (value) {
+  case 1:
     break;
-  default:
+  case Aaa.Foo:
     break;
+  case Aaa.Bar: { throw new Error('Not implemented yet: Aaa.Bar case') }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+            },
+          ],
         },
-      ],
-    },
-    {
-      code: `
+        {
+          column: 9,
+          line: 7,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
 enum Aaa {
   Foo,
   Bar,
 }
-declare const value: Aaa | 1;
+declare const value: Aaa | 1 | string;
 switch (value) {
   case 1:
     break;
   case Aaa.Foo:
     break;
-  case Aaa.Bar:
-    break;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
-  ],
-  invalid: [
     {
+      // Matched only one branch out of seven.
       code: `
-declare const value: 'literal';
-switch (value) {
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
+    break;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
           column: 9,
+          data: {
+            missingBranches:
+              '"Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
+          },
+          line: 14,
+          messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: 'literal';
-switch (value) {
-case "literal": { throw new Error('Not implemented yet: "literal" case') }
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
+    break;
+  }
+  case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
+  case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
+  case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
+  case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
+  case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
+  case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
 }
       `,
             },
@@ -845,29 +801,43 @@ case "literal": { throw new Error('Not implemented yet: "literal" case') }
       ],
     },
     {
+      // Didn't match all enum variants
       code: `
-declare const value: 'literal' & { _brand: true };
-switch (value) {
+enum Enum {
+  A,
+  B,
+}
+
+function test(value: Enum): number {
+  switch (value) {
+    case Enum.A:
+      return 1;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
+          column: 11,
+          data: {
+            missingBranches: 'Enum.B',
+          },
+          line: 8,
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: 'literal' & { _brand: true };
-switch (value) {
-case "literal": { throw new Error('Not implemented yet: "literal" case') }
+enum Enum {
+  A,
+  B,
+}
+
+function test(value: Enum): number {
+  switch (value) {
+    case Enum.A:
+      return 1;
+    case Enum.B: { throw new Error('Not implemented yet: Enum.B case') }
+  }
 }
       `,
             },
@@ -877,32 +847,42 @@ case "literal": { throw new Error('Not implemented yet: "literal" case') }
     },
     {
       code: `
-declare const value: ('literal' & { _brand: true }) | 1;
-switch (value) {
-  case 'literal':
-    break;
+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;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
+          column: 11,
+          data: {
+            missingBranches: '"b" | "c"',
+          },
+          line: 8,
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: ('literal' & { _brand: true }) | 1;
-switch (value) {
-  case 'literal':
-    break;
-  case 1: { throw new Error('Not implemented yet: 1 case') }
+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": { throw new Error('Not implemented yet: "b" case') }
+    case "c": { throw new Error('Not implemented yet: "c" case') }
+  }
 }
       `,
             },
@@ -912,32 +892,44 @@ switch (value) {
     },
     {
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
+const A = 'a';
+const B = 1;
+const C = true;
+
+type Union = typeof A | typeof B | typeof C;
+
+function test(value: Union): number {
+  switch (value) {
+    case 'a':
+      return 1;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
-        },
-      ],
       errors: [
         {
+          column: 11,
+          data: {
+            missingBranches: 'true | 1',
+          },
+          line: 9,
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case "2": { throw new Error('Not implemented yet: "2" case') }
+const A = 'a';
+const B = 1;
+const C = true;
+
+type Union = typeof A | typeof B | typeof C;
+
+function test(value: Union): number {
+  switch (value) {
+    case 'a':
+      return 1;
+    case true: { throw new Error('Not implemented yet: true case') }
+    case 1: { throw new Error('Not implemented yet: 1 case') }
+  }
 }
       `,
             },
@@ -947,50 +939,35 @@ switch (value) {
     },
     {
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
+type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
+
+function test(value: DiscriminatedUnion): number {
+  switch (value.type) {
+    case 'A':
+      return 1;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
+          column: 11,
+          data: {
+            missingBranches: '"B"',
+          },
+          line: 5,
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case "2": { throw new Error('Not implemented yet: "2" case') }
-}
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  default: { throw new Error('default case') }
+              messageId: 'addMissingCases',
+              output: `
+type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
+
+function test(value: DiscriminatedUnion): number {
+  switch (value.type) {
+    case 'A':
+      return 1;
+    case "B": { throw new Error('Not implemented yet: "B" case') }
+  }
 }
       `,
             },
@@ -999,33 +976,54 @@ switch (value) {
       ],
     },
     {
+      // Still complains with empty switch
       code: `
-declare const value: (string & { foo: 'bar' }) | '1';
-switch (value) {
-  case '1':
-    break;
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+
+switch (day) {
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
           column: 9,
+          data: {
+            missingBranches:
+              '"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
+          },
+          line: 13,
+          messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: (string & { foo: 'bar' }) | '1';
-switch (value) {
-  case '1':
-    break;
-  default: { throw new Error('default case') }
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+
+switch (day) {
+case "Monday": { throw new Error('Not implemented yet: "Monday" case') }
+case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
+case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
+case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
+case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
+case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
+case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
 }
       `,
             },
@@ -1035,47 +1033,79 @@ switch (value) {
     },
     {
       code: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
-switch (value) {
+const a = Symbol('a');
+const b = Symbol('b');
+const c = Symbol('c');
+
+type T = typeof a | typeof b | typeof c;
+
+function test(value: T): number {
+  switch (value) {
+    case a:
+      return 1;
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
+          column: 11,
+          data: {
+            missingBranches: 'typeof b | typeof c',
+          },
+          line: 9,
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
-switch (value) {
-case undefined: { throw new Error('Not implemented yet: undefined case') }
-case null: { throw new Error('Not implemented yet: null case') }
-case "1": { throw new Error('Not implemented yet: "1" case') }
-case 1: { throw new Error('Not implemented yet: 1 case') }
+const a = Symbol('a');
+const b = Symbol('b');
+const c = Symbol('c');
+
+type T = typeof a | typeof b | typeof c;
+
+function test(value: T): number {
+  switch (value) {
+    case a:
+      return 1;
+    case b: { throw new Error('Not implemented yet: b case') }
+    case c: { throw new Error('Not implemented yet: c case') }
+  }
 }
       `,
             },
           ],
         },
+      ],
+    },
+    // Provides suggestions to add missing cases
+    {
+      // with existing cases present
+      code: `
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+    case 1:
+      return 1;
+  }
+}
+      `,
+      errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
-switch (value) {
-default: { throw new Error('default case') }
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+    case 1:
+      return 1;
+    case 2: { throw new Error('Not implemented yet: 2 case') }
+  }
 }
       `,
             },
@@ -1084,33 +1114,29 @@ default: { throw new Error('default case') }
       ],
     },
     {
+      // without existing cases
       code: `
-declare const value: string | number;
-switch (value) {
-  case 1:
-    break;
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: string | number;
-switch (value) {
-  case 1:
-    break;
-  default: { throw new Error('default case') }
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+  case 1: { throw new Error('Not implemented yet: 1 case') }
+  case 2: { throw new Error('Not implemented yet: 2 case') }
+  }
 }
       `,
             },
@@ -1119,35 +1145,35 @@ switch (value) {
       ],
     },
     {
+      // keys include special characters
       code: `
-declare const value: number;
-declare const a: number;
-switch (value) {
-  case a:
-    break;
+export enum Enum {
+  'test-test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 4,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: number;
-declare const a: number;
-switch (value) {
-  case a:
-    break;
-  default: { throw new Error('default case') }
+export enum Enum {
+  'test-test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['test-test']: { throw new Error('Not implemented yet: Enum[\\'test-test\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
 }
       `,
             },
@@ -1156,33 +1182,35 @@ switch (value) {
       ],
     },
     {
+      // keys include empty string
       code: `
-declare const value: bigint;
-switch (value) {
-  case 10n:
-    break;
+export enum Enum {
+  '' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: bigint;
-switch (value) {
-  case 10n:
-    break;
-  default: { throw new Error('default case') }
+export enum Enum {
+  '' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['']: { throw new Error('Not implemented yet: Enum[\\'\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
 }
       `,
             },
@@ -1191,35 +1219,35 @@ switch (value) {
       ],
     },
     {
+      // keys include number as first character
       code: `
-declare const value: symbol;
-const a = Symbol('a');
-switch (value) {
-  case a:
-    break;
+export enum Enum {
+  '9test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 4,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: symbol;
-const a = Symbol('a');
-switch (value) {
-  case a:
-    break;
-  default: { throw new Error('default case') }
+export enum Enum {
+  '9test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['9test']: { throw new Error('Not implemented yet: Enum[\\'9test\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
 }
       `,
             },
@@ -1229,75 +1257,75 @@ switch (value) {
     },
     {
       code: `
-const a = Symbol('aa');
-const b = Symbol('bb');
-declare const value: typeof a | typeof b | 1;
+const value: number = Math.floor(Math.random() * 3);
 switch (value) {
+  case 0:
+    return 0;
   case 1:
-    break;
+    return 1;
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 5,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-const a = Symbol('aa');
-const b = Symbol('bb');
-declare const value: typeof a | typeof b | 1;
+const value: number = Math.floor(Math.random() * 3);
 switch (value) {
+  case 0:
+    return 0;
   case 1:
-    break;
-  case a: { throw new Error('Not implemented yet: a case') }
-  case b: { throw new Error('Not implemented yet: b case') }
+    return 1;
+  default: { throw new Error('default case') }
 }
       `,
             },
           ],
         },
       ],
-    },
-    {
-      code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
-switch (value) {
-  case a:
-    break;
-}
-      `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: true,
         },
       ],
+    },
+    {
+      code: `
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        }
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 4,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-const a = Symbol('a');
-declare const value: typeof a | string;
-switch (value) {
-  case a:
-    break;
-  default: { throw new Error('default case') }
-}
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
+        case Enum['key-with\\n\\n          new-line']: { throw new Error('Not implemented yet: Enum[\\'key-with\\\\n\\\\n          new-line\\'] case') }
+        }
       `,
             },
           ],
@@ -1305,31 +1333,34 @@ switch (value) {
       ],
     },
     {
-      code: `
-declare const value: boolean;
-switch (value) {
-}
+      code: noFormat`
+        enum Enum {
+          'a' = 1,
+          "'a' \`b\` \\"c\\"" = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {}
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-declare const value: boolean;
-switch (value) {
-case false: { throw new Error('Not implemented yet: false case') }
-case true: { throw new Error('Not implemented yet: true case') }
-}
+        enum Enum {
+          'a' = 1,
+          "'a' \`b\` \\"c\\"" = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
+        case Enum['\\'a\\' \`b\` "c"']: { throw new Error('Not implemented yet: Enum[\\'\\\\\\'a\\\\\\' \`b\` "c"\\'] case') }
+        }
       `,
             },
           ],
@@ -1337,204 +1368,346 @@ case true: { throw new Error('Not implemented yet: true case') }
       ],
     },
     {
+      // superfluous switch with a string-based union
       code: `
-declare const value: boolean | 1;
-switch (value) {
-  case false:
+type MyUnion = 'foo' | 'bar' | 'baz';
+
+declare const myUnion: MyUnion;
+
+switch (myUnion) {
+  case 'foo':
+  case 'bar':
+  case 'baz': {
+    break;
+  }
+  default: {
     break;
+  }
 }
       `,
+      errors: [
+        {
+          messageId: 'dangerousDefaultCase',
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | 1;
-switch (value) {
-  case false:
+    },
+    {
+      // superfluous switch with a string-based enum
+      code: `
+enum MyEnum {
+  Foo = 'Foo',
+  Bar = 'Bar',
+  Baz = 'Baz',
+}
+
+declare const myEnum: MyEnum;
+
+switch (myEnum) {
+  case MyEnum.Foo:
+  case MyEnum.Bar:
+  case MyEnum.Baz: {
     break;
-  case true: { throw new Error('Not implemented yet: true case') }
-  case 1: { throw new Error('Not implemented yet: 1 case') }
+  }
+  default: {
+    break;
+  }
 }
       `,
-            },
-          ],
+      errors: [
+        {
+          messageId: 'dangerousDefaultCase',
+        },
+      ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with a number-based enum
       code: `
-declare const value: boolean | number;
-switch (value) {
-  case 1:
+enum MyEnum {
+  Foo,
+  Bar,
+  Baz,
+}
+
+declare const myEnum: MyEnum;
+
+switch (myEnum) {
+  case MyEnum.Foo:
+  case MyEnum.Bar:
+  case MyEnum.Baz: {
+    break;
+  }
+  default: {
     break;
+  }
 }
       `,
+      errors: [
+        {
+          messageId: 'dangerousDefaultCase',
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | number;
-switch (value) {
-  case 1:
+    },
+    {
+      // superfluous switch with a boolean
+      code: `
+declare const myBoolean: boolean;
+
+switch (myBoolean) {
+  case true:
+  case false: {
+    break;
+  }
+  default: {
     break;
-  case false: { throw new Error('Not implemented yet: false case') }
-  case true: { throw new Error('Not implemented yet: true case') }
+  }
 }
       `,
-            },
-          ],
+      errors: [
+        {
+          messageId: 'dangerousDefaultCase',
         },
+      ],
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | number;
-switch (value) {
-  case 1:
-    break;
-  default: { throw new Error('default case') }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with undefined
       code: `
-declare const value: object;
-switch (value) {
-  case 1:
+declare const myValue: undefined;
+
+switch (myValue) {
+  case undefined: {
+    break;
+  }
+
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 3,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: object;
-switch (value) {
-  case 1:
-    break;
-  default: { throw new Error('default case') }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with null
       code: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
-switch (value) {
-  case 1:
+declare const myValue: null;
+
+switch (myValue) {
+  case null: {
     break;
-  case Aaa.Foo:
+  }
+
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 7,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
-switch (value) {
-  case 1:
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      // superfluous switch with union of various types
+      code: `
+declare const myValue: 'foo' | boolean | undefined | null;
+
+switch (myValue) {
+  case 'foo':
+  case true:
+  case false:
+  case undefined:
+  case null: {
     break;
-  case Aaa.Foo:
+  }
+
+  default: {
     break;
-  case Aaa.Bar: { throw new Error('Not implemented yet: Aaa.Bar case') }
+  }
 }
       `,
-            },
-          ],
+      errors: [
+        {
+          messageId: 'dangerousDefaultCase',
         },
+      ],
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 7,
-          column: 9,
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
-switch (value) {
-  case 1:
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+  ],
+  valid: [
+    // All branches matched
+    `
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
     break;
-  case Aaa.Foo:
+  }
+  case 'Tuesday': {
+    result = 2;
     break;
-  default: { throw new Error('default case') }
+  }
+  case 'Wednesday': {
+    result = 3;
+    break;
+  }
+  case 'Thursday': {
+    result = 4;
+    break;
+  }
+  case 'Friday': {
+    result = 5;
+    break;
+  }
+  case 'Saturday': {
+    result = 6;
+    break;
+  }
+  case 'Sunday': {
+    result = 7;
+    break;
+  }
+}
+    `,
+    // Other primitive literals work too
+    `
+type Num = 0 | 1 | 2;
+
+function test(value: Num): number {
+  switch (value) {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    case 2:
+      return 2;
+  }
+}
+    `,
+    `
+type Bool = true | false;
+
+function test(value: Bool): number {
+  switch (value) {
+    case true:
+      return 1;
+    case false:
+      return 0;
+  }
+}
+    `,
+    `
+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;
+  }
+}
+    `,
+    // Works with type references
+    `
+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;
+  }
 }
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      // Matched only one branch out of seven.
-      code: `
+    `,
+    // Works with `typeof`
+    `
+const A = 'a';
+const B = 1;
+const C = true;
+
+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;
+  }
+}
+    `,
+    // Switch contains default clause.
+    `
 type Day =
   | 'Monday'
   | 'Tuesday'
@@ -1552,31 +1725,14 @@ switch (day) {
     result = 1;
     break;
   }
+  default: {
+    result = 42;
+  }
 }
-      `,
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          line: 14,
-          column: 9,
-          data: {
-            missingBranches:
-              '"Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
+    `,
+    // Exhaustiveness check only works for union types...
+    `
+const day = 'Monday' as string;
 let result = 0;
 
 switch (day) {
@@ -1584,22 +1740,14 @@ switch (day) {
     result = 1;
     break;
   }
-  case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
-  case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
-  case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
-  case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
-  case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
-  case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
+  case 'Tuesday': {
+    result = 2;
+    break;
+  }
 }
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      // Didn't match all enum variants
-      code: `
+    `,
+    // ... and enums (at least for now).
+    `
 enum Enum {
   A,
   B,
@@ -1609,577 +1757,377 @@ function test(value: Enum): number {
   switch (value) {
     case Enum.A:
       return 1;
+    case Enum.B:
+      return 2;
   }
 }
-      `,
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          line: 8,
-          column: 11,
-          data: {
-            missingBranches: 'Enum.B',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Enum {
-  A,
-  B,
-}
+    `,
+    // Object union types won't work either, unless it's a discriminated union
+    `
+type ObjectUnion = { a: 1 } | { b: 2 };
 
-function test(value: Enum): number {
-  switch (value) {
-    case Enum.A:
+function test(value: ObjectUnion): number {
+  switch (value.a) {
+    case 1:
       return 1;
-    case Enum.B: { throw new Error('Not implemented yet: Enum.B case') }
   }
+}
+    `,
+    // switch with default clause on non-union type
+    {
+      code: `
+declare const value: number;
+switch (value) {
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
+    // switch with default clause on string type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-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;
-  }
+declare const value: string;
+switch (value) {
+  case 'foo':
+    return 0;
+  case 'bar':
+    return 1;
+  default:
+    return -1;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 8,
-          column: 11,
-          data: {
-            missingBranches: '"b" | "c"',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-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": { throw new Error('Not implemented yet: "b" case') }
-    case "c": { throw new Error('Not implemented yet: "c" case') }
-  }
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    // switch with default clause on number type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
+    {
+      code: `
+declare const value: number;
+switch (value) {
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
+}
+      `,
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    // switch with default clause on bigint type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
+    {
+      code: `
+declare const value: bigint;
+switch (value) {
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
+}
+      `,
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    // switch with default clause on symbol type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
+    {
+      code: `
+declare const value: symbol;
+const foo = Symbol('foo');
+switch (value) {
+  case foo:
+    return 0;
+  default:
+    return -1;
+}
+      `,
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    // switch with default clause on union with number +
+    // "allowDefaultCaseForExhaustiveSwitch" option
+    {
+      code: `
+declare const value: 0 | 1 | number;
+switch (value) {
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-const A = 'a';
-const B = 1;
-const C = true;
-
-type Union = typeof A | typeof B | typeof C;
-
-function test(value: Union): number {
-  switch (value) {
-    case 'a':
-      return 1;
-  }
+declare const value: 'literal';
+switch (value) {
+  case 'literal':
+    return 0;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 9,
-          column: 11,
-          data: {
-            missingBranches: 'true | 1',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const A = 'a';
-const B = 1;
-const C = true;
-
-type Union = typeof A | typeof B | typeof C;
-
-function test(value: Union): number {
-  switch (value) {
-    case 'a':
-      return 1;
-    case true: { throw new Error('Not implemented yet: true case') }
-    case 1: { throw new Error('Not implemented yet: 1 case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
-
-function test(value: DiscriminatedUnion): number {
-  switch (value.type) {
-    case 'A':
-      return 1;
-  }
+declare const value: null;
+switch (value) {
+  case null:
+    return 0;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 5,
-          column: 11,
-          data: {
-            missingBranches: '"B"',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
-
-function test(value: DiscriminatedUnion): number {
-  switch (value.type) {
-    case 'A':
-      return 1;
-    case "B": { throw new Error('Not implemented yet: "B" case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // Still complains with empty switch
       code: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-
-switch (day) {
+declare const value: undefined;
+switch (value) {
+  case undefined:
+    return 0;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 13,
-          column: 9,
-          data: {
-            missingBranches:
-              '"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-
-switch (day) {
-case "Monday": { throw new Error('Not implemented yet: "Monday" case') }
-case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
-case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
-case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
-case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
-case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
-case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-const a = Symbol('a');
-const b = Symbol('b');
-const c = Symbol('c');
-
-type T = typeof a | typeof b | typeof c;
-
-function test(value: T): number {
-  switch (value) {
-    case a:
-      return 1;
-  }
+declare const value: null | undefined;
+switch (value) {
+  case null:
+    return 0;
+  case undefined:
+    return 0;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          line: 9,
-          column: 11,
-          data: {
-            missingBranches: 'typeof b | typeof c',
-          },
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const a = Symbol('a');
-const b = Symbol('b');
-const c = Symbol('c');
-
-type T = typeof a | typeof b | typeof c;
-
-function test(value: T): number {
-  switch (value) {
-    case a:
-      return 1;
-    case b: { throw new Error('Not implemented yet: b case') }
-    case c: { throw new Error('Not implemented yet: c case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
-    // Provides suggestions to add missing cases
     {
-      // with existing cases present
       code: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-    case 1:
-      return 1;
-  }
+declare const value: 'literal' & { _brand: true };
+switch (value) {
+  case 'literal':
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-    case 1:
-      return 1;
-    case 2: { throw new Error('Not implemented yet: 2 case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // without existing cases
       code: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-  }
-}
-      `,
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-  case 1: { throw new Error('Not implemented yet: 1 case') }
-  case 2: { throw new Error('Not implemented yet: 2 case') }
-  }
+declare const value: ('literal' & { _brand: true }) | 1;
+switch (value) {
+  case 'literal':
+    break;
+  case 1:
+    break;
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // keys include special characters
       code: `
-export enum Enum {
-  'test-test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: (1 & { _brand: true }) | 'literal' | null;
+switch (value) {
+  case 'literal':
+    break;
+  case 1:
+    break;
+  case null:
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-export enum Enum {
-  'test-test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['test-test']: { throw new Error('Not implemented yet: Enum[\\'test-test\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // keys include empty string
       code: `
-export enum Enum {
-  '' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  case '2':
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-export enum Enum {
-  '' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['']: { throw new Error('Not implemented yet: Enum[\\'\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
-      // keys include number as first character
       code: `
-export enum Enum {
-  '9test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-export enum Enum {
-  '9test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['9test']: { throw new Error('Not implemented yet: Enum[\\'9test\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-const value: number = Math.floor(Math.random() * 3);
+declare const value: '1' | '2' | number;
 switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
+    break;
 }
       `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const value: number = Math.floor(Math.random() * 3);
+    },
+    {
+      code: `
+declare const value: '1' | '2' | (number & { foo: 'bar' });
 switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default: { throw new Error('default case') }
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
+    break;
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-        enum Enum {
-          'a' = 1,
-          [\`key-with
-
-          new-line\`] = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
+    break;
+}
       `,
-      errors: [
+      options: [
         {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-        enum Enum {
-          'a' = 1,
-          [\`key-with
-
-          new-line\`] = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
-        case Enum['key-with\\n\\n          new-line']: { throw new Error('Not implemented yet: Enum[\\'key-with\\\\n\\\\n          new-line\\'] case') }
-        }
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      code: noFormat`
-        enum Enum {
-          'a' = 1,
-          "'a' \`b\` \\"c\\"" = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {}
-      `,
-      errors: [
-        {
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-        enum Enum {
-          'a' = 1,
-          "'a' \`b\` \\"c\\"" = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
-        case Enum['\\'a\\' \`b\` "c"']: { throw new Error('Not implemented yet: Enum[\\'\\\\\\'a\\\\\\' \`b\` "c"\\'] case') }
-        }
+      code: `
+declare const value: number | null | undefined;
+switch (value) {
+  case null:
+    break;
+  case undefined:
+    break;
+}
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
-      // superfluous switch with a string-based union
       code: `
-type MyUnion = 'foo' | 'bar' | 'baz';
-
-declare const myUnion: MyUnion;
-
-switch (myUnion) {
-  case 'foo':
-  case 'bar':
-  case 'baz': {
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
     break;
-  }
-  default: {
+  default:
     break;
-  }
 }
       `,
       options: [
@@ -2188,66 +2136,90 @@ switch (myUnion) {
           requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+declare const value: (string & { foo: 'bar' }) | '1';
+switch (value) {
+  case '1':
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
-      // superfluous switch with a string-based enum
       code: `
-enum MyEnum {
-  Foo = 'Foo',
-  Bar = 'Bar',
-  Baz = 'Baz',
-}
-
-declare const myEnum: MyEnum;
-
-switch (myEnum) {
-  case MyEnum.Foo:
-  case MyEnum.Bar:
-  case MyEnum.Baz: {
+const a = Symbol('a');
+declare const value: typeof a | 2;
+switch (value) {
+  case a:
     break;
-  }
-  default: {
+  case 2:
     break;
-  }
 }
       `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+declare const value: string | number;
+switch (value) {
+  case 1:
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
-      // superfluous switch with a number-based enum
       code: `
-enum MyEnum {
-  Foo,
-  Bar,
-  Baz,
+declare const value: string | number;
+switch (value) {
 }
-
-declare const myEnum: MyEnum;
-
-switch (myEnum) {
-  case MyEnum.Foo:
-  case MyEnum.Bar:
-  case MyEnum.Baz: {
+      `,
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: string | number;
+switch (value) {
+  default:
     break;
-  }
-  default: {
+}
+      `,
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: number;
+declare const a: number;
+switch (value) {
+  case a:
     break;
-  }
 }
       `,
       options: [
@@ -2256,121 +2228,148 @@ switch (myEnum) {
           requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+declare const value: bigint;
+switch (value) {
+  case 10n:
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
-      // superfluous switch with a boolean
       code: `
-declare const myBoolean: boolean;
-
-switch (myBoolean) {
-  case true:
-  case false: {
-    break;
-  }
-  default: {
+declare const value: symbol;
+const a = Symbol('a');
+switch (value) {
+  case a:
     break;
-  }
 }
       `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+declare const value: symbol;
+const a = Symbol('a');
+switch (value) {
+  case a:
+    break;
+  default:
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with undefined
       code: `
-declare const myValue: undefined;
-
-switch (myValue) {
-  case undefined: {
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  case a:
     break;
-  }
-
-  default: {
+  default:
     break;
-  }
 }
       `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  default:
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with null
       code: `
-declare const myValue: null;
-
-switch (myValue) {
-  case null: {
+declare const value: boolean | 1;
+switch (value) {
+  case 1:
     break;
-  }
-
-  default: {
+  default:
     break;
-  }
 }
       `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-      errors: [
-        {
-          messageId: 'dangerousDefaultCase',
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with union of various types
       code: `
-declare const myValue: 'foo' | boolean | undefined | null;
-
-switch (myValue) {
-  case 'foo':
+declare const value: boolean | 1;
+switch (value) {
+  case 1:
+    break;
   case true:
+    break;
   case false:
-  case undefined:
-  case null: {
     break;
-  }
-
-  default: {
+  default:
     break;
-  }
 }
       `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: false,
         },
       ],
-      errors: [
+    },
+    {
+      code: `
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1;
+switch (value) {
+  case 1:
+    break;
+  case Aaa.Foo:
+    break;
+  case Aaa.Bar:
+    break;
+}
+      `,
+      options: [
         {
-          messageId: 'dangerousDefaultCase',
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
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 2ed79fe7a4dc..c0f2df7e22fc 100644
--- a/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
+++ b/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
@@ -5,6 +5,69 @@ import rule from '../../src/rules/triple-slash-reference';
 const ruleTester = new RuleTester();
 
 ruleTester.run('triple-slash-reference', rule, {
+  invalid: [
+    {
+      code: `
+/// <reference types="foo" />
+import * as foo from 'foo';
+      `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'prefer-import' }],
+    },
+    {
+      code: `
+/// <reference types="foo" />
+import foo = require('foo');
+      `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'prefer-import' }],
+    },
+    {
+      code: '/// <reference path="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ path: 'never' }],
+    },
+    {
+      code: '/// <reference types="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'never' }],
+    },
+    {
+      code: '/// <reference lib="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ lib: 'never' }],
+    },
+  ],
   valid: [
     {
       code: `
@@ -15,7 +78,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import * as bar from 'bar';
         import * as baz from 'baz';
       `,
-      options: [{ path: 'never', types: 'never', lib: 'never' }],
+      options: [{ lib: 'never', path: 'never', types: 'never' }],
     },
     {
       code: `
@@ -26,7 +89,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import bar = require('bar');
         import baz = require('baz');
       `,
-      options: [{ path: 'never', types: 'never', lib: 'never' }],
+      options: [{ lib: 'never', path: 'never', types: 'never' }],
     },
     {
       code: `
@@ -37,7 +100,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import * as bar from 'bar';
         import * as baz from 'baz';
       `,
-      options: [{ path: 'always', types: 'always', lib: 'always' }],
+      options: [{ lib: 'always', path: 'always', types: 'always' }],
     },
     {
       code: `
@@ -48,7 +111,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import bar = require('bar');
         import baz = require('baz');
       `,
-      options: [{ path: 'always', types: 'always', lib: 'always' }],
+      options: [{ lib: 'always', path: 'always', types: 'always' }],
     },
     {
       code: `
@@ -59,7 +122,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import bar = bar;
         import baz = baz;
       `,
-      options: [{ path: 'always', types: 'always', lib: 'always' }],
+      options: [{ lib: 'always', path: 'always', types: 'always' }],
     },
     {
       code: `
@@ -70,7 +133,7 @@ ruleTester.run('triple-slash-reference', rule, {
         import bar = bar.bar.bar.bar;
         import baz = baz.baz;
       `,
-      options: [{ path: 'always', types: 'always', lib: 'always' }],
+      options: [{ lib: 'always', path: 'always', types: 'always' }],
     },
     {
       code: "import * as foo from 'foo';",
@@ -118,70 +181,7 @@ ruleTester.run('triple-slash-reference', rule, {
         */
         import * as foo from 'foo';
       `,
-      options: [{ path: 'never', types: 'never', lib: 'never' }],
-    },
-  ],
-  invalid: [
-    {
-      code: `
-/// <reference types="foo" />
-import * as foo from 'foo';
-      `,
-      options: [{ types: 'prefer-import' }],
-      errors: [
-        {
-          messageId: 'tripleSlashReference',
-          line: 2,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: `
-/// <reference types="foo" />
-import foo = require('foo');
-      `,
-      options: [{ types: 'prefer-import' }],
-      errors: [
-        {
-          messageId: 'tripleSlashReference',
-          line: 2,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '/// <reference path="foo" />',
-      options: [{ path: 'never' }],
-      errors: [
-        {
-          messageId: 'tripleSlashReference',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '/// <reference types="foo" />',
-      options: [{ types: 'never' }],
-      errors: [
-        {
-          messageId: 'tripleSlashReference',
-          line: 1,
-          column: 1,
-        },
-      ],
-    },
-    {
-      code: '/// <reference lib="foo" />',
-      options: [{ lib: 'never' }],
-      errors: [
-        {
-          messageId: 'tripleSlashReference',
-          line: 1,
-          column: 1,
-        },
-      ],
+      options: [{ lib: 'never', path: 'never', types: 'never' }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/typedef.test.ts b/packages/eslint-plugin/tests/rules/typedef.test.ts
index c3d588bc2c1e..bd203d7876a7 100644
--- a/packages/eslint-plugin/tests/rules/typedef.test.ts
+++ b/packages/eslint-plugin/tests/rules/typedef.test.ts
@@ -7,25 +7,22 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('typedef', rule, {
-  valid: [
+  invalid: [
     // Array destructuring
     {
-      code: 'function foo(...[a]: string[]) {}',
-      options: [
+      code: 'const [a] = [1];',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const foo = (...[a]: string[]) => {};',
       options: [
         {
           arrayDestructuring: true,
@@ -33,510 +30,415 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: 'const [a]: [number] = [1];',
-      options: [
+      code: 'const [a, b] = [1, 2];',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const [a, b]: [number, number] = [1, 2];',
       options: [
         {
           arrayDestructuring: true,
         },
       ],
     },
+    // Object destructuring
     {
-      code: '[a] = [1];',
-      options: [
+      code: 'const { a } = { a: 1 };',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'b = [a] = [1];',
       options: [
         {
-          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'const [b]: [number] = ([a] = [1]);',
-      options: [
+      code: 'const { a, b } = { a: 1, b: 2 };',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const [[a]]: number[][] = [[1]];',
       options: [
         {
-          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'const foo = ([{ bar }]: { bar: string }[]) => {};',
+      code: `
+        const {
+          id,
+          details: {
+            name: {
+              first,
+              middle,
+              last,
+              forTest: { moreNested },
+            },
+          },
+        } = getUser();
+      `,
+      errors: [
+        {
+          data: { name: 'first' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'middle' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'last' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'moreNested' },
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
           objectDestructuring: true,
         },
       ],
     },
+    // Arrow parameters
     {
-      code: 'const foo = ([{ bar }]: [{ bar: string }]) => {};',
+      code: 'const receivesNumber = (a): void => {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
-          objectDestructuring: true,
+          arrowParameter: true,
         },
       ],
     },
     {
-      code: 'const [a] = [1];',
+      code: 'const receivesStrings = (a, b): void => {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: false,
+          arrowParameter: true,
         },
       ],
     },
+    // Member variable declarations
     {
       code: `
-        for (const [key, val] of new Map([['key', 1]])) {
+        class Test {
+          state = 1;
         }
       `,
+      errors: [
+        {
+          data: { name: 'state' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
+          memberVariableDeclaration: true,
         },
       ],
     },
     {
       code: `
-        for (const [[key]] of [[['key']]]) {
+        class Test {
+          ['state'] = 1;
         }
       `,
+      errors: [
+        {
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
+          memberVariableDeclaration: true,
         },
       ],
     },
+    // Function parameters
     {
-      code: `
-        for (const [[{ key }]] of [[[{ key: 'value' }]]]) {
-        }
-      `,
+      code: 'function receivesNumber(a): void {}',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
+          parameter: true,
         },
       ],
     },
-    `
-      let a: number;
-      [a] = [1];
-    `,
-    // Arrow parameters
-    '((a: number): void => {})();',
-    '((a: string, b: string): void => {})();',
     {
-      code: '((a: number): void => {})();',
+      code: 'function receivesStrings(a, b): void {}',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrowParameter: false,
+          parameter: true,
         },
       ],
     },
     {
-      code: '((a: string, b: string): void => {})();',
+      code: 'function receivesNumber([a]): void {}',
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          arrowParameter: false,
+          parameter: true,
         },
       ],
     },
-    // Member variable declarations
-    `
-      class Test {
-        state: number;
-      }
-    `,
-    `
-      class Test {
-        state: number = 1;
-      }
-    `,
     {
-      code: `
-        class Test {
-          state = 1;
-        }
-      `,
+      code: 'function receivesNumbers([a, b]): void {}',
+      errors: [
+        {
+          column: 26,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          memberVariableDeclaration: false,
+          parameter: true,
         },
       ],
     },
-    // Object destructuring
     {
-      code: 'const { a }: { a: number } = { a: 1 };',
+      code: 'function receivesString({ a }): void {}',
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: 'const { a, b }: { [i: string]: number } = { a: 1, b: 2 };',
+      code: 'function receivesStrings({ a, b }): void {}',
+      errors: [
+        {
+          column: 26,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
+    // Constructor parameters
     {
       code: `
-        for (const {
-          p1: {
-            p2: { p3 },
-          },
-        } of [{ p1: { p2: { p3: 'value' } } }]) {
+        class Test {
+          constructor(param) {}
         }
       `,
+      errors: [
+        {
+          column: 23,
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
     {
       code: `
-        for (const {
-          p1: {
-            p2: {
-              p3: [key],
-            },
-          },
-        } of [{ p1: { p2: { p3: ['value'] } } }]) {
+        class Test {
+          constructor(param = 'something') {}
         }
       `,
-      options: [
+      errors: [
         {
-          objectDestructuring: true,
+          column: 23,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const { a } = { a: 1 };',
       options: [
         {
-          objectDestructuring: false,
+          parameter: true,
         },
       ],
     },
     {
       code: `
-        for (const { key, val } of [{ key: 'key', val: 1 }]) {
+        class Test {
+          constructor(private param = 'something') {}
         }
       `,
-      options: [
+      errors: [
         {
-          objectDestructuring: true,
+          column: 23,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: `
-        const {
-          id,
-          details: {
-            name: {
-              first,
-              middle,
-              last,
-              forTest: { moreNested },
-            },
-          },
-        }: User = getUser();
-      `,
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
-    // 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 {}',
-    // Constructor parameters
-    `
-      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;
-        }
-      }
-    `,
-    // Property declarations
-    `
-      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,
-        },
-      ],
-    },
-    {
-      code: noFormat`
-        type Test = {
-          [i: string];
-        };
+        class Test {
+          public method(x): number {
+            return x;
+          }
+        }
       `,
-      options: [
-        {
-          propertyDeclaration: false,
-        },
-      ],
-    },
-    // Variable declarations
-    {
-      code: "const x: string = '';",
-      options: [
-        {
-          variableDeclaration: true,
-        },
-      ],
-    },
-    {
-      code: "let x: string = '';",
-      options: [
-        {
-          variableDeclaration: true,
-        },
-      ],
-    },
-    {
-      code: 'let x: string;',
-      options: [
-        {
-          variableDeclaration: true,
-        },
-      ],
-    },
-    {
-      code: 'const a = 1;',
-      options: [
+      errors: [
         {
-          variableDeclaration: false,
+          column: 25,
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    {
-      code: 'let a;',
       options: [
         {
-          variableDeclaration: false,
-        },
-      ],
-    },
-    {
-      code: 'let a = 1;',
-      options: [
-        {
-          variableDeclaration: false,
+          parameter: true,
         },
       ],
     },
     {
-      code: 'const [a, b] = [1, 2];',
-      options: [
+      code: `
+        class Test {
+          public method(x = 123): number {
+            return x;
+          }
+        }
+      `,
+      errors: [
         {
-          objectDestructuring: false,
-          variableDeclaration: true,
+          column: 25,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: "const { a, b } = { a: '', b: '' };",
       options: [
         {
-          objectDestructuring: false,
-          variableDeclaration: true,
+          parameter: true,
         },
       ],
     },
-    // Contexts where TypeScript doesn't allow annotations
     {
       code: `
-        for (x of [1, 2, 3]) {
+        class Test {
+          public constructor(public x) {}
         }
       `,
-      options: [
+      errors: [
         {
-          variableDeclaration: true,
+          column: 30,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: `
-        for (const x in {}) {
-        }
-      `,
       options: [
         {
-          variableDeclaration: true,
+          parameter: true,
         },
       ],
     },
+    // Property declarations
     {
       code: `
-        try {
-        } catch (e) {}
+        type Test = {
+          member;
+        };
       `,
-      options: [
-        {
-          variableDeclaration: true,
-        },
-      ],
-    },
-    // variable declaration ignore function
-    {
-      code: 'const foo = function (): void {};',
-      options: [
+      errors: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          data: { name: 'member' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    {
-      code: 'const foo = (): void => {};',
       options: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          propertyDeclaration: true,
         },
       ],
     },
     {
-      code: 'const foo: () => void = (): void => {};',
-      options: [
+      code: noFormat`
+        type Test = {
+          [i: string];
+        };
+      `,
+      errors: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const foo: () => void = function (): void {};',
       options: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          propertyDeclaration: true,
         },
       ],
     },
     {
       code: `
-class Foo {
-  a = (): void => {};
-  b = function (): void {};
-}
+        interface Test {
+          member;
+        }
       `,
-      options: [
+      errors: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          data: { name: 'member' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/4033
-    {
-      code: `
-class ClassName {
-  public str: string = 'str';
-  #num: number = 13;
-
-  func: () => void = (): void => {
-    console.log(this.str);
-  };
-}
-      `,
       options: [
         {
-          memberVariableDeclaration: true,
+          propertyDeclaration: true,
         },
       ],
     },
-  ],
-  invalid: [
-    // Array destructuring
     {
-      code: 'const [a] = [1];',
+      code: noFormat`
+        interface Test {
+          [i: string];
+        }
+      `,
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -544,91 +446,63 @@ class ClassName {
       ],
       options: [
         {
-          arrayDestructuring: true,
+          propertyDeclaration: true,
         },
       ],
     },
+    // Variable declarations
     {
-      code: 'const [a, b] = [1, 2];',
+      code: 'const a = 1;',
       errors: [
         {
-          messageId: 'expectedTypedef',
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          arrayDestructuring: true,
+          variableDeclaration: true,
         },
       ],
     },
-    // Object destructuring
     {
-      code: 'const { a } = { a: 1 };',
+      code: `
+        const a = 1,
+          b: number = 2,
+          c = 3;
+      `,
       errors: [
         {
-          messageId: 'expectedTypedef',
-        },
-      ],
-      options: [
-        {
-          objectDestructuring: true,
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
         },
-      ],
-    },
-    {
-      code: 'const { a, b } = { a: 1, b: 2 };',
-      errors: [
         {
-          messageId: 'expectedTypedef',
+          data: { name: 'c' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          objectDestructuring: true,
+          variableDeclaration: true,
         },
       ],
     },
     {
-      code: `
-        const {
-          id,
-          details: {
-            name: {
-              first,
-              middle,
-              last,
-              forTest: { moreNested },
-            },
-          },
-        } = getUser();
-      `,
+      code: 'let a;',
       errors: [
         {
-          data: { name: 'first' },
-          messageId: 'expectedTypedef',
-        },
-        {
-          data: { name: 'middle' },
-          messageId: 'expectedTypedef',
-        },
-        {
-          data: { name: 'last' },
-          messageId: 'expectedTypedef',
-        },
-        {
-          data: { name: 'moreNested' },
-          messageId: 'expectedTypedef',
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          objectDestructuring: true,
+          variableDeclaration: true,
         },
       ],
     },
-    // Arrow parameters
     {
-      code: 'const receivesNumber = (a): void => {};',
+      code: 'let a = 1;',
       errors: [
         {
           data: { name: 'a' },
@@ -637,81 +511,84 @@ class ClassName {
       ],
       options: [
         {
-          arrowParameter: true,
+          variableDeclaration: true,
         },
       ],
     },
     {
-      code: 'const receivesStrings = (a, b): void => {};',
+      code: `
+        let a = 1,
+          b: number,
+          c = 2;
+      `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'expectedTypedefNamed',
         },
         {
-          data: { name: 'b' },
+          data: { name: 'c' },
           messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          arrowParameter: true,
+          variableDeclaration: true,
         },
       ],
     },
-    // Member variable declarations
     {
-      code: `
-        class Test {
-          state = 1;
-        }
-      `,
+      code: "const foo = 'foo';",
       errors: [
         {
-          data: { name: 'state' },
+          data: { name: 'foo' },
           messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          memberVariableDeclaration: true,
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
     {
-      code: `
-        class Test {
-          ['state'] = 1;
-        }
-      `,
+      code: 'const foo = function (): void {};',
       errors: [
         {
-          messageId: 'expectedTypedef',
+          data: { name: 'foo' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          memberVariableDeclaration: true,
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
-    // Function parameters
     {
-      code: 'function receivesNumber(a): void {}',
+      code: 'const foo = (): void => {};',
       errors: [
         {
-          data: { name: 'a' },
+          data: { name: 'foo' },
           messageId: 'expectedTypedefNamed',
         },
       ],
       options: [
         {
-          parameter: true,
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
     {
-      code: 'function receivesStrings(a, b): void {}',
+      code: `
+class Foo {
+  a = (): void => {};
+  b = function (): void {};
+}
+      `,
       errors: [
         {
           data: { name: 'a' },
@@ -724,196 +601,346 @@ class ClassName {
       ],
       options: [
         {
-          parameter: true,
+          memberVariableDeclaration: true,
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
+  ],
+  valid: [
+    // Array destructuring
     {
-      code: 'function receivesNumber([a]): void {}',
-      errors: [
+      code: 'function foo(...[a]: string[]) {}',
+      options: [
         {
-          column: 25,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const foo = (...[a]: string[]) => {};',
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
-      code: 'function receivesNumbers([a, b]): void {}',
-      errors: [
+      code: 'const [a]: [number] = [1];',
+      options: [
         {
-          column: 26,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const [a, b]: [number, number] = [1, 2];',
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
-      code: 'function receivesString({ a }): void {}',
-      errors: [
+      code: '[a] = [1];',
+      options: [
         {
-          column: 25,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'b = [a] = [1];',
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
-      code: 'function receivesStrings({ a, b }): void {}',
-      errors: [
+      code: 'const [b]: [number] = ([a] = [1]);',
+      options: [
         {
-          column: 26,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const [[a]]: number[][] = [[1]];',
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
-    // Constructor parameters
     {
-      code: `
-        class Test {
-          constructor(param) {}
-        }
-      `,
-      errors: [
+      code: 'const foo = ([{ bar }]: { bar: string }[]) => {};',
+      options: [
         {
-          column: 23,
-          messageId: 'expectedTypedefNamed',
+          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const foo = ([{ bar }]: [{ bar: string }]) => {};',
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
+          objectDestructuring: true,
+        },
+      ],
+    },
+    {
+      code: 'const [a] = [1];',
+      options: [
+        {
+          arrayDestructuring: false,
         },
       ],
     },
     {
       code: `
-        class Test {
-          constructor(param = 'something') {}
+        for (const [key, val] of new Map([['key', 1]])) {
         }
       `,
-      errors: [
+      options: [
         {
-          column: 23,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: `
+        for (const [[key]] of [[['key']]]) {
+        }
+      `,
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
       code: `
-        class Test {
-          constructor(private param = 'something') {}
+        for (const [[{ key }]] of [[[{ key: 'value' }]]]) {
         }
       `,
-      errors: [
+      options: [
         {
-          column: 23,
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
+        },
+      ],
+    },
+    `
+      let a: number;
+      [a] = [1];
+    `,
+    // Arrow parameters
+    '((a: number): void => {})();',
+    '((a: string, b: string): void => {})();',
+    {
+      code: '((a: number): void => {})();',
+      options: [
+        {
+          arrowParameter: false,
         },
       ],
+    },
+    {
+      code: '((a: string, b: string): void => {})();',
       options: [
         {
-          parameter: true,
+          arrowParameter: false,
         },
       ],
     },
-    // Method parameters
+    // Member variable declarations
+    `
+      class Test {
+        state: number;
+      }
+    `,
+    `
+      class Test {
+        state: number = 1;
+      }
+    `,
     {
       code: `
         class Test {
-          public method(x): number {
-            return x;
-          }
+          state = 1;
         }
       `,
-      errors: [
+      options: [
         {
-          column: 25,
-          messageId: 'expectedTypedefNamed',
+          memberVariableDeclaration: false,
         },
       ],
+    },
+    // Object destructuring
+    {
+      code: 'const { a }: { a: number } = { a: 1 };',
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
+        },
+      ],
+    },
+    {
+      code: 'const { a, b }: { [i: string]: number } = { a: 1, b: 2 };',
+      options: [
+        {
+          objectDestructuring: true,
         },
       ],
     },
     {
       code: `
-        class Test {
-          public method(x = 123): number {
-            return x;
-          }
+        for (const {
+          p1: {
+            p2: { p3 },
+          },
+        } of [{ p1: { p2: { p3: 'value' } } }]) {
         }
       `,
-      errors: [
+      options: [
         {
-          column: 25,
-          messageId: 'expectedTypedef',
+          objectDestructuring: true,
         },
       ],
+    },
+    {
+      code: `
+        for (const {
+          p1: {
+            p2: {
+              p3: [key],
+            },
+          },
+        } of [{ p1: { p2: { p3: ['value'] } } }]) {
+        }
+      `,
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
+        },
+      ],
+    },
+    {
+      code: 'const { a } = { a: 1 };',
+      options: [
+        {
+          objectDestructuring: false,
         },
       ],
     },
     {
       code: `
-        class Test {
-          public constructor(public x) {}
+        for (const { key, val } of [{ key: 'key', val: 1 }]) {
         }
       `,
-      errors: [
-        {
-          column: 30,
-          messageId: 'expectedTypedef',
+      options: [
+        {
+          objectDestructuring: true,
         },
       ],
+    },
+    {
+      code: `
+        const {
+          id,
+          details: {
+            name: {
+              first,
+              middle,
+              last,
+              forTest: { moreNested },
+            },
+          },
+        }: User = getUser();
+      `,
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
+    // 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 {}',
+    // Constructor parameters
+    `
+      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;
+        }
+      }
+    `,
     // Property declarations
+    `
+      type Test = {
+        member: number;
+      };
+    `,
+    `
+      type Test = {
+        [i: string]: number;
+      };
+    `,
+    `
+      interface Test {
+        member: string;
+      }
+    `,
+    `
+      interface Test {
+        [i: number]: string;
+      }
+    `,
     {
       code: `
         type Test = {
           member;
         };
       `,
-      errors: [
-        {
-          data: { name: 'member' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
-          propertyDeclaration: true,
+          propertyDeclaration: false,
         },
       ],
     },
@@ -923,111 +950,85 @@ class ClassName {
           [i: string];
         };
       `,
-      errors: [
-        {
-          messageId: 'expectedTypedef',
-        },
-      ],
       options: [
         {
-          propertyDeclaration: true,
+          propertyDeclaration: false,
         },
       ],
     },
+    // Variable declarations
     {
-      code: `
-        interface Test {
-          member;
-        }
-      `,
-      errors: [
-        {
-          data: { name: 'member' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: "const x: string = '';",
       options: [
         {
-          propertyDeclaration: true,
+          variableDeclaration: true,
         },
       ],
     },
     {
-      code: noFormat`
-        interface Test {
-          [i: string];
-        }
-      `,
-      errors: [
+      code: "let x: string = '';",
+      options: [
         {
-          messageId: 'expectedTypedef',
+          variableDeclaration: true,
         },
       ],
+    },
+    {
+      code: 'let x: string;',
       options: [
         {
-          propertyDeclaration: true,
+          variableDeclaration: true,
         },
       ],
     },
-    // Variable declarations
     {
       code: 'const a = 1;',
-      errors: [
+      options: [
         {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: false,
         },
       ],
+    },
+    {
+      code: 'let a;',
       options: [
         {
-          variableDeclaration: true,
+          variableDeclaration: false,
         },
       ],
     },
     {
-      code: `
-        const a = 1,
-          b: number = 2,
-          c = 3;
-      `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
+      code: 'let a = 1;',
+      options: [
         {
-          data: { name: 'c' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: false,
         },
       ],
+    },
+    {
+      code: 'const [a, b] = [1, 2];',
       options: [
         {
+          objectDestructuring: false,
           variableDeclaration: true,
         },
       ],
     },
     {
-      code: 'let a;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: "const { a, b } = { a: '', b: '' };",
       options: [
         {
+          objectDestructuring: false,
           variableDeclaration: true,
         },
       ],
     },
+    // Contexts where TypeScript doesn't allow annotations
     {
-      code: 'let a = 1;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: `
+        for (x of [1, 2, 3]) {
+        }
+      `,
       options: [
         {
           variableDeclaration: true,
@@ -1036,20 +1037,9 @@ class ClassName {
     },
     {
       code: `
-        let a = 1,
-          b: number,
-          c = 2;
+        for (const x in {}) {
+        }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-        {
-          data: { name: 'c' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
           variableDeclaration: true,
@@ -1057,47 +1047,50 @@ class ClassName {
       ],
     },
     {
-      code: "const foo = 'foo';",
-      errors: [
-        {
-          messageId: 'expectedTypedefNamed',
-          data: { name: 'foo' },
-        },
-      ],
+      code: `
+        try {
+        } catch (e) {}
+      `,
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
+    // variable declaration ignore function
     {
       code: 'const foo = function (): void {};',
-      errors: [
+      options: [
         {
-          messageId: 'expectedTypedefNamed',
-          data: { name: 'foo' },
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
+    },
+    {
+      code: 'const foo = (): void => {};',
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
     {
-      code: 'const foo = (): void => {};',
-      errors: [
+      code: 'const foo: () => void = (): void => {};',
+      options: [
         {
-          messageId: 'expectedTypedefNamed',
-          data: { name: 'foo' },
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
+    },
+    {
+      code: 'const foo: () => void = function (): void {};',
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
@@ -1108,21 +1101,28 @@ class Foo {
   b = function (): void {};
 }
       `,
-      errors: [
-        {
-          messageId: 'expectedTypedefNamed',
-          data: { name: 'a' },
-        },
+      options: [
         {
-          messageId: 'expectedTypedefNamed',
-          data: { name: 'b' },
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/4033
+    {
+      code: `
+class ClassName {
+  public str: string = 'str';
+  #num: number = 13;
+
+  func: () => void = (): void => {
+    console.log(this.str);
+  };
+}
+      `,
       options: [
         {
           memberVariableDeclaration: true,
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
index 3f2d0df5d1e2..3767f76b0cca 100644
--- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -1,7 +1,9 @@
 import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
+
 import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import type { MessageIds, Options } from '../../src/rules/unbound-method';
+
 import rule from '../../src/rules/unbound-method';
 import { getFixturesRootDir } from '../RuleTester';
 
@@ -10,8 +12,8 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
@@ -52,1203 +54,1203 @@ function addContainsMethodsClassInvalid(
 }
 
 ruleTester.run('unbound-method', rule, {
-  valid: [
-    'Promise.resolve().then(console.log);',
-    "['1', '2', '3'].map(Number.parseInt);",
-    '[5.2, 7.1, 3.6].map(Math.floor);',
-    `
-      const foo = Number;
-      ['1', '2', '3'].map(foo.parseInt);
-    `,
-    `
-      const foo = Math;
-      [5.2, 7.1, 3.6].map(foo.floor);
-    `,
-    "['1', '2', '3'].map(Number['floor']);",
-    'const x = console.log;',
-    'const x = Object.defineProperty;',
-    `
-      const foo = Object;
-      const x = foo.defineProperty;
-    `,
-    'const x = String.fromCharCode;',
-    `
-      const foo = String;
-      const x = foo.fromCharCode;
-    `,
-    'const x = RegExp.prototype;',
-    'const x = Symbol.keyFor;',
-    `
-      const foo = Symbol;
-      const x = foo.keyFor;
-    `,
-    'const x = Array.isArray;',
-    `
-      const foo = Array;
-      const x = foo.isArray;
-    `,
-    `
-      class Foo extends Array {}
-      const x = Foo.isArray;
-    `,
-    'const x = Proxy.revocable;',
-    `
-      const foo = Proxy;
-      const x = foo.revocable;
-    `,
-    'const x = Date.parse;',
-    `
-      const foo = Date;
-      const x = foo.parse;
-    `,
-    'const x = Atomics.load;',
-    `
-      const foo = Atomics;
-      const x = foo.load;
-    `,
-    'const x = Reflect.deleteProperty;',
-    'const x = JSON.stringify;',
-    `
-      const foo = JSON;
-      const x = foo.stringify;
-    `,
-    `
-      const o = {
-        f: function (this: void) {},
-      };
-      const f = o.f;
-    `,
-    `
-      const { alert } = window;
-    `,
-    `
-      let b = window.blur;
-    `,
-    `
-      function foo() {}
-      const fooObject = { foo };
-      const { foo: bar } = fooObject;
-    `,
-    ...[
-      'instance.bound();',
-      'instance.unbound();',
-
-      'ContainsMethods.boundStatic();',
-      'ContainsMethods.unboundStatic();',
-
-      'const bound = instance.bound;',
-      'const boundStatic = ContainsMethods;',
-
-      'const { bound } = instance;',
-      'const { boundStatic } = ContainsMethods;',
-
-      '(instance.bound)();',
-      '(instance.unbound)();',
-
-      '(ContainsMethods.boundStatic)();',
-      '(ContainsMethods.unboundStatic)();',
-
-      'instance.bound``;',
-      'instance.unbound``;',
-
-      'if (instance.bound) { }',
-      'if (instance.unbound) { }',
-
-      'if (instance.bound !== undefined) { }',
-      'if (instance.unbound !== undefined) { }',
+  invalid: [
+    {
+      code: `
+class Console {
+  log(str) {
+    process.stdout.write(str);
+  }
+}
 
-      'if (ContainsMethods.boundStatic) { }',
-      'if (ContainsMethods.unboundStatic) { }',
+const console = new Console();
 
-      'if (ContainsMethods.boundStatic !== undefined) { }',
-      'if (ContainsMethods.unboundStatic !== undefined) { }',
+Promise.resolve().then(console.log);
+      `,
+      errors: [
+        {
+          line: 10,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+import { console } from './class';
+const x = console.log;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: addContainsMethodsClass(`
+function foo(arg: ContainsMethods | null) {
+  const unbound = arg?.unbound;
+  arg.unbound += 1;
+  arg?.unbound as any;
+}
+      `),
+      errors: [
+        {
+          line: 20,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+        {
+          line: 21,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+        {
+          line: 22,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    ...addContainsMethodsClassInvalid([
+      'const unbound = instance.unbound;',
+      'const unboundStatic = ContainsMethods.unboundStatic;',
 
-      'if (ContainsMethods.boundStatic && instance) { }',
-      'if (ContainsMethods.unboundStatic && instance) { }',
+      'const { unbound } = instance;',
+      'const { unboundStatic } = ContainsMethods;',
 
-      'if (instance.bound || instance) { }',
-      'if (instance.unbound || instance) { }',
+      '<any>instance.unbound;',
+      'instance.unbound as any;',
 
-      'ContainsMethods.unboundStatic && 0 || ContainsMethods;',
+      '<any>ContainsMethods.unboundStatic;',
+      'ContainsMethods.unboundStatic as any;',
 
-      '(instance.bound || instance) ? 1 : 0',
-      '(instance.unbound || instance) ? 1 : 0',
+      'instance.unbound || 0;',
+      'ContainsMethods.unboundStatic || 0;',
 
-      'while (instance.bound) { }',
-      'while (instance.unbound) { }',
+      'instance.unbound ? instance.unbound : null',
+    ]),
+    {
+      code: `
+class ContainsMethods {
+  unbound?(): void;
 
-      'while (instance.bound !== undefined) { }',
-      'while (instance.unbound !== undefined) { }',
+  static unboundStatic?(): void;
+}
 
-      'while (ContainsMethods.boundStatic) { }',
-      'while (ContainsMethods.unboundStatic) { }',
+new ContainsMethods().unbound;
 
-      'while (ContainsMethods.boundStatic !== undefined) { }',
-      'while (ContainsMethods.unboundStatic !== undefined) { }',
+ContainsMethods.unboundStatic;
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+      options: [
+        {
+          ignoreStatic: true,
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/496
+    {
+      code: `
+class CommunicationError {
+  foo() {}
+}
+const x = CommunicationError.prototype.foo;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      // Promise.all is not auto-bound to Promise
+      code: 'const x = Promise.all;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound() {}
+}
+const instance = new Foo();
 
-      'instance.bound as any;',
-      'ContainsMethods.boundStatic as any;',
+let x;
 
-      'instance.bound++;',
-      '+instance.bound;',
-      '++instance.bound;',
-      'instance.bound--;',
-      '-instance.bound;',
-      '--instance.bound;',
-      'instance.bound += 1;',
-      'instance.bound -= 1;',
-      'instance.bound *= 1;',
-      'instance.bound /= 1;',
-
-      'instance.bound || 0;',
-      'instance.bound && 0;',
-
-      'instance.bound ? 1 : 0;',
-      'instance.unbound ? 1 : 0;',
-
-      'ContainsMethods.boundStatic++;',
-      '+ContainsMethods.boundStatic;',
-      '++ContainsMethods.boundStatic;',
-      'ContainsMethods.boundStatic--;',
-      '-ContainsMethods.boundStatic;',
-      '--ContainsMethods.boundStatic;',
-      'ContainsMethods.boundStatic += 1;',
-      'ContainsMethods.boundStatic -= 1;',
-      'ContainsMethods.boundStatic *= 1;',
-      'ContainsMethods.boundStatic /= 1;',
-
-      'ContainsMethods.boundStatic || 0;',
-      'instane.boundStatic && 0;',
-
-      'ContainsMethods.boundStatic ? 1 : 0;',
-      'ContainsMethods.unboundStatic ? 1 : 0;',
-
-      "typeof instance.bound === 'function';",
-      "typeof instance.unbound === 'function';",
-
-      "typeof ContainsMethods.boundStatic === 'function';",
-      "typeof ContainsMethods.unboundStatic === 'function';",
-
-      'instance.unbound = () => {};',
-      'instance.unbound = instance.unbound.bind(instance);',
-      'if (!!instance.unbound) {}',
-      'void instance.unbound',
-      'delete instance.unbound',
-
-      'const { double } = arith;',
-    ].map(addContainsMethodsClass),
-    `
-interface RecordA {
-  readonly type: 'A';
-  readonly a: {};
-}
-interface RecordB {
-  readonly type: 'B';
-  readonly b: {};
-}
-type AnyRecord = RecordA | RecordB;
-
-function test(obj: AnyRecord) {
-  switch (obj.type) {
-  }
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/496
-    `
-class CommunicationError {
-  constructor() {
-    const x = CommunicationError.prototype;
-  }
-}
-    `,
-    `
-class CommunicationError {}
-const x = CommunicationError.prototype;
-    `,
-    // optional chain
-    `
-class ContainsMethods {
-  bound?: () => void;
-  unbound?(): void;
-
-  static boundStatic?: () => void;
-  static unboundStatic?(): void;
-}
-
-function foo(instance: ContainsMethods | null) {
-  instance?.bound();
-  instance?.unbound();
-
-  if (instance?.bound) {
-  }
-  if (instance?.unbound) {
-  }
-
-  typeof instance?.bound === 'function';
-  typeof instance?.unbound === 'function';
+x = instance.unbound; // THIS SHOULD ERROR
+instance.unbound = x; // THIS SHOULD NOT
+      `,
+      errors: [
+        {
+          line: 9,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Number {
+  static parseInt = function (string: string, radix?: number): number {};
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1425
-    `
-interface OptionalMethod {
-  mightBeDefined?(): void;
+const foo = Foo;
+['1', '2', '3'].map(foo.parseInt);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Number;
+const x = foo.toFixed;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Object;
+const x = foo.hasOwnProperty;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: String;
+const x = foo.slice;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Date;
+const x = foo.getTime;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Number {}
+const x = Foo.parseInt;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends String {}
+const x = Foo.fromCharCode;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Object {}
+const x = Foo.defineProperty;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Date {}
+const x = Foo.parse;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
 }
-
-const x: OptionalMethod = {};
-declare const myCondition: boolean;
-if (myCondition || x.mightBeDefined) {
-  console.log('hello world');
+const unbound = new Foo().unbound;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound() {}
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1256
-    `
-class A {
-  unbound(): void {
-    this.unbound = undefined;
-    this.unbound = this.unbound.bind(this);
-  }
+const { unbound } = new Foo();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
 }
-    `,
-    'const { parseInt } = Number;',
-    'const { log } = console;',
-    `
-let parseInt;
-({ parseInt } = Number);
-    `,
-    `
-let log;
-({ log } = console);
-    `,
-    `
-const foo = {
-  bar: 'bar',
-};
-const { bar } = foo;
-    `,
-    `
+const { unbound } = new Foo();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  unbnound() {}
-  bar = 4;
+  unbound() {}
 }
-const { bar } = new Foo();
-    `,
-    `
+let unbound;
+({ unbound } = new Foo());
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-const { bound } = new Foo();
-    `,
-    `
+let unbound;
+({ unbound } = new Foo());
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-function foo({ bound } = new Foo()) {}
-    `,
-    `
+function foo({ unbound }: Foo = new Foo()) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
 declare const bar: Foo;
-function foo({ bound }: Foo) {}
-    `,
-    `
+function foo({ unbound }: Foo = bar) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
-}
-class Bar {
-  bound = () => 'bar';
+  unbound = function () {};
 }
-function foo({ bound }: Foo | Bar) {}
-    `,
-    `
+declare const bar: Foo;
+function foo({ unbound }: Foo = { unbound: () => {} }) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-type foo = ({ bound }: Foo) => void;
-    `,
-    `
+declare const bar: Foo;
+function foo({ unbound }: Foo = { unbound: function () {} }) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-type foo = ({ unbound }: Foo) => void;
-    `,
-    `
+function foo({ unbound }: Foo) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-class Bar {
-  bound = () => 'bar';
+function bar(cb: (arg: Foo) => void) {}
+bar(({ unbound }) => {});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
 }
-function foo({ bound }: Foo & Bar) {}
-    `,
-    `
+function bar(cb: (arg: { unbound: () => void }) => void) {}
+bar(({ unbound } = new Foo()) => {});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare const { unbound }: Foo;
-    `,
-    "declare const { unbound } = '***';",
-    `
+for (const { unbound } of [new Foo(), new Foo()]) {
+}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
+
+  foo({ unbound }: Foo) {}
 }
-type foo = (a: (b: (c: ({ unbound }: Foo) => void) => void) => void) => void;
-    `,
-    `
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
 class Bar {
-  property: ({ unbound }: Foo) => void;
-}
-    `,
-    `
-class Foo {
   unbound = function () {};
 }
-function foo<T extends ({ unbound }: Foo) => void>() {}
-    `,
-    `
+function foo({ unbound }: Foo | Bar) {}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-abstract class Bar {
-  abstract foo({ unbound }: Foo);
-}
-    `,
-    `
+function foo({ unbound }: { unbound: () => string } | Foo) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare class Bar {
-  foo({ unbound }: Foo);
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+function foo({ unbound }: Foo | Bar) {}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare function foo({ unbound }: Foo);
-    `,
-    `
+const foo = ({ unbound }: Foo & { foo: () => 'bar' }) => {};
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-interface Bar {
-  foo: ({ unbound }: Foo) => void;
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+const foo = ({ unbound }: (Foo & { foo: () => 'bar' }) | Bar) => {};
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-interface Bar {
-  foo({ unbound }: Foo): void;
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+const foo = ({ unbound }: Foo & Bar) => {};
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
+
+  other = function () {};
 }
-interface Bar {
-  new ({ unbound }: Foo): Foo;
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+const foo = ({ unbound, ...rest }: Foo & Bar) => {};
+      `,
+      errors: [
+        {
+          line: 10,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: 'const { unbound } = { unbound: function () {} };',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+function foo(
+  { unbound }: { unbound: () => void } = { unbound: function () {} },
+) {}
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  unbound = function () {};
+  floor = function () {};
 }
-type foo = new ({ unbound }: Foo) => void;
-    `,
-    'const { unbound } = { unbound: () => {} };',
-    'function foo({ unbound }: { unbound: () => void } = { unbound: () => {} }) {}',
+
+const { floor } = Math.random() > 0.5 ? new Foo() : Math;
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class CommunicationError {
+  foo() {}
+}
+const { foo } = CommunicationError.prototype;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class CommunicationError {
+  foo() {}
+}
+let foo;
+({ foo } = CommunicationError.prototype);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+import { console } from './class';
+const { log } = console;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: 'const { all } = Promise;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
     // https://github.com/typescript-eslint/typescript-eslint/issues/1866
-    `
+    {
+      code: `
 class BaseClass {
-  x: number = 42;
   logThis() {}
 }
 class OtherClass extends BaseClass {
-  superLogThis: any;
   constructor() {
     super();
-    this.superLogThis = super.logThis;
+    const x = super.logThis;
   }
 }
-const oc = new OtherClass();
-oc.superLogThis();
-    `,
-  ],
-  invalid: [
+      `,
+      errors: [
+        {
+          column: 15,
+          line: 8,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1866
     {
       code: `
-class Console {
-  log(str) {
-    process.stdout.write(str);
+class BaseClass {
+  logThis() {}
+}
+class OtherClass extends BaseClass {
+  constructor() {
+    super();
+    let x;
+    x = super.logThis;
   }
 }
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 9,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+const values = {
+  a() {},
+  b: () => {},
+};
 
-const console = new Console();
+const { a, b } = values;
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 10,
+          line: 7,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+const values = {
+  a() {},
+  b: () => {},
+};
 
-Promise.resolve().then(console.log);
+const { a: c } = values;
       `,
       errors: [
         {
-          line: 10,
+          column: 9,
+          endColumn: 10,
+          line: 7,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
     {
       code: `
-import { console } from './class';
-const x = console.log;
+const values = {
+  a() {},
+  b: () => {},
+};
+
+const { b, a } = values;
       `,
       errors: [
         {
-          line: 3,
+          column: 12,
+          endColumn: 13,
+          line: 7,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8636
     {
-      code: addContainsMethodsClass(`
-function foo(arg: ContainsMethods | null) {
-  const unbound = arg?.unbound;
-  arg.unbound += 1;
-  arg?.unbound as any;
-}
-      `),
+      code: `
+const objectLiteral = {
+  f: function () {},
+};
+const f = objectLiteral.f;
+      `,
       errors: [
         {
-          line: 20,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-        {
-          line: 21,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-        {
-          line: 22,
+          line: 5,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
-    ...addContainsMethodsClassInvalid([
-      'const unbound = instance.unbound;',
-      'const unboundStatic = ContainsMethods.unboundStatic;',
+  ],
+  valid: [
+    'Promise.resolve().then(console.log);',
+    "['1', '2', '3'].map(Number.parseInt);",
+    '[5.2, 7.1, 3.6].map(Math.floor);',
+    `
+      const foo = Number;
+      ['1', '2', '3'].map(foo.parseInt);
+    `,
+    `
+      const foo = Math;
+      [5.2, 7.1, 3.6].map(foo.floor);
+    `,
+    "['1', '2', '3'].map(Number['floor']);",
+    'const x = console.log;',
+    'const x = Object.defineProperty;',
+    `
+      const foo = Object;
+      const x = foo.defineProperty;
+    `,
+    'const x = String.fromCharCode;',
+    `
+      const foo = String;
+      const x = foo.fromCharCode;
+    `,
+    'const x = RegExp.prototype;',
+    'const x = Symbol.keyFor;',
+    `
+      const foo = Symbol;
+      const x = foo.keyFor;
+    `,
+    'const x = Array.isArray;',
+    `
+      const foo = Array;
+      const x = foo.isArray;
+    `,
+    `
+      class Foo extends Array {}
+      const x = Foo.isArray;
+    `,
+    'const x = Proxy.revocable;',
+    `
+      const foo = Proxy;
+      const x = foo.revocable;
+    `,
+    'const x = Date.parse;',
+    `
+      const foo = Date;
+      const x = foo.parse;
+    `,
+    'const x = Atomics.load;',
+    `
+      const foo = Atomics;
+      const x = foo.load;
+    `,
+    'const x = Reflect.deleteProperty;',
+    'const x = JSON.stringify;',
+    `
+      const foo = JSON;
+      const x = foo.stringify;
+    `,
+    `
+      const o = {
+        f: function (this: void) {},
+      };
+      const f = o.f;
+    `,
+    `
+      const { alert } = window;
+    `,
+    `
+      let b = window.blur;
+    `,
+    `
+      function foo() {}
+      const fooObject = { foo };
+      const { foo: bar } = fooObject;
+    `,
+    ...[
+      'instance.bound();',
+      'instance.unbound();',
 
-      'const { unbound } = instance;',
-      'const { unboundStatic } = ContainsMethods;',
+      'ContainsMethods.boundStatic();',
+      'ContainsMethods.unboundStatic();',
 
-      '<any>instance.unbound;',
-      'instance.unbound as any;',
+      'const bound = instance.bound;',
+      'const boundStatic = ContainsMethods;',
 
-      '<any>ContainsMethods.unboundStatic;',
-      'ContainsMethods.unboundStatic as any;',
+      'const { bound } = instance;',
+      'const { boundStatic } = ContainsMethods;',
 
-      'instance.unbound || 0;',
-      'ContainsMethods.unboundStatic || 0;',
+      '(instance.bound)();',
+      '(instance.unbound)();',
 
-      'instance.unbound ? instance.unbound : null',
-    ]),
-    {
-      code: `
+      '(ContainsMethods.boundStatic)();',
+      '(ContainsMethods.unboundStatic)();',
+
+      'instance.bound``;',
+      'instance.unbound``;',
+
+      'if (instance.bound) { }',
+      'if (instance.unbound) { }',
+
+      'if (instance.bound !== undefined) { }',
+      'if (instance.unbound !== undefined) { }',
+
+      'if (ContainsMethods.boundStatic) { }',
+      'if (ContainsMethods.unboundStatic) { }',
+
+      'if (ContainsMethods.boundStatic !== undefined) { }',
+      'if (ContainsMethods.unboundStatic !== undefined) { }',
+
+      'if (ContainsMethods.boundStatic && instance) { }',
+      'if (ContainsMethods.unboundStatic && instance) { }',
+
+      'if (instance.bound || instance) { }',
+      'if (instance.unbound || instance) { }',
+
+      'ContainsMethods.unboundStatic && 0 || ContainsMethods;',
+
+      '(instance.bound || instance) ? 1 : 0',
+      '(instance.unbound || instance) ? 1 : 0',
+
+      'while (instance.bound) { }',
+      'while (instance.unbound) { }',
+
+      'while (instance.bound !== undefined) { }',
+      'while (instance.unbound !== undefined) { }',
+
+      'while (ContainsMethods.boundStatic) { }',
+      'while (ContainsMethods.unboundStatic) { }',
+
+      'while (ContainsMethods.boundStatic !== undefined) { }',
+      'while (ContainsMethods.unboundStatic !== undefined) { }',
+
+      'instance.bound as any;',
+      'ContainsMethods.boundStatic as any;',
+
+      'instance.bound++;',
+      '+instance.bound;',
+      '++instance.bound;',
+      'instance.bound--;',
+      '-instance.bound;',
+      '--instance.bound;',
+      'instance.bound += 1;',
+      'instance.bound -= 1;',
+      'instance.bound *= 1;',
+      'instance.bound /= 1;',
+
+      'instance.bound || 0;',
+      'instance.bound && 0;',
+
+      'instance.bound ? 1 : 0;',
+      'instance.unbound ? 1 : 0;',
+
+      'ContainsMethods.boundStatic++;',
+      '+ContainsMethods.boundStatic;',
+      '++ContainsMethods.boundStatic;',
+      'ContainsMethods.boundStatic--;',
+      '-ContainsMethods.boundStatic;',
+      '--ContainsMethods.boundStatic;',
+      'ContainsMethods.boundStatic += 1;',
+      'ContainsMethods.boundStatic -= 1;',
+      'ContainsMethods.boundStatic *= 1;',
+      'ContainsMethods.boundStatic /= 1;',
+
+      'ContainsMethods.boundStatic || 0;',
+      'instane.boundStatic && 0;',
+
+      'ContainsMethods.boundStatic ? 1 : 0;',
+      'ContainsMethods.unboundStatic ? 1 : 0;',
+
+      "typeof instance.bound === 'function';",
+      "typeof instance.unbound === 'function';",
+
+      "typeof ContainsMethods.boundStatic === 'function';",
+      "typeof ContainsMethods.unboundStatic === 'function';",
+
+      'instance.unbound = () => {};',
+      'instance.unbound = instance.unbound.bind(instance);',
+      'if (!!instance.unbound) {}',
+      'void instance.unbound',
+      'delete instance.unbound',
+
+      'const { double } = arith;',
+    ].map(addContainsMethodsClass),
+    `
+interface RecordA {
+  readonly type: 'A';
+  readonly a: {};
+}
+interface RecordB {
+  readonly type: 'B';
+  readonly b: {};
+}
+type AnyRecord = RecordA | RecordB;
+
+function test(obj: AnyRecord) {
+  switch (obj.type) {
+  }
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/496
+    `
+class CommunicationError {
+  constructor() {
+    const x = CommunicationError.prototype;
+  }
+}
+    `,
+    `
+class CommunicationError {}
+const x = CommunicationError.prototype;
+    `,
+    // optional chain
+    `
 class ContainsMethods {
+  bound?: () => void;
   unbound?(): void;
 
+  static boundStatic?: () => void;
   static unboundStatic?(): void;
 }
 
-new ContainsMethods().unbound;
-
-ContainsMethods.unboundStatic;
-      `,
-      options: [
-        {
-          ignoreStatic: true,
-        },
-      ],
-      errors: [
-        {
-          line: 8,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/496
-    {
-      code: `
-class CommunicationError {
-  foo() {}
-}
-const x = CommunicationError.prototype.foo;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      // Promise.all is not auto-bound to Promise
-      code: 'const x = Promise.all;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound() {}
-}
-const instance = new Foo();
+function foo(instance: ContainsMethods | null) {
+  instance?.bound();
+  instance?.unbound();
 
-let x;
+  if (instance?.bound) {
+  }
+  if (instance?.unbound) {
+  }
 
-x = instance.unbound; // THIS SHOULD ERROR
-instance.unbound = x; // THIS SHOULD NOT
-      `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Number {
-  static parseInt = function (string: string, radix?: number): number {};
+  typeof instance?.bound === 'function';
+  typeof instance?.unbound === 'function';
 }
-const foo = Foo;
-['1', '2', '3'].map(foo.parseInt);
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Number;
-const x = foo.toFixed;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Object;
-const x = foo.hasOwnProperty;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: String;
-const x = foo.slice;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Date;
-const x = foo.getTime;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Number {}
-const x = Foo.parseInt;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends String {}
-const x = Foo.fromCharCode;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Object {}
-const x = Foo.defineProperty;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Date {}
-const x = Foo.parse;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1425
+    `
+interface OptionalMethod {
+  mightBeDefined?(): void;
 }
-const unbound = new Foo().unbound;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound() {}
+
+const x: OptionalMethod = {};
+declare const myCondition: boolean;
+if (myCondition || x.mightBeDefined) {
+  console.log('hello world');
 }
-const { unbound } = new Foo();
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1256
+    `
+class A {
+  unbound(): void {
+    this.unbound = undefined;
+    this.unbound = this.unbound.bind(this);
+  }
 }
-const { unbound } = new Foo();
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    'const { parseInt } = Number;',
+    'const { log } = console;',
+    `
+let parseInt;
+({ parseInt } = Number);
+    `,
+    `
+let log;
+({ log } = console);
+    `,
+    `
+const foo = {
+  bar: 'bar',
+};
+const { bar } = foo;
+    `,
+    `
 class Foo {
-  unbound() {}
+  unbnound() {}
+  bar = 4;
 }
-let unbound;
-({ unbound } = new Foo());
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
+const { bar } = new Foo();
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-let unbound;
-({ unbound } = new Foo());
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+const { bound } = new Foo();
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-function foo({ unbound }: Foo = new Foo()) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound } = new Foo()) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
 declare const bar: Foo;
-function foo({ unbound }: Foo = bar) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound }: Foo) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-declare const bar: Foo;
-function foo({ unbound }: Foo = { unbound: () => {} }) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
+class Bar {
+  bound = () => 'bar';
 }
-declare const bar: Foo;
-function foo({ unbound }: Foo = { unbound: function () {} }) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound }: Foo | Bar) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-function foo({ unbound }: Foo) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = ({ bound }: Foo) => void;
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-function bar(cb: (arg: Foo) => void) {}
-bar(({ unbound }) => {});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = ({ unbound }: Foo) => void;
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-function bar(cb: (arg: { unbound: () => void }) => void) {}
-bar(({ unbound } = new Foo()) => {});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+class Bar {
+  bound = () => 'bar';
+}
+function foo({ bound }: Foo & Bar) {}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-for (const { unbound } of [new Foo(), new Foo()]) {
-}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+declare const { unbound }: Foo;
+    `,
+    "declare const { unbound } = '***';",
+    `
 class Foo {
   unbound = function () {};
-
-  foo({ unbound }: Foo) {}
 }
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = (a: (b: (c: ({ unbound }: Foo) => void) => void) => void) => void;
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
 class Bar {
-  unbound = function () {};
+  property: ({ unbound }: Foo) => void;
 }
-function foo({ unbound }: Foo | Bar) {}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-function foo({ unbound }: { unbound: () => string } | Foo) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo<T extends ({ unbound }: Foo) => void>() {}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
+abstract class Bar {
+  abstract foo({ unbound }: Foo);
 }
-function foo({ unbound }: Foo | Bar) {}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-const foo = ({ unbound }: Foo & { foo: () => 'bar' }) => {};
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+declare class Bar {
+  foo({ unbound }: Foo);
+}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
-}
-const foo = ({ unbound }: (Foo & { foo: () => 'bar' }) | Bar) => {};
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+declare function foo({ unbound }: Foo);
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
+interface Bar {
+  foo: ({ unbound }: Foo) => void;
 }
-const foo = ({ unbound }: Foo & Bar) => {};
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   unbound = function () {};
-
-  other = function () {};
 }
-class Bar {
-  unbound = () => {};
+interface Bar {
+  foo({ unbound }: Foo): void;
 }
-const foo = ({ unbound, ...rest }: Foo & Bar) => {};
-      `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: 'const { unbound } = { unbound: function () {} };',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-function foo(
-  { unbound }: { unbound: () => void } = { unbound: function () {} },
-) {}
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
-  floor = function () {};
-}
-
-const { floor } = Math.random() > 0.5 ? new Foo() : Math;
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class CommunicationError {
-  foo() {}
-}
-const { foo } = CommunicationError.prototype;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class CommunicationError {
-  foo() {}
+  unbound = function () {};
 }
-let foo;
-({ foo } = CommunicationError.prototype);
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-import { console } from './class';
-const { log } = console;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: 'const { all } = Promise;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1866
-    {
-      code: `
-class BaseClass {
-  logThis() {}
+interface Bar {
+  new ({ unbound }: Foo): Foo;
 }
-class OtherClass extends BaseClass {
-  constructor() {
-    super();
-    const x = super.logThis;
-  }
+    `,
+    `
+class Foo {
+  unbound = function () {};
 }
-      `,
-      errors: [
-        {
-          line: 8,
-          column: 15,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
+type foo = new ({ unbound }: Foo) => void;
+    `,
+    'const { unbound } = { unbound: () => {} };',
+    'function foo({ unbound }: { unbound: () => void } = { unbound: () => {} }) {}',
     // https://github.com/typescript-eslint/typescript-eslint/issues/1866
-    {
-      code: `
+    `
 class BaseClass {
+  x: number = 42;
   logThis() {}
 }
 class OtherClass extends BaseClass {
+  superLogThis: any;
   constructor() {
     super();
-    let x;
-    x = super.logThis;
+    this.superLogThis = super.logThis;
   }
 }
-      `,
-      errors: [
-        {
-          line: 9,
-          column: 9,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-const values = {
-  a() {},
-  b: () => {},
-};
-
-const { a, b } = values;
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 9,
-          endColumn: 10,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-const values = {
-  a() {},
-  b: () => {},
-};
-
-const { a: c } = values;
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 9,
-          endColumn: 10,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-const values = {
-  a() {},
-  b: () => {},
-};
-
-const { b, a } = values;
-      `,
-      errors: [
-        {
-          line: 7,
-          column: 12,
-          endColumn: 13,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8636
-    {
-      code: `
-const objectLiteral = {
-  f: function () {},
-};
-const f = objectLiteral.f;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
+const oc = new OtherClass();
+oc.superLogThis();
+    `,
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
index 39a95fa53e39..e37768875fc5 100644
--- a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
@@ -9,218 +9,6 @@ import rule from '../../src/rules/unified-signatures';
 const ruleTester = new RuleTester();
 
 ruleTester.run('unified-signatures', rule, {
-  valid: [
-    `
-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) {}
-
-  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;
-}
-    `,
-    // No error for different return types.
-    `
-interface I {
-  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;
-}
-    `,
-    // No error if one is a rest parameter and other isn't.
-    `
-interface I {
-  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;
-}
-    `,
-    // No error if one is optional and the other isn't.
-    `
-interface I {
-  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;
-}
-    `,
-    // No conflict between static/non-static members.
-    `
-declare class D {
-  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;
-}
-    `,
-    // Allow signatures if the type is not equal.
-    `
-interface I {
-  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' {
-  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;
-  }
-}
-    `,
-    `
-export interface Foo {
-  bar(baz: string): number[];
-  bar(): string[];
-}
-    `,
-    `
-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;
-}
-    `,
-    `
-interface I {
-  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;
-}
-    `,
-    {
-      code: `
-function f(a: number): void;
-function f(b: string): void;
-function f(a: number | string): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(m: number): void;
-function f(v: number, u: string): void;
-function f(v: number, u?: string): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: boolean): number;
-function f(): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: boolean, u: boolean): number;
-function f(v: boolean): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: number, u?: string): void {}
-function f(v: number): void;
-function f(): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(a: boolean, ...c: number[]): void;
-function f(a: boolean, ...d: string[]): void;
-function f(a: boolean, ...c: (number | string)[]): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-class C {
-  constructor();
-  constructor(a: number, b: number);
-  constructor(c?: number, b?: number) {}
-
-  a(): void;
-  a(a: number, b: number): void;
-  a(a?: number, d?: number): void {}
-}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-  ],
   invalid: [
     {
       code: `
@@ -230,7 +18,7 @@ function f(a: number | string): void {}
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 12,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -238,7 +26,7 @@ function f(a: number | string): void {}
             type2: 'string',
           },
           line: 3,
-          column: 12,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -252,7 +40,7 @@ function f(x: any): any {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 12,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -260,7 +48,7 @@ function f(x: any): any {
             type2: 'string',
           },
           line: 3,
-          column: 12,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -274,7 +62,7 @@ function f(x: any): any {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 12,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -282,7 +70,7 @@ function f(x: any): any {
             type2: 'string',
           },
           line: 3,
-          column: 12,
+          messageId: 'singleParameterDifference',
         },
       ],
       options: [{ ignoreDifferentlyNamedParameters: true }],
@@ -295,13 +83,13 @@ function opt(...args: any[]) {}
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 28,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 3,
-          column: 28,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -316,13 +104,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 6,
           data: {
             failureStringStart:
               'This overload and the one on line 3 can be combined into one signature',
           },
           line: 5,
-          column: 6,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -337,13 +125,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 6,
           data: {
             failureStringStart:
               'This overload and the one on line 3 can be combined into one signature',
           },
           line: 5,
-          column: 6,
+          messageId: 'omittingSingleParameter',
         },
       ],
       options: [{ ignoreDifferentlyNamedParameters: true }],
@@ -358,13 +146,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 6,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 6,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -378,13 +166,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingRestParameter',
+          column: 29,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 29,
+          messageId: 'omittingRestParameter',
         },
       ],
     },
@@ -398,13 +186,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingRestParameter',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 5,
+          messageId: 'omittingRestParameter',
         },
       ],
     },
@@ -418,13 +206,13 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 5,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -438,7 +226,7 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 6,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -446,7 +234,7 @@ interface I {
             type2: 'string',
           },
           line: 4,
-          column: 6,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -460,7 +248,7 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -468,7 +256,7 @@ interface I {
             type2: 'string',
           },
           line: 4,
-          column: 5,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -482,13 +270,13 @@ type T = {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 4,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 4,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -502,13 +290,13 @@ declare class C {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 15,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 15,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -522,7 +310,7 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -530,7 +318,7 @@ interface I {
             type2: 'string | boolean',
           },
           line: 4,
-          column: 5,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -544,7 +332,7 @@ interface I {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -552,7 +340,7 @@ interface I {
             type2: '[string, boolean]',
           },
           line: 4,
-          column: 5,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -565,7 +353,7 @@ interface Generic<T> {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 5,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -573,7 +361,7 @@ interface Generic<T> {
             type2: 'T',
           },
           line: 4,
-          column: 5,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -585,7 +373,7 @@ function f<T>(x: T): void;
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 15,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -593,7 +381,7 @@ function f<T>(x: T): void;
             type2: 'T',
           },
           line: 3,
-          column: 15,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -605,7 +393,7 @@ function f<T extends number>(x: T): void;
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 30,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -613,7 +401,7 @@ function f<T extends number>(x: T): void;
             type2: 'T',
           },
           line: 3,
-          column: 30,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -627,7 +415,7 @@ abstract class Foo {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 21,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -635,7 +423,7 @@ abstract class Foo {
             type2: 'string',
           },
           line: 4,
-          column: 21,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -649,7 +437,7 @@ interface Foo {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 7,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -657,7 +445,7 @@ interface Foo {
             type2: 'number',
           },
           line: 4,
-          column: 7,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -671,7 +459,7 @@ interface Foo {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 8,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -679,7 +467,7 @@ interface Foo {
             type2: 'number',
           },
           line: 4,
-          column: 8,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -697,7 +485,7 @@ interface IFoo {
       `,
       errors: [
         {
-          messageId: 'singleParameterDifference',
+          column: 15,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
@@ -705,7 +493,7 @@ interface IFoo {
             type2: 'number',
           },
           line: 8,
-          column: 15,
+          messageId: 'singleParameterDifference',
         },
       ],
     },
@@ -716,13 +504,13 @@ export function foo(line: number, character?: number): number;
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 35,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 3,
-          column: 35,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -733,13 +521,13 @@ export function foo(line: number, character?: number): number;
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
+          column: 35,
           data: {
             failureStringStart:
               'These overloads can be combined into one signature',
           },
           line: 3,
-          column: 35,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -752,9 +540,9 @@ declare module 'foo' {
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
-          line: 4,
           column: 41,
+          line: 4,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
@@ -765,11 +553,223 @@ export default function (foo: number, bar?: string): string[];
       `,
       errors: [
         {
-          messageId: 'omittingSingleParameter',
-          line: 3,
           column: 39,
+          line: 3,
+          messageId: 'omittingSingleParameter',
         },
       ],
     },
   ],
+  valid: [
+    `
+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) {}
+
+  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;
+}
+    `,
+    // No error for different return types.
+    `
+interface I {
+  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;
+}
+    `,
+    // No error if one is a rest parameter and other isn't.
+    `
+interface I {
+  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;
+}
+    `,
+    // No error if one is optional and the other isn't.
+    `
+interface I {
+  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;
+}
+    `,
+    // No conflict between static/non-static members.
+    `
+declare class D {
+  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;
+}
+    `,
+    // Allow signatures if the type is not equal.
+    `
+interface I {
+  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' {
+  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;
+  }
+}
+    `,
+    `
+export interface Foo {
+  bar(baz: string): number[];
+  bar(): string[];
+}
+    `,
+    `
+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;
+}
+    `,
+    `
+interface I {
+  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;
+}
+    `,
+    {
+      code: `
+function f(a: number): void;
+function f(b: string): void;
+function f(a: number | string): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(m: number): void;
+function f(v: number, u: string): void;
+function f(v: number, u?: string): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: boolean): number;
+function f(): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: boolean, u: boolean): number;
+function f(v: boolean): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: number, u?: string): void {}
+function f(v: number): void;
+function f(): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(a: boolean, ...c: number[]): void;
+function f(a: boolean, ...d: string[]): void;
+function f(a: boolean, ...c: (number | string)[]): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+class C {
+  constructor();
+  constructor(a: number, b: number);
+  constructor(c?: number, b?: number) {}
+
+  a(): void;
+  a(a: number, b: number): void;
+  a(a?: number, d?: number): void {}
+}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts b/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
index 263092f1f92f..ea562abf6494 100644
--- a/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
+++ b/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
@@ -8,163 +8,13 @@ const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootDir,
       project: './tsconfig.json',
+      tsconfigRootDir: rootDir,
     },
   },
 });
 
 ruleTester.run('use-unknown-in-catch-callback-variable', rule, {
-  valid: [
-    `
-      Promise.resolve().catch((err: unknown) => {
-        throw err;
-      });
-    `,
-    `
-      let x = Math.random() ? 'ca' + 'tch' : 'catch';
-      Promise.resolve()[x]((err: Error) => {});
-    `,
-    `
-      Promise.resolve().then(
-        () => {},
-        (err: unknown) => {
-          throw err;
-        },
-      );
-    `,
-    `
-      Promise.resolve().catch(() => {
-        throw new Error();
-      });
-    `,
-    `
-      Promise.reject(new Error()).catch("not this rule's problem");
-    `,
-    `
-      declare const crappyHandler: (() => void) | 2;
-      Promise.reject(new Error()).catch(crappyHandler);
-    `,
-
-    `
-      Promise.resolve().catch((...args: [unknown]) => {
-        throw args[0];
-      });
-    `,
-    `
-      Promise.resolve().catch((...args: [a: unknown]) => {
-        const err = args[0];
-      });
-    `,
-
-    `
-      Promise.resolve().catch((...args: readonly unknown[]) => {
-        throw args[0];
-      });
-    `,
-
-    `
-      declare const notAPromise: { catch: (f: Function) => void };
-      notAPromise.catch((...args: [a: string, string]) => {
-        throw args[0];
-      });
-    `,
-    `
-      declare const catchArgs: [(x: unknown) => void];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-
-    `
-      declare const catchArgs: [
-        string | (() => never),
-        (shouldntFlag: string) => void,
-        number,
-      ];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-      declare const catchArgs: ['not callable'];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-      declare const emptySpread: [];
-      Promise.reject(new Error()).catch(...emptySpread);
-    `,
-    `
-      Promise.resolve().catch(
-        (
-          ...err: [unknown, string | ((number | unknown) & { b: () => void }), string]
-        ) => {
-          throw err;
-        },
-      );
-    `,
-    `
-      declare const notAMemberExpression: (...args: any[]) => {};
-      notAMemberExpression(
-        'This helps get 100% code cov',
-        "but doesn't test anything useful related to the rule.",
-      );
-    `,
-    `
-      Promise.resolve().catch((...[args]: [unknown]) => {
-        console.log(args);
-      });
-    `,
-    `
-      Promise.resolve().catch((...{ find }: [unknown]) => {
-        console.log(find);
-      });
-    `,
-    'Promise.resolve.then();',
-    'Promise.resolve().then(() => {});',
-    `
-      declare const singleTupleArg: [() => void];
-      Promise.resolve().then(...singleTupleArg, (error: unknown) => {});
-    `,
-    `
-      declare const arrayArg: (() => void)[];
-      Promise.resolve().then(...arrayArg, error => {});
-    `,
-    `
-declare let iPromiseImAPromise: Promise<any>;
-declare const catchArgs: [(x: any) => void];
-iPromiseImAPromise.catch(...catchArgs);
-    `,
-    `
-declare const catchArgs: [
-  string | (() => never) | ((x: string) => void),
-  number,
-];
-Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-declare const you: [];
-declare const cannot: [];
-declare const fool: [];
-declare const me: [(x: Error) => void] | undefined;
-Promise.resolve(undefined).catch(...you, ...cannot, ...fool, ...me!);
-    `,
-    `
-declare const really: undefined[];
-declare const dumb: [];
-declare const code: (x: Error) => void;
-Promise.resolve(undefined).catch(...really, ...dumb, code);
-    `,
-    `
-declare const x: ((x: any) => string)[];
-Promise.resolve('string promise').catch(...x);
-    `,
-    `
-declare const x: any;
-Promise.resolve().catch(...x);
-    `,
-    `
-declare const thenArgs: [() => {}, (err: any) => {}];
-Promise.resolve().then(...thenArgs);
-    `,
-  ],
-
   invalid: [
     {
       code: `
@@ -749,4 +599,154 @@ Promise.resolve().catch((...{ find }: [unknown]) => {
       ],
     },
   ],
+
+  valid: [
+    `
+      Promise.resolve().catch((err: unknown) => {
+        throw err;
+      });
+    `,
+    `
+      let x = Math.random() ? 'ca' + 'tch' : 'catch';
+      Promise.resolve()[x]((err: Error) => {});
+    `,
+    `
+      Promise.resolve().then(
+        () => {},
+        (err: unknown) => {
+          throw err;
+        },
+      );
+    `,
+    `
+      Promise.resolve().catch(() => {
+        throw new Error();
+      });
+    `,
+    `
+      Promise.reject(new Error()).catch("not this rule's problem");
+    `,
+    `
+      declare const crappyHandler: (() => void) | 2;
+      Promise.reject(new Error()).catch(crappyHandler);
+    `,
+
+    `
+      Promise.resolve().catch((...args: [unknown]) => {
+        throw args[0];
+      });
+    `,
+    `
+      Promise.resolve().catch((...args: [a: unknown]) => {
+        const err = args[0];
+      });
+    `,
+
+    `
+      Promise.resolve().catch((...args: readonly unknown[]) => {
+        throw args[0];
+      });
+    `,
+
+    `
+      declare const notAPromise: { catch: (f: Function) => void };
+      notAPromise.catch((...args: [a: string, string]) => {
+        throw args[0];
+      });
+    `,
+    `
+      declare const catchArgs: [(x: unknown) => void];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+
+    `
+      declare const catchArgs: [
+        string | (() => never),
+        (shouldntFlag: string) => void,
+        number,
+      ];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+      declare const catchArgs: ['not callable'];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+      declare const emptySpread: [];
+      Promise.reject(new Error()).catch(...emptySpread);
+    `,
+    `
+      Promise.resolve().catch(
+        (
+          ...err: [unknown, string | ((number | unknown) & { b: () => void }), string]
+        ) => {
+          throw err;
+        },
+      );
+    `,
+    `
+      declare const notAMemberExpression: (...args: any[]) => {};
+      notAMemberExpression(
+        'This helps get 100% code cov',
+        "but doesn't test anything useful related to the rule.",
+      );
+    `,
+    `
+      Promise.resolve().catch((...[args]: [unknown]) => {
+        console.log(args);
+      });
+    `,
+    `
+      Promise.resolve().catch((...{ find }: [unknown]) => {
+        console.log(find);
+      });
+    `,
+    'Promise.resolve.then();',
+    'Promise.resolve().then(() => {});',
+    `
+      declare const singleTupleArg: [() => void];
+      Promise.resolve().then(...singleTupleArg, (error: unknown) => {});
+    `,
+    `
+      declare const arrayArg: (() => void)[];
+      Promise.resolve().then(...arrayArg, error => {});
+    `,
+    `
+declare let iPromiseImAPromise: Promise<any>;
+declare const catchArgs: [(x: any) => void];
+iPromiseImAPromise.catch(...catchArgs);
+    `,
+    `
+declare const catchArgs: [
+  string | (() => never) | ((x: string) => void),
+  number,
+];
+Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+declare const you: [];
+declare const cannot: [];
+declare const fool: [];
+declare const me: [(x: Error) => void] | undefined;
+Promise.resolve(undefined).catch(...you, ...cannot, ...fool, ...me!);
+    `,
+    `
+declare const really: undefined[];
+declare const dumb: [];
+declare const code: (x: Error) => void;
+Promise.resolve(undefined).catch(...really, ...dumb, code);
+    `,
+    `
+declare const x: ((x: any) => string)[];
+Promise.resolve('string promise').catch(...x);
+    `,
+    `
+declare const x: any;
+Promise.resolve().catch(...x);
+    `,
+    `
+declare const thenArgs: [() => {}, (err: any) => {}];
+Promise.resolve().then(...thenArgs);
+    `,
+  ],
 });
diff --git a/packages/eslint-plugin/tests/schemas.test.ts b/packages/eslint-plugin/tests/schemas.test.ts
index acb93bb3f4ea..a02852c7e777 100644
--- a/packages/eslint-plugin/tests/schemas.test.ts
+++ b/packages/eslint-plugin/tests/schemas.test.ts
@@ -1,9 +1,7 @@
+import { compile } from '@typescript-eslint/rule-schema-to-typescript-types';
 import 'jest-specific-snapshot';
-
 import fs from 'node:fs';
 import path from 'node:path';
-
-import { compile } from '@typescript-eslint/rule-schema-to-typescript-types';
 import prettier from 'prettier';
 
 import rules from '../src/rules/index';
@@ -188,8 +186,8 @@ describe('Rule schemas should validate options correctly', () => {
   // This override allows providing example valid options for rules which don't
   // accept their defaults.
   const overrideValidOptions: Record<string, unknown> = {
-    semi: ['never'],
     'func-call-spacing': ['never'],
+    semi: ['never'],
   };
 
   for (const [ruleName, rule] of Object.entries(rules)) {
diff --git a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
index aa1083a4d4e8..c22f9f9a3216 100644
--- a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
@@ -1,5 +1,6 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
 import type { TSESTree } from '@typescript-eslint/utils';
+
+import { RuleTester } from '@typescript-eslint/rule-tester';
 import * as ts from 'typescript';
 
 import {
@@ -14,35 +15,18 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 const removeFunctionRule = createRule({
-  name: 'remove-function',
-  defaultOptions: [],
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description:
-        'Remove function with first arg remaining in random places for test purposes.',
-    },
-    messages: {
-      removeFunction: 'Please remove this function',
-    },
-    schema: [],
-  },
-
   create(context) {
     const parserServices = getParserServices(context, true);
 
     const report = (node: TSESTree.CallExpression): void => {
       context.report({
-        node,
-        messageId: 'removeFunction',
         fix: fixer => {
           const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
           const tsArgumentNode = tsNode.arguments[0];
@@ -66,6 +50,8 @@ const removeFunctionRule = createRule({
             getWrappedCode(text, nodePrecedence, parentPrecedence),
           );
         },
+        messageId: 'removeFunction',
+        node,
       });
     };
 
@@ -73,10 +59,24 @@ const removeFunctionRule = createRule({
       'CallExpression[callee.name="fn"]': report,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Remove function with first arg remaining in random places for test purposes.',
+    },
+    fixable: 'code',
+    messages: {
+      removeFunction: 'Please remove this function',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'remove-function',
 });
 
 ruleTester.run('getWrappedCode - removeFunctionRule', removeFunctionRule, {
-  valid: [],
   invalid: [
     // should add parens when the first argument node has lower precedence than the parent node of the CallExpression
     {
@@ -92,4 +92,5 @@ ruleTester.run('getWrappedCode - removeFunctionRule', removeFunctionRule, {
       output: 'const a = { x: "wrapObject" }',
     },
   ],
+  valid: [],
 });
diff --git a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
index 68c433715d5d..1dd7a2b929e8 100644
--- a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
@@ -1,6 +1,7 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
 import type { TSESTree } from '@typescript-eslint/utils';
 
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { createRule, getWrappingFixer } from '../../src/util';
 import { getFixturesRootDir } from '../RuleTester';
 
@@ -8,53 +9,52 @@ const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 const voidEverythingRule = createRule({
-  name: 'void-everything',
-  defaultOptions: [],
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description: 'Add void operator in random places for test purposes.',
-    },
-    messages: {
-      addVoid: 'Please void this',
-    },
-    schema: [],
-  },
-
   create(context) {
     const report = (node: TSESTree.Node): void => {
       context.report({
-        node,
-        messageId: 'addVoid',
         fix: getWrappingFixer({
-          sourceCode: context.sourceCode,
           node,
+          sourceCode: context.sourceCode,
           wrap: code => `void ${code.replaceAll('wrap', 'wrapped')}`,
         }),
+        messageId: 'addVoid',
+        node,
       });
     };
 
     return {
+      'ArrayExpression[elements.0.value="wrapArray"]': report,
+      'ClassExpression[id.name="wrapClass"]': report,
+      'FunctionExpression[id.name="wrapFunction"]': report,
       'Identifier[name="wrapMe"]': report,
       'Literal[value="wrapMe"]': report,
-      'ArrayExpression[elements.0.value="wrapArray"]': report,
       'ObjectExpression[properties.0.value.value="wrapObject"]': report,
-      'FunctionExpression[id.name="wrapFunction"]': report,
-      'ClassExpression[id.name="wrapClass"]': report,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Add void operator in random places for test purposes.',
+    },
+    fixable: 'code',
+    messages: {
+      addVoid: 'Please void this',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'void-everything',
 });
 
 ruleTester.run('getWrappingFixer - voidEverythingRule', voidEverythingRule, {
-  valid: [],
   invalid: [
     // should add parens when inner expression might need them
     {
@@ -286,35 +286,21 @@ ruleTester.run('getWrappingFixer - voidEverythingRule', voidEverythingRule, {
       `,
     },
   ],
+  valid: [],
 });
 
 const removeFunctionRule = createRule({
-  name: 'remove-function',
-  defaultOptions: [],
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description:
-        'Remove function with first arg remaining in random places for test purposes.',
-    },
-    messages: {
-      removeFunction: 'Please remove this function',
-    },
-    schema: [],
-  },
-
   create(context) {
     const report = (node: TSESTree.CallExpression): void => {
       context.report({
-        node,
-        messageId: 'removeFunction',
         fix: getWrappingFixer({
-          sourceCode: context.sourceCode,
-          node,
           innerNode: [node.arguments[0]],
+          node,
+          sourceCode: context.sourceCode,
           wrap: code => code,
         }),
+        messageId: 'removeFunction',
+        node,
       });
     };
 
@@ -322,10 +308,24 @@ const removeFunctionRule = createRule({
       'CallExpression[callee.name="fn"]': report,
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description:
+        'Remove function with first arg remaining in random places for test purposes.',
+    },
+    fixable: 'code',
+    messages: {
+      removeFunction: 'Please remove this function',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'remove-function',
 });
 
 ruleTester.run('getWrappingFixer - removeFunctionRule', removeFunctionRule, {
-  valid: [],
   invalid: [
     // should add parens when a inner node is a part of return body of node's parent
     {
@@ -346,4 +346,5 @@ ruleTester.run('getWrappingFixer - removeFunctionRule', removeFunctionRule, {
       output: '() => "string"',
     },
   ],
+  valid: [],
 });
diff --git a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
index 3a92f8d28c37..1177b1ac44bb 100644
--- a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
+++ b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
@@ -1,31 +1,16 @@
-import { RuleTester } from '@typescript-eslint/rule-tester';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 
+import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { createRule, isNodeEqual } from '../../src/util';
 import { getFixturesRootDir } from '../RuleTester';
 
 const rule = createRule({
-  name: 'no-useless-expression',
-  defaultOptions: [],
-  meta: {
-    type: 'suggestion',
-    fixable: 'code',
-    docs: {
-      description: 'Remove useless expressions.',
-    },
-    messages: {
-      removeExpression: 'Remove useless expression',
-    },
-    schema: [],
-  },
-
   create(context) {
     return {
       LogicalExpression: (node: TSESTree.LogicalExpression): void => {
         if (isNodeEqual(node.left, node.right)) {
           context.report({
-            node,
-            messageId: 'removeExpression',
             fix(fixer: TSESLint.RuleFixer): TSESLint.RuleFix {
               return fixer.replaceText(
                 node,
@@ -35,30 +20,40 @@ const rule = createRule({
                 ),
               );
             },
+            messageId: 'removeExpression',
+            node,
           });
         }
       },
     };
   },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Remove useless expressions.',
+    },
+    fixable: 'code',
+    messages: {
+      removeExpression: 'Remove useless expression',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+
+  name: 'no-useless-expression',
 });
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
-      tsconfigRootDir: rootPath,
       project: './tsconfig.json',
+      tsconfigRootDir: rootPath,
     },
   },
 });
 
 ruleTester.run('isNodeEqual', rule, {
-  valid: [
-    { code: 'a || b' },
-    { code: '!true || true' },
-    { code: 'a() || a()' },
-    { code: 'foo.bar || foo.bar.foo' },
-  ],
   invalid: [
     {
       code: 'undefined || undefined',
@@ -101,4 +96,10 @@ ruleTester.run('isNodeEqual', rule, {
       output: 'x.z[1][this[this.o]]["3"][a.b.c]',
     },
   ],
+  valid: [
+    { code: 'a || b' },
+    { code: '!true || true' },
+    { code: 'a() || a()' },
+    { code: 'foo.bar || foo.bar.foo' },
+  ],
 });
diff --git a/packages/eslint-plugin/typings/eslint-rules.d.ts b/packages/eslint-plugin/typings/eslint-rules.d.ts
index a608423db3ee..0b39f36da45f 100644
--- a/packages/eslint-plugin/typings/eslint-rules.d.ts
+++ b/packages/eslint-plugin/typings/eslint-rules.d.ts
@@ -20,11 +20,11 @@ declare module 'eslint/use-at-your-own-risk' {
     'no-loop-func': typeof import('eslint/lib/rules/no-loop-func');
     'no-loss-of-precision': typeof import('eslint/lib/rules/no-loss-of-precision');
     'no-magic-numbers': typeof import('eslint/lib/rules/no-magic-numbers');
+    'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals');
     'no-restricted-imports': typeof import('eslint/lib/rules/no-restricted-imports');
     'no-undef': typeof import('eslint/lib/rules/no-undef');
     'no-unused-expressions': typeof import('eslint/lib/rules/no-unused-expressions');
     'no-useless-constructor': typeof import('eslint/lib/rules/no-useless-constructor');
-    'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals');
     'prefer-const': typeof import('eslint/lib/rules/prefer-const');
     'prefer-destructuring': typeof import('eslint/lib/rules/prefer-destructuring');
     strict: typeof import('eslint/lib/rules/strict');
@@ -70,12 +70,12 @@ declare module 'eslint/lib/rules/consistent-return' {
     ],
     unknown,
     {
-      ReturnStatement(node: TSESTree.ReturnStatement): void;
-      'FunctionDeclaration:exit'(node: TSESTree.FunctionDeclaration): void;
-      'FunctionExpression:exit'(node: TSESTree.FunctionExpression): void;
       'ArrowFunctionExpression:exit'(
         node: TSESTree.ArrowFunctionExpression,
       ): void;
+      'FunctionDeclaration:exit'(node: TSESTree.FunctionDeclaration): void;
+      'FunctionExpression:exit'(node: TSESTree.FunctionExpression): void;
+      ReturnStatement(node: TSESTree.ReturnStatement): void;
     }
   >;
   export = rule;
@@ -89,9 +89,9 @@ declare module 'eslint/lib/rules/camelcase' {
     [
       {
         allow?: string[];
+        genericType?: 'always' | 'never';
         ignoreDestructuring?: boolean;
         properties?: 'always' | 'never';
-        genericType?: 'always' | 'never';
       },
     ],
     unknown,
@@ -107,14 +107,14 @@ declare module 'eslint/lib/rules/max-params' {
   const rule: TSESLint.RuleModule<
     'exceed',
     (
-      | { max: number; countVoidThis?: boolean }
-      | { maximum: number; countVoidThis?: boolean }
+      | { countVoidThis?: boolean; max: number }
+      | { countVoidThis?: boolean; maximum: number }
     )[],
     unknown,
     {
+      ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
       FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
       FunctionExpression(node: TSESTree.FunctionExpression): void;
-      ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
     }
   >;
   export = rule;
@@ -128,12 +128,12 @@ declare module 'eslint/lib/rules/no-dupe-class-members' {
     [],
     unknown,
     {
-      Program(): void;
-      ClassBody(): void;
       'ClassBody:exit'(): void;
       'MethodDefinition, PropertyDefinition'(
         node: TSESTree.MethodDefinition | TSESTree.PropertyDefinition,
       ): void;
+      ClassBody(): void;
+      Program(): void;
     }
   >;
   export = rule;
@@ -200,8 +200,8 @@ declare module 'eslint/lib/rules/no-loop-func' {
     unknown,
     {
       ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
-      FunctionExpression(node: TSESTree.FunctionExpression): void;
       FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
+      FunctionExpression(node: TSESTree.FunctionExpression): void;
     }
   >;
   export = rule;
@@ -214,12 +214,12 @@ declare module 'eslint/lib/rules/no-magic-numbers' {
     'noMagic',
     [
       {
+        detectObjects?: boolean;
+        enforceConst?: boolean;
         ignore?: (number | string)[];
         ignoreArrayIndexes?: boolean;
-        enforceConst?: boolean;
-        detectObjects?: boolean;
-        ignoreNumericLiteralTypes?: boolean;
         ignoreEnums?: boolean;
+        ignoreNumericLiteralTypes?: boolean;
         ignoreReadonlyClassProperties?: boolean;
         ignoreTypeIndexes?: boolean;
       },
@@ -256,11 +256,11 @@ declare module 'eslint/lib/rules/no-restricted-globals' {
   const rule: TSESLint.RuleModule<
     'customMessage' | 'defaultMessage',
     (
-      | string
       | {
-          name: string;
           message?: string;
+          name: string;
         }
+      | string
     )[],
     unknown,
     {
@@ -277,9 +277,9 @@ declare module 'eslint/lib/rules/no-shadow' {
     'noShadow',
     [
       {
+        allow?: string[];
         builtinGlobals?: boolean;
         hoist?: 'all' | 'functions' | 'never';
-        allow?: string[];
         ignoreOnInitialization?: boolean;
       },
     ],
@@ -318,14 +318,14 @@ declare module 'eslint/lib/rules/no-unused-vars' {
       | 'all'
       | 'local'
       | {
-          vars?: 'all' | 'local';
-          varsIgnorePattern?: string;
           args?: 'after-used' | 'all' | 'none';
-          ignoreRestSiblings?: boolean;
           argsIgnorePattern?: string;
           caughtErrors?: 'all' | 'none';
           caughtErrorsIgnorePattern?: string;
           destructuredArrayIgnorePattern?: string;
+          ignoreRestSiblings?: boolean;
+          vars?: 'all' | 'local';
+          varsIgnorePattern?: string;
         },
     ],
     unknown,
@@ -344,8 +344,8 @@ declare module 'eslint/lib/rules/no-unused-expressions' {
     [
       {
         allowShortCircuit?: boolean;
-        allowTernary?: boolean;
         allowTaggedTemplates?: boolean;
+        allowTernary?: boolean;
       },
     ],
     unknown,
@@ -364,8 +364,8 @@ declare module 'eslint/lib/rules/no-use-before-define' {
     (
       | 'nofunc'
       | {
-          functions?: boolean;
           classes?: boolean;
+          functions?: boolean;
           variables?: boolean;
         }
     )[],
@@ -458,11 +458,11 @@ declare module 'eslint/lib/rules/dot-notation' {
     'useBrackets' | 'useDot',
     [
       {
+        allowIndexSignaturePropertyAccess?: boolean;
         allowKeywords?: boolean;
         allowPattern?: string;
         allowPrivateClassPropertyAccess?: boolean;
         allowProtectedClassPropertyAccess?: boolean;
-        allowIndexSignaturePropertyAccess?: boolean;
       },
     ],
     unknown,
@@ -511,15 +511,15 @@ declare module 'eslint/lib/rules/prefer-destructuring' {
   import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 
   interface DestructuringTypeConfig {
-    object?: boolean;
     array?: boolean;
+    object?: boolean;
   }
   type Option0 =
-    | DestructuringTypeConfig
     | {
-        VariableDeclarator?: DestructuringTypeConfig;
         AssignmentExpression?: DestructuringTypeConfig;
-      };
+        VariableDeclarator?: DestructuringTypeConfig;
+      }
+    | DestructuringTypeConfig;
   interface Option1 {
     enforceForRenamedProperties?: boolean;
   }
@@ -528,8 +528,8 @@ declare module 'eslint/lib/rules/prefer-destructuring' {
     [Option0, Option1?],
     unknown,
     {
-      VariableDeclarator(node: TSESTree.VariableDeclarator): void;
       AssignmentExpression(node: TSESTree.AssignmentExpression): void;
+      VariableDeclarator(node: TSESTree.VariableDeclarator): void;
     }
   >;
   export = rule;
@@ -539,31 +539,31 @@ declare module 'eslint/lib/rules/no-restricted-imports' {
 
   namespace rule {
     export type ArrayOfStringOrObject = (
-      | string
       | {
-          name: string;
-          message?: string;
-          importNames?: string[];
           // extended
           allowTypeImports?: boolean;
+          importNames?: string[];
+          message?: string;
+          name: string;
         }
+      | string
     )[];
     export type ArrayOfStringOrObjectPatterns =
       | {
-          group: string[];
-          message?: string;
-          caseSensitive?: boolean;
           // extended
           allowTypeImports?: boolean;
+          caseSensitive?: boolean;
+          group: string[];
+          message?: string;
         }[]
       | string[];
     export type RuleListener =
-      | Record<string, never>
       | {
-          ImportDeclaration(node: TSESTree.ImportDeclaration): void;
-          ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void;
           ExportAllDeclaration(node: TSESTree.ExportAllDeclaration): void;
-        };
+          ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void;
+          ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+        }
+      | Record<string, never>;
   }
 
   interface ObjectOfPathsAndPatterns {
@@ -580,7 +580,7 @@ declare module 'eslint/lib/rules/no-restricted-imports' {
     | 'pathWithCustomMessage'
     | 'patterns'
     | 'patternWithCustomMessage',
-    rule.ArrayOfStringOrObject | [ObjectOfPathsAndPatterns],
+    [ObjectOfPathsAndPatterns] | rule.ArrayOfStringOrObject,
     unknown,
     rule.RuleListener
   >;
diff --git a/packages/eslint-plugin/typings/typescript.d.ts b/packages/eslint-plugin/typings/typescript.d.ts
index 3579a04dc205..b79a51114d55 100644
--- a/packages/eslint-plugin/typings/typescript.d.ts
+++ b/packages/eslint-plugin/typings/typescript.d.ts
@@ -4,8 +4,15 @@ declare module 'typescript' {
   interface TypeChecker {
     // internal TS APIs
 
-    getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
+    /**
+     * Return the awaited type of the given type.
+     *
+     * TODO: Remove when it's exposed as a public API.
+     * https://github.com/microsoft/TypeScript/issues/59256
+     */
+    getAwaitedType(type: Type): Type | undefined;
 
+    getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
     /**
      * @returns `true` if the given type is an array type:
      * - `Array<foo>`
@@ -20,12 +27,5 @@ declare module 'typescript' {
      * - `readonly [foo]`
      */
     isTupleType(type: Type): type is TupleTypeReference;
-    /**
-     * Return the awaited type of the given type.
-     *
-     * TODO: Remove when it's exposed as a public API.
-     * https://github.com/microsoft/TypeScript/issues/59256
-     */
-    getAwaitedType(type: Type): Type | undefined;
   }
 }

From 06c6ece7e264eea3d4487eab84bacc34cce7f722 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Tue, 20 Aug 2024 15:35:58 -0400
Subject: [PATCH 02/13] Assorted cleanups

---
 .../eslint-plugin/src/rules/await-thenable.ts |  1 -
 .../src/rules/consistent-type-exports.ts      |  1 -
 .../src/rules/consistent-type-imports.ts      |  1 -
 .../eslint-plugin/src/rules/max-params.ts     |  1 -
 .../src/rules/member-ordering.ts              | 17 ++++++++--------
 .../src/rules/method-signature-style.ts       |  1 -
 .../src/rules/no-confusing-void-expression.ts |  1 -
 .../src/rules/no-floating-promises.ts         |  1 -
 .../src/rules/no-meaningless-void-operator.ts |  1 -
 .../src/rules/no-misused-promises.ts          |  1 -
 .../non-nullable-type-assertion-style.ts      |  1 -
 .../eslint-plugin/src/rules/prefer-find.ts    |  1 -
 .../src/rules/prefer-includes.ts              |  1 -
 .../src/rules/prefer-regexp-exec.ts           |  5 +++--
 .../src/rules/prefer-return-this-type.ts      |  1 -
 .../rules/prefer-string-starts-ends-with.ts   |  1 -
 .../src/rules/require-array-sort-compare.ts   |  1 -
 .../eslint-plugin/src/rules/return-await.ts   |  1 -
 .../use-unknown-in-catch-callback-variable.ts |  1 -
 .../schema-snapshots/member-ordering.shot     | 18 ++++++++---------
 .../schema-snapshots/naming-convention.shot   | 20 +++++++++----------
 .../tests/util/getWrappedCode.test.ts         |  1 -
 .../tests/util/getWrappingFixer.test.ts       |  2 --
 .../tests/util/isNodeEqual.test.ts            |  1 -
 24 files changed, 31 insertions(+), 50 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index 71c13ee2e2cc..507b8ededfe9 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -63,6 +63,5 @@ export default createRule({
     schema: [],
     type: 'problem',
   },
-
   name: 'await-thenable',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index f64d82053648..1a6041bee233 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -237,7 +237,6 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'suggestion',
   },
-
   name: 'consistent-type-exports',
 });
 
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index a46548d36adf..ad001e7aba02 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -942,6 +942,5 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'suggestion',
   },
-
   name: 'consistent-type-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index e72d88b75a31..9ac486e21c37 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -90,6 +90,5 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'suggestion',
   },
-
   name: 'max-params',
 });
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index 64e2220c8eab..20039baa01b2 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -1047,13 +1047,6 @@ export default createRule<Options, MessageIds>({
             enum: allMemberTypes as string[],
             type: 'string',
           },
-          baseConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/allItems'),
-              objectConfig('#/items/0/$defs/allItems'),
-            ],
-          },
           optionalityOrderOptions: {
             enum: ['optional-first', 'required-first'],
             type: 'string',
@@ -1068,7 +1061,6 @@ export default createRule<Options, MessageIds>({
             ],
             type: 'string',
           },
-
           typeItems: {
             enum: [
               'readonly-signature',
@@ -1080,6 +1072,15 @@ export default createRule<Options, MessageIds>({
             ],
             type: 'string',
           },
+
+          // These properties must follow the preceding ones for ajv logic.
+          baseConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/allItems'),
+              objectConfig('#/items/0/$defs/allItems'),
+            ],
+          },
           typesConfig: {
             oneOf: [
               neverConfig,
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index 2939dd242182..dd59ae538c13 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -239,6 +239,5 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'suggestion',
   },
-
   name: 'method-signature-style',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index a4fa1f6af727..4eb54e068417 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -377,6 +377,5 @@ export default createRule<Options, MessageId>({
     ],
     type: 'problem',
   },
-
   name: 'no-confusing-void-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 746d6aa740ea..6ad63ce2cc80 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -448,7 +448,6 @@ export default createRule<Options, MessageId>({
     ],
     type: 'problem',
   },
-
   name: 'no-floating-promises',
 });
 
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index d792a9a9338a..4a7de1f3c2f7 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -86,6 +86,5 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
     ],
     type: 'suggestion',
   },
-
   name: 'no-meaningless-void-operator',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index 014578519b65..5d4a4cdb8e3e 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -589,7 +589,6 @@ export default createRule<Options, MessageId>({
     ],
     type: 'problem',
   },
-
   name: 'no-misused-promises',
 });
 
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index 364c10053c19..f63b3a9c78fa 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -143,6 +143,5 @@ export default createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'non-nullable-type-assertion-style',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index 7b61e01b5160..1795d966cda5 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -319,7 +319,6 @@ export default createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'prefer-find',
 });
 
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index ddb58e74123e..3c905915bd19 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -264,6 +264,5 @@ export default createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'prefer-includes',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index 921308ab1c8e..73c95321cd26 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -13,10 +13,12 @@ import {
 } from '../util';
 
 enum ArgumentType {
-  Both = String | RegExp,
   Other = 0,
   RegExp = 1 << 1,
   String = 1 << 0,
+
+  // https://github.com/azat-io/eslint-plugin-perfectionist/issues/226
+  Both = String | RegExp,
 }
 
 export default createRule({
@@ -176,6 +178,5 @@ export default createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'prefer-regexp-exec',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 4e1099a7fe42..3d7b95137b6f 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -166,6 +166,5 @@ export default createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'prefer-return-this-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index 72ed3ae365f5..7c6d6c131f93 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -725,6 +725,5 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'suggestion',
   },
-
   name: 'prefer-string-starts-ends-with',
 });
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index dea7e1009985..2c8803525731 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -85,6 +85,5 @@ export default createRule<Options, MessageIds>({
     ],
     type: 'problem',
   },
-
   name: 'require-array-sort-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index 1562a58a80d9..e1e8b94fc2f4 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -395,7 +395,6 @@ export default createRule({
     ],
     type: 'problem',
   },
-
   name: 'return-await',
 });
 
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index a593693d2210..dd55fb4fbaa1 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -307,6 +307,5 @@ export default createRule<[], MessageIds>({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'use-unknown-in-catch-callback-variable',
 });
diff --git a/packages/eslint-plugin/tests/schema-snapshots/member-ordering.shot b/packages/eslint-plugin/tests/schema-snapshots/member-ordering.shot
index 658de4a1a19b..9aa7e76bd567 100644
--- a/packages/eslint-plugin/tests/schema-snapshots/member-ordering.shot
+++ b/packages/eslint-plugin/tests/schema-snapshots/member-ordering.shot
@@ -336,15 +336,6 @@ exports[`Rule schemas should be convertible to TS types for documentation purpos
 
 # TYPES:
 
-type OrderOptions =
-  | 'alphabetically'
-  | 'alphabetically-case-insensitive'
-  | 'as-written'
-  | 'natural'
-  | 'natural-case-insensitive';
-
-type OptionalityOrderOptions = 'optional-first' | 'required-first';
-
 type AllItems =
   | '#private-accessor'
   | '#private-field'
@@ -500,6 +491,15 @@ type AllItems =
   | 'static-set'
   | 'static-static-initialization';
 
+type OptionalityOrderOptions = 'optional-first' | 'required-first';
+
+type OrderOptions =
+  | 'alphabetically'
+  | 'alphabetically-case-insensitive'
+  | 'as-written'
+  | 'natural'
+  | 'natural-case-insensitive';
+
 type TypeItems =
   | 'constructor'
   | 'field'
diff --git a/packages/eslint-plugin/tests/schema-snapshots/naming-convention.shot b/packages/eslint-plugin/tests/schema-snapshots/naming-convention.shot
index 80a4f0e19e1c..e92e56897d88 100644
--- a/packages/eslint-plugin/tests/schema-snapshots/naming-convention.shot
+++ b/packages/eslint-plugin/tests/schema-snapshots/naming-convention.shot
@@ -1710,14 +1710,6 @@ exports[`Rule schemas should be convertible to TS types for documentation purpos
 
 # TYPES:
 
-type UnderscoreOptions =
-  | 'allow'
-  | 'allowDouble'
-  | 'allowSingleOrDouble'
-  | 'forbid'
-  | 'require'
-  | 'requireDouble';
-
 type PredefinedFormats =
   | 'PascalCase'
   | 'StrictPascalCase'
@@ -1728,14 +1720,22 @@ type PredefinedFormats =
 
 type TypeModifiers = 'array' | 'boolean' | 'function' | 'number' | 'string';
 
-type PrefixSuffixConfig = string[];
+type UnderscoreOptions =
+  | 'allow'
+  | 'allowDouble'
+  | 'allowSingleOrDouble'
+  | 'forbid'
+  | 'require'
+  | 'requireDouble';
+
+type FormatOptionsConfig = PredefinedFormats[] | null;
 
 type MatchRegexConfig = {
   match: boolean;
   regex: string;
 };
 
-type FormatOptionsConfig = PredefinedFormats[] | null;
+type PrefixSuffixConfig = string[];
 
 type Options = /** Multiple selectors in one config */
 (| {
diff --git a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
index c22f9f9a3216..45c8634b1994 100644
--- a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
@@ -72,7 +72,6 @@ const removeFunctionRule = createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'remove-function',
 });
 
diff --git a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
index 1dd7a2b929e8..af30ec1dd4d6 100644
--- a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
@@ -50,7 +50,6 @@ const voidEverythingRule = createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'void-everything',
 });
 
@@ -321,7 +320,6 @@ const removeFunctionRule = createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'remove-function',
 });
 
diff --git a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
index 1177b1ac44bb..4763c9b73070 100644
--- a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
+++ b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
@@ -39,7 +39,6 @@ const rule = createRule({
     schema: [],
     type: 'suggestion',
   },
-
   name: 'no-useless-expression',
 });
 

From 976a7faf13e101c50e645a86cc96b6c3165c1b17 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Sun, 8 Sep 2024 22:29:44 -0400
Subject: [PATCH 03/13] type, meta, defaultOptions, create ordering

---
 eslint.config.mjs                             | 41 +++++++++---------
 .../src/rules/adjacent-overload-signatures.ts |  8 ++--
 .../eslint-plugin/src/rules/array-type.ts     | 12 +++---
 .../eslint-plugin/src/rules/await-thenable.ts |  2 +-
 .../eslint-plugin/src/rules/ban-ts-comment.ts | 12 +++---
 .../src/rules/ban-tslint-comment.ts           |  2 +-
 .../src/rules/class-literal-property-style.ts |  4 +-
 .../src/rules/class-methods-use-this.ts       | 14 +++----
 .../rules/consistent-generic-constructors.ts  |  4 +-
 .../rules/consistent-indexed-object-style.ts  |  4 +-
 .../src/rules/consistent-return.ts            |  2 +-
 .../src/rules/consistent-type-assertions.ts   | 12 +++---
 .../src/rules/consistent-type-definitions.ts  |  4 +-
 .../src/rules/consistent-type-exports.ts      |  4 +-
 .../src/rules/consistent-type-imports.ts      |  8 ++--
 .../src/rules/default-param-last.ts           |  2 +-
 .../eslint-plugin/src/rules/dot-notation.ts   | 14 +++----
 .../rules/explicit-function-return-type.ts    | 20 ++++-----
 .../rules/explicit-member-accessibility.ts    | 28 ++++++-------
 .../rules/explicit-module-boundary-types.ts   | 14 +++----
 .../src/rules/init-declarations.ts            |  2 +-
 .../eslint-plugin/src/rules/max-params.ts     |  8 ++--
 .../src/rules/member-ordering.ts              | 22 +++++-----
 .../src/rules/method-signature-style.ts       |  4 +-
 .../rules/naming-convention-utils/schema.ts   | 42 +++++++++----------
 .../naming-convention-utils/validator.ts      |  2 +-
 .../src/rules/naming-convention.ts            |  2 +-
 .../src/rules/no-array-constructor.ts         |  2 +-
 .../src/rules/no-array-delete.ts              |  2 +-
 .../src/rules/no-base-to-string.ts            |  6 +--
 .../rules/no-confusing-non-null-assertion.ts  |  2 +-
 .../src/rules/no-confusing-void-expression.ts |  4 +-
 .../src/rules/no-dupe-class-members.ts        |  2 +-
 .../src/rules/no-duplicate-enum-values.ts     |  2 +-
 .../rules/no-duplicate-type-constituents.ts   | 10 ++---
 .../src/rules/no-dynamic-delete.ts            |  2 +-
 .../src/rules/no-empty-function.ts            |  4 +-
 .../src/rules/no-empty-interface.ts           |  4 +-
 .../src/rules/no-empty-object-type.ts         |  8 ++--
 .../src/rules/no-explicit-any.ts              |  8 ++--
 .../src/rules/no-extra-non-null-assertion.ts  |  2 +-
 .../src/rules/no-extraneous-class.ts          | 12 +++---
 .../src/rules/no-floating-promises.ts         | 10 ++---
 .../src/rules/no-for-in-array.ts              |  2 +-
 .../src/rules/no-implied-eval.ts              |  2 +-
 .../src/rules/no-import-type-side-effects.ts  |  2 +-
 .../src/rules/no-inferrable-types.ts          |  4 +-
 .../src/rules/no-invalid-this.ts              |  2 +-
 .../src/rules/no-invalid-void-type.ts         |  6 +--
 .../eslint-plugin/src/rules/no-loop-func.ts   |  2 +-
 .../src/rules/no-loss-of-precision.ts         |  2 +-
 .../src/rules/no-magic-numbers.ts             |  2 +-
 .../src/rules/no-meaningless-void-operator.ts |  6 +--
 .../eslint-plugin/src/rules/no-misused-new.ts |  2 +-
 .../src/rules/no-misused-promises.ts          |  6 +--
 .../eslint-plugin/src/rules/no-mixed-enums.ts |  2 +-
 .../eslint-plugin/src/rules/no-namespace.ts   |  8 ++--
 ...no-non-null-asserted-nullish-coalescing.ts |  2 +-
 .../no-non-null-asserted-optional-chain.ts    |  2 +-
 .../src/rules/no-non-null-assertion.ts        |  2 +-
 .../eslint-plugin/src/rules/no-redeclare.ts   | 16 +++----
 .../rules/no-redundant-type-constituents.ts   |  2 +-
 .../src/rules/no-require-imports.ts           |  8 ++--
 .../src/rules/no-restricted-imports.ts        | 22 +++++-----
 .../src/rules/no-restricted-types.ts          | 18 ++++----
 packages/eslint-plugin/src/rules/no-shadow.ts |  8 ++--
 .../eslint-plugin/src/rules/no-this-alias.ts  |  8 ++--
 .../eslint-plugin/src/rules/no-type-alias.ts  |  8 ++--
 .../no-unnecessary-boolean-literal-compare.ts |  8 ++--
 .../src/rules/no-unnecessary-condition.ts     |  8 ++--
 ...necessary-parameter-property-assignment.ts |  2 +-
 .../src/rules/no-unnecessary-qualifier.ts     |  2 +-
 .../no-unnecessary-template-expression.ts     |  2 +-
 .../rules/no-unnecessary-type-arguments.ts    |  2 +-
 .../rules/no-unnecessary-type-assertion.ts    |  6 +--
 .../rules/no-unnecessary-type-constraint.ts   |  2 +-
 .../rules/no-unnecessary-type-parameters.ts   |  2 +-
 .../src/rules/no-unsafe-argument.ts           |  6 +--
 .../src/rules/no-unsafe-assignment.ts         |  2 +-
 .../eslint-plugin/src/rules/no-unsafe-call.ts |  2 +-
 .../rules/no-unsafe-declaration-merging.ts    |  2 +-
 .../src/rules/no-unsafe-enum-comparison.ts    |  2 +-
 .../src/rules/no-unsafe-function-type.ts      |  2 +-
 .../src/rules/no-unsafe-member-access.ts      |  6 +--
 .../src/rules/no-unsafe-return.ts             |  2 +-
 .../src/rules/no-unsafe-unary-minus.ts        |  2 +-
 .../src/rules/no-unused-expressions.ts        |  2 +-
 .../eslint-plugin/src/rules/no-unused-vars.ts | 12 +++---
 .../src/rules/no-use-before-define.ts         |  6 +--
 .../src/rules/no-useless-constructor.ts       |  2 +-
 .../src/rules/no-useless-empty-export.ts      |  2 +-
 .../src/rules/no-var-requires.ts              |  6 +--
 .../src/rules/no-wrapper-object-types.ts      |  2 +-
 .../non-nullable-type-assertion-style.ts      |  2 +-
 .../src/rules/only-throw-error.ts             |  4 +-
 .../src/rules/parameter-properties.ts         | 10 ++---
 .../src/rules/prefer-as-const.ts              |  2 +-
 .../src/rules/prefer-destructuring.ts         |  8 ++--
 .../src/rules/prefer-enum-initializers.ts     |  2 +-
 .../eslint-plugin/src/rules/prefer-find.ts    |  2 +-
 .../eslint-plugin/src/rules/prefer-for-of.ts  |  2 +-
 .../src/rules/prefer-function-type.ts         |  2 +-
 .../src/rules/prefer-includes.ts              |  2 +-
 .../src/rules/prefer-literal-enum-member.ts   |  4 +-
 .../src/rules/prefer-namespace-keyword.ts     |  2 +-
 .../src/rules/prefer-nullish-coalescing.ts    |  8 ++--
 .../gatherLogicalOperands.ts                  | 12 +++---
 .../src/rules/prefer-optional-chain.ts        | 20 ++++-----
 .../src/rules/prefer-promise-reject-errors.ts |  4 +-
 .../rules/prefer-readonly-parameter-types.ts  |  4 +-
 .../src/rules/prefer-readonly.ts              |  4 +-
 .../src/rules/prefer-reduce-type-parameter.ts |  2 +-
 .../src/rules/prefer-regexp-exec.ts           |  2 +-
 .../src/rules/prefer-return-this-type.ts      |  2 +-
 .../rules/prefer-string-starts-ends-with.ts   |  6 +--
 .../src/rules/prefer-ts-expect-error.ts       |  2 +-
 .../src/rules/promise-function-async.ts       |  8 ++--
 .../src/rules/require-array-sort-compare.ts   |  6 +--
 .../eslint-plugin/src/rules/require-await.ts  |  2 +-
 .../src/rules/restrict-plus-operands.ts       | 24 +++++------
 .../rules/restrict-template-expressions.ts    | 10 ++---
 .../eslint-plugin/src/rules/return-await.ts   |  4 +-
 .../src/rules/sort-type-constituents.ts       | 16 +++----
 .../src/rules/strict-boolean-expressions.ts   |  4 +-
 .../src/rules/switch-exhaustiveness-check.ts  |  8 ++--
 .../src/rules/triple-slash-reference.ts       | 10 ++---
 packages/eslint-plugin/src/rules/typedef.ts   |  4 +-
 .../eslint-plugin/src/rules/unbound-method.ts |  6 +--
 .../src/rules/unified-signatures.ts           |  6 +--
 .../use-unknown-in-catch-callback-variable.ts |  2 +-
 130 files changed, 413 insertions(+), 414 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 052489694f75..b316f8f5c767 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -585,39 +585,38 @@ export default tseslint.config(
     ],
     rules: {
       '@typescript-eslint/sort-type-constituents': 'off',
-      'perfectionist/sort-classes': [
-        'error',
-        {
-          order: 'asc',
-          partitionByComment: true,
-          type: 'natural',
-        },
-      ],
-      'perfectionist/sort-enums': [
-        'error',
-        {
-          order: 'asc',
-          partitionByComment: true,
-          type: 'natural',
-        },
-      ],
+      'perfectionist/sort-classes': 'error',
+      'perfectionist/sort-enums': 'error',
       'perfectionist/sort-objects': [
         'error',
         {
-          order: 'asc',
-          partitionByComment: true,
-          type: 'natural',
+          customGroups: {
+            top: [
+              'meta',
+              'defaultOptions',
+              'create',
+              'type',
+              'valid',
+              'invalid',
+            ],
+          },
+          groups: ['top', 'unknown'],
         },
       ],
       'perfectionist/sort-union-types': [
         'error',
         {
-          order: 'asc',
           groups: ['unknown', 'keyword', 'nullish'],
-          type: 'natural',
         },
       ],
       'simple-import-sort/imports': 'off',
     },
+    settings: {
+      perfectionist: {
+        partitionByComment: true,
+        order: 'asc',
+        type: 'natural',
+      },
+    },
   },
 );
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index 5d8e094fe761..e561f08ad1e2 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -56,9 +56,9 @@ export default createRule({
             return null;
           }
           return {
+            type: MemberNameType.Normal,
             callSignature: false,
             name,
-            type: MemberNameType.Normal,
           };
         }
         case AST_NODE_TYPES.TSMethodSignature:
@@ -69,15 +69,15 @@ export default createRule({
           };
         case AST_NODE_TYPES.TSCallSignatureDeclaration:
           return {
+            type: MemberNameType.Normal,
             callSignature: true,
             name: 'call',
-            type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.TSConstructSignatureDeclaration:
           return {
+            type: MemberNameType.Normal,
             callSignature: false,
             name: 'new',
-            type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.MethodDefinition:
           return {
@@ -157,6 +157,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require that function overload signatures be consecutive',
       recommended: 'stylistic',
@@ -165,7 +166,6 @@ export default createRule({
       adjacentSignature: 'All {{name}} signatures should be adjacent.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'adjacent-overload-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 92b53a9c7898..51c2cb7df1f0 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -125,9 +125,9 @@ export default createRule<Options, MessageIds>({
 
         context.report({
           data: {
+            type: getMessageType(node.elementType),
             className: isReadonly ? 'ReadonlyArray' : 'Array',
             readonlyPrefix: isReadonly ? 'readonly ' : '',
-            type: getMessageType(node.elementType),
           },
           fix(fixer) {
             const typeNode = node.elementType;
@@ -193,9 +193,9 @@ export default createRule<Options, MessageIds>({
           // Create an 'any' array
           context.report({
             data: {
+              type: 'any',
               className: isReadonlyArrayType ? 'ReadonlyArray' : 'Array',
               readonlyPrefix,
-              type: 'any',
             },
             fix(fixer) {
               return fixer.replaceText(node, `${readonlyPrefix}any[]`);
@@ -227,9 +227,9 @@ export default createRule<Options, MessageIds>({
         const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`;
         context.report({
           data: {
+            type: getMessageType(type),
             className: isReadonlyArrayType ? node.typeName.name : 'Array',
             readonlyPrefix,
-            type: getMessageType(type),
           },
           fix(fixer) {
             return [
@@ -249,6 +249,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require consistently using either `T[]` or `Array<T>` for arrays',
@@ -271,10 +272,11 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           arrayOption: {
-            enum: ['array', 'generic', 'array-simple'],
             type: 'string',
+            enum: ['array', 'generic', 'array-simple'],
           },
         },
         additionalProperties: false,
@@ -289,10 +291,8 @@ export default createRule<Options, MessageIds>({
               'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'array-type',
 });
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index 507b8ededfe9..a58280939c4c 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -50,6 +50,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow awaiting a value that is not a Thenable',
       recommended: 'recommended',
@@ -61,7 +62,6 @@ export default createRule({
       removeAwait: 'Remove unnecessary `await`.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'await-thenable',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index f00c6846f85c..b981a32f9ac6 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -196,6 +196,7 @@ export default createRule<[Options], MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow `@ts-<directive>` comments or require descriptions after directives',
@@ -219,23 +220,24 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           directiveConfigSchema: {
             oneOf: [
               {
-                default: true,
                 type: 'boolean',
+                default: true,
               },
               {
-                enum: ['allow-with-description'],
                 type: 'string',
+                enum: ['allow-with-description'],
               },
               {
+                type: 'object',
                 additionalProperties: false,
                 properties: {
                   descriptionFormat: { type: 'string' },
                 },
-                type: 'object',
               },
             ],
           },
@@ -243,18 +245,16 @@ export default createRule<[Options], MessageIds>({
         additionalProperties: false,
         properties: {
           minimumDescriptionLength: {
-            default: defaultMinimumDescriptionLength,
             type: 'number',
+            default: defaultMinimumDescriptionLength,
           },
           'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'ban-ts-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 95ed5d959788..8ab0f7704722 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -45,6 +45,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow `// tslint:<rule-flag>` comments',
       recommended: 'stylistic',
@@ -54,7 +55,6 @@ export default createRule({
       commentDetected: 'tslint comment detected: "{{ text }}"',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'ban-tslint-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index 13109cb32e28..d9213d2cde4d 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -214,6 +214,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['fields'],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Enforce that literals on classes are exposed in a consistent style',
@@ -228,11 +229,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        enum: ['fields', 'getters'],
         type: 'string',
+        enum: ['fields', 'getters'],
       },
     ],
-    type: 'problem',
   },
   name: 'class-literal-property-style',
 });
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index f0142a26010c..b611006bbedd 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -232,6 +232,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce that class methods utilize `this`',
       extendsBaseRule: true,
@@ -242,47 +243,46 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           enforceForClassFields: {
+            type: 'boolean',
             default: true,
             description:
               'Enforces that functions used as instance field initializers utilize `this`',
-            type: 'boolean',
           },
           exceptMethods: {
+            type: 'array',
             description:
               'Allows specified method names to be ignored with this rule',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           ignoreClassesThatImplementAnInterface: {
             description:
               'Ignore classes that specifically implement some interface',
             oneOf: [
               {
-                description: 'Ignore all classes that implement an interface',
                 type: 'boolean',
+                description: 'Ignore all classes that implement an interface',
               },
               {
+                type: 'string',
                 description:
                   'Ignore only the public fields of classes that implement an interface',
                 enum: ['public-fields'],
-                type: 'string',
               },
             ],
           },
           ignoreOverrideMethods: {
-            description: 'Ignore members marked with the `override` modifier',
             type: 'boolean',
+            description: 'Ignore members marked with the `override` modifier',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'class-methods-use-this',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index 06bddbfc6b52..6bbad334229d 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -125,6 +125,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['constructor'],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
@@ -139,11 +140,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        enum: ['type-annotation', 'constructor'],
         type: 'string',
+        enum: ['type-annotation', 'constructor'],
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-generic-constructors',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index 88c55a7eec75..5a29718504ac 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -130,6 +130,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['record'],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require or disallow the `Record` type',
       recommended: 'stylistic',
@@ -141,11 +142,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        enum: ['record', 'index-signature'],
         type: 'string',
+        enum: ['record', 'index-signature'],
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-indexed-object-style',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-return.ts b/packages/eslint-plugin/src/rules/consistent-return.ts
index 2b62e7372e5a..5644278cfae2 100644
--- a/packages/eslint-plugin/src/rules/consistent-return.ts
+++ b/packages/eslint-plugin/src/rules/consistent-return.ts
@@ -115,6 +115,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ treatUndefinedAsUnspecified: false }],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require `return` statements to either always or never specify values',
@@ -124,7 +125,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'suggestion',
   },
   name: 'consistent-return',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index ed7e641381e5..f91658154481 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -227,6 +227,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type assertions',
       recommended: 'stylistic',
@@ -247,35 +248,34 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
+            type: 'object',
             additionalProperties: false,
             properties: {
               assertionStyle: {
-                enum: ['never'],
                 type: 'string',
+                enum: ['never'],
               },
             },
             required: ['assertionStyle'],
-            type: 'object',
           },
           {
+            type: 'object',
             additionalProperties: false,
             properties: {
               assertionStyle: {
-                enum: ['as', 'angle-bracket'],
                 type: 'string',
+                enum: ['as', 'angle-bracket'],
               },
               objectLiteralTypeAssertions: {
-                enum: ['allow', 'allow-as-parameter', 'never'],
                 type: 'string',
+                enum: ['allow', 'allow-as-parameter', 'never'],
               },
             },
             required: ['assertionStyle'],
-            type: 'object',
           },
         ],
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-type-assertions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 3cc36be45170..633f154fd369 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -117,6 +117,7 @@ export default createRule({
   },
   defaultOptions: ['interface'],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce type definitions to consistently use either `interface` or `type`',
@@ -129,11 +130,10 @@ export default createRule({
     },
     schema: [
       {
-        enum: ['interface', 'type'],
         type: 'string',
+        enum: ['interface', 'type'],
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-type-definitions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index 1a6041bee233..b581578e5518 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -210,6 +210,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type exports',
       requiresTypeChecking: true,
@@ -226,16 +227,15 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           fixMixedExportsWithInlineTypeSpecifier: {
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-type-exports',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index ad001e7aba02..317156bf90ff 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -909,6 +909,7 @@ export default createRule<Options, MessageIds>({
   ],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type imports',
     },
@@ -923,24 +924,23 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           disallowTypeAnnotations: {
             type: 'boolean',
           },
           fixStyle: {
-            enum: ['separate-type-imports', 'inline-type-imports'],
             type: 'string',
+            enum: ['separate-type-imports', 'inline-type-imports'],
           },
           prefer: {
-            enum: ['type-imports', 'no-type-imports'],
             type: 'string',
+            enum: ['type-imports', 'no-type-imports'],
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'consistent-type-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index acccc135874d..76b8237f0ddd 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -72,6 +72,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce default parameters to be last',
       extendsBaseRule: true,
@@ -80,7 +81,6 @@ export default createRule({
       shouldBeLast: 'Default parameters should be last.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'default-param-last',
 });
diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
index d9efb21a0336..495a4d2b6802 100644
--- a/packages/eslint-plugin/src/rules/dot-notation.ts
+++ b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -91,6 +91,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce dot notation whenever possible',
       extendsBaseRule: true,
@@ -102,33 +103,32 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowIndexSignaturePropertyAccess: {
-            default: false,
             type: 'boolean',
+            default: false,
           },
           allowKeywords: {
-            default: true,
             type: 'boolean',
+            default: true,
           },
           allowPattern: {
-            default: '',
             type: 'string',
+            default: '',
           },
           allowPrivateClassPropertyAccess: {
-            default: false,
             type: 'boolean',
+            default: false,
           },
           allowProtectedClassPropertyAccess: {
-            default: false,
             type: 'boolean',
+            default: false,
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'dot-notation',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index b8264cdec926..97aec257069e 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -194,6 +194,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require explicit return types on functions and class methods',
@@ -203,56 +204,55 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowConciseArrowFunctionExpressionsStartingWithVoid: {
+            type: 'boolean',
             description:
               'Whether to allow arrow functions that start with the `void` keyword.',
-            type: 'boolean',
           },
           allowDirectConstAssertionInArrowFunctions: {
+            type: 'boolean',
             description:
               'Whether to ignore arrow functions immediately returning a `as const` value.',
-            type: 'boolean',
           },
           allowedNames: {
+            type: 'array',
             description:
               'An array of function/method names that will not have their arguments or return values checked.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           allowExpressions: {
+            type: 'boolean',
             description:
               'Whether to ignore function expressions (functions which are not part of a declaration).',
-            type: 'boolean',
           },
           allowFunctionsWithoutTypeParameters: {
+            type: 'boolean',
             description:
               "Whether to ignore functions that don't have generic type parameters.",
-            type: 'boolean',
           },
           allowHigherOrderFunctions: {
+            type: 'boolean',
             description:
               'Whether to ignore functions immediately returning another function expression.',
-            type: 'boolean',
           },
           allowIIFEs: {
+            type: 'boolean',
             description:
               'Whether to ignore immediately invoked function expressions (IIFEs).',
-            type: 'boolean',
           },
           allowTypedFunctionExpressions: {
+            type: 'boolean',
             description:
               'Whether to ignore type annotations on the variable of function expressions.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'explicit-function-return-type',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 1f180ff4c5d8..e6fbe8e4bc38 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -93,8 +93,8 @@ export default createRule<Options, MessageIds>({
         const publicKeyword = findPublicKeyword(methodDefinition);
         context.report({
           data: {
-            name: methodName,
             type: nodeType,
+            name: methodName,
           },
           fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
           loc: rangeToLoc(context.sourceCode, publicKeyword.range),
@@ -103,8 +103,8 @@ export default createRule<Options, MessageIds>({
       } else if (check === 'explicit' && !methodDefinition.accessibility) {
         context.report({
           data: {
-            name: methodName,
             type: nodeType,
+            name: methodName,
           },
           loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
           messageId: 'missingAccessibility',
@@ -228,8 +228,8 @@ export default createRule<Options, MessageIds>({
         const publicKeywordRange = findPublicKeyword(propertyDefinition);
         context.report({
           data: {
-            name: propertyName,
             type: nodeType,
+            name: propertyName,
           },
           fix: fixer => fixer.removeRange(publicKeywordRange.rangeToRemove),
           loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
@@ -241,8 +241,8 @@ export default createRule<Options, MessageIds>({
       ) {
         context.report({
           data: {
-            name: propertyName,
             type: nodeType,
+            name: propertyName,
           },
           loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
           messageId: 'missingAccessibility',
@@ -278,8 +278,8 @@ export default createRule<Options, MessageIds>({
           if (!node.accessibility) {
             context.report({
               data: {
-                name: nodeName,
                 type: nodeType,
+                name: nodeName,
               },
               loc: getParameterPropertyHeadLoc(
                 context.sourceCode,
@@ -297,8 +297,8 @@ export default createRule<Options, MessageIds>({
             const publicKeyword = findPublicKeyword(node);
             context.report({
               data: {
-                name: nodeName,
                 type: nodeType,
+                name: nodeName,
               },
               fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
               loc: rangeToLoc(context.sourceCode, publicKeyword.range),
@@ -320,6 +320,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ accessibility: 'explicit' }],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require explicit accessibility modifiers on class properties and methods',
@@ -336,23 +337,24 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           accessibilityLevel: {
             oneOf: [
               {
+                type: 'string',
                 description: 'Always require an accessor.',
                 enum: ['explicit'],
-                type: 'string',
               },
               {
+                type: 'string',
                 description: 'Require an accessor except when public.',
                 enum: ['no-public'],
-                type: 'string',
               },
               {
+                type: 'string',
                 description: 'Never check whether there is an accessor.',
                 enum: ['off'],
-                type: 'string',
               },
             ],
           },
@@ -361,13 +363,15 @@ export default createRule<Options, MessageIds>({
         properties: {
           accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
           ignoredMethodNames: {
+            type: 'array',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           overrides: {
+            type: 'object',
             additionalProperties: false,
+
             properties: {
               accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
               constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
@@ -377,14 +381,10 @@ export default createRule<Options, MessageIds>({
               },
               properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
             },
-
-            type: 'object',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'explicit-member-accessibility',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index 8673c647b6de..09cdd8cbf10c 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -460,6 +460,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         "Require explicit return and argument types on exported functions' and classes' public class methods",
@@ -474,45 +475,44 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowArgumentsExplicitlyTypedAsAny: {
+            type: 'boolean',
             description:
               'Whether to ignore arguments that are explicitly typed as `any`.',
-            type: 'boolean',
           },
           allowDirectConstAssertionInArrowFunctions: {
+            type: 'boolean',
             description: [
               'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
               'You must still type the parameters of the function.',
             ].join('\n'),
-            type: 'boolean',
           },
           allowedNames: {
+            type: 'array',
             description:
               'An array of function/method names that will not have their arguments or return values checked.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           allowHigherOrderFunctions: {
+            type: 'boolean',
             description: [
               'Whether to ignore return type annotations on functions immediately returning another function expression.',
               'You must still type the parameters of the function.',
             ].join('\n'),
-            type: 'boolean',
           },
           allowTypedFunctionExpressions: {
+            type: 'boolean',
             description:
               'Whether to ignore type annotations on the variable of a function expression.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'explicit-module-boundary-types',
 });
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 106587e8c47e..55ffecd7caed 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -99,6 +99,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['always'],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require or disallow initialization in variable declarations',
@@ -107,7 +108,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'suggestion',
   },
   name: 'init-declarations',
 });
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index 9ac486e21c37..4a444a1f554f 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -63,6 +63,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ countVoidThis: false, max: 3 }],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce a maximum number of parameters in function definitions',
@@ -71,24 +72,23 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           countVoidThis: {
             type: 'boolean',
           },
           max: {
-            minimum: 0,
             type: 'integer',
+            minimum: 0,
           },
           maximum: {
-            minimum: 0,
             type: 'integer',
+            minimum: 0,
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'max-params',
 });
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index 20039baa01b2..c2f61e4c0c3e 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -92,28 +92,29 @@ export type Options = [
 ];
 
 const neverConfig: JSONSchema.JSONSchema4 = {
-  enum: ['never'],
   type: 'string',
+  enum: ['never'],
 };
 
 const arrayConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
+  type: 'array',
   items: {
     oneOf: [
       {
         $ref: memberTypes,
       },
       {
+        type: 'array',
         items: {
           $ref: memberTypes,
         },
-        type: 'array',
       },
     ],
   },
-  type: 'array',
 });
 
 const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
+  type: 'object',
   additionalProperties: false,
   properties: {
     memberTypes: {
@@ -126,7 +127,6 @@ const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
       $ref: '#/items/0/$defs/orderOptions',
     },
   },
-  type: 'object',
 });
 
 export const defaultOrder: MemberType[] = [
@@ -427,7 +427,7 @@ function getMemberRawName(
     | TSESTree.TSPropertySignature,
   sourceCode: TSESLint.SourceCode,
 ): string {
-  const { name, type } = getNameFromMember(member, sourceCode);
+  const { type, name } = getNameFromMember(member, sourceCode);
 
   if (type === MemberNameType.Quoted) {
     return name.slice(1, -1);
@@ -1030,6 +1030,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require a consistent member declaration order',
     },
@@ -1042,16 +1043,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           allItems: {
-            enum: allMemberTypes as string[],
             type: 'string',
+            enum: allMemberTypes as string[],
           },
           optionalityOrderOptions: {
-            enum: ['optional-first', 'required-first'],
             type: 'string',
+            enum: ['optional-first', 'required-first'],
           },
           orderOptions: {
+            type: 'string',
             enum: [
               'alphabetically',
               'alphabetically-case-insensitive',
@@ -1059,9 +1062,9 @@ export default createRule<Options, MessageIds>({
               'natural',
               'natural-case-insensitive',
             ],
-            type: 'string',
           },
           typeItems: {
+            type: 'string',
             enum: [
               'readonly-signature',
               'signature',
@@ -1070,7 +1073,6 @@ export default createRule<Options, MessageIds>({
               'method',
               'constructor',
             ],
-            type: 'string',
           },
 
           // These properties must follow the preceding ones for ajv logic.
@@ -1107,10 +1109,8 @@ export default createRule<Options, MessageIds>({
             $ref: '#/items/0/$defs/typesConfig',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'member-ordering',
 });
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index dd59ae538c13..39152b5a239c 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -221,6 +221,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['property'],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce using a particular method signature syntax',
     },
@@ -233,11 +234,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        enum: ['property', 'method'],
         type: 'string',
+        enum: ['property', 'method'],
       },
     ],
-    type: 'suggestion',
   },
   name: 'method-signature-style',
 });
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
index 13e4f9a8b3cd..3a310b41b6ba 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/schema.ts
@@ -18,27 +18,27 @@ import {
 const $DEFS: Record<string, JSONSchema.JSONSchema4> = {
   // enums
   predefinedFormats: {
-    enum: getEnumNames(PredefinedFormats),
     type: 'string',
+    enum: getEnumNames(PredefinedFormats),
   },
   typeModifiers: {
-    enum: getEnumNames(TypeModifiers),
     type: 'string',
+    enum: getEnumNames(TypeModifiers),
   },
   underscoreOptions: {
-    enum: getEnumNames(UnderscoreOptions),
     type: 'string',
+    enum: getEnumNames(UnderscoreOptions),
   },
 
   // repeated types
   formatOptionsConfig: {
     oneOf: [
       {
+        type: 'array',
         additionalItems: false,
         items: {
           $ref: '#/$defs/predefinedFormats',
         },
-        type: 'array',
       },
       {
         type: 'null',
@@ -46,21 +46,21 @@ const $DEFS: Record<string, JSONSchema.JSONSchema4> = {
     ],
   },
   matchRegexConfig: {
+    type: 'object',
     additionalProperties: false,
     properties: {
       match: { type: 'boolean' },
       regex: { type: 'string' },
     },
     required: ['match', 'regex'],
-    type: 'object',
   },
   prefixSuffixConfig: {
+    type: 'array',
     additionalItems: false,
     items: {
-      minLength: 1,
       type: 'string',
+      minLength: 1,
     },
-    type: 'array',
   },
 };
 
@@ -96,39 +96,40 @@ function selectorSchema(
     filter: {
       oneOf: [
         {
-          minLength: 1,
           type: 'string',
+          minLength: 1,
         },
         MATCH_REGEX_SCHEMA,
       ],
     },
     selector: {
-      enum: [selectorString],
       type: 'string',
+      enum: [selectorString],
     },
   };
   if (modifiers && modifiers.length > 0) {
     selector.modifiers = {
+      type: 'array',
       additionalItems: false,
       items: {
-        enum: modifiers,
         type: 'string',
+        enum: modifiers,
       },
-      type: 'array',
     };
   }
   if (allowType) {
     selector.types = {
+      type: 'array',
       additionalItems: false,
       items: {
         $ref: '#/$defs/typeModifiers',
       },
-      type: 'array',
     };
   }
 
   return [
     {
+      type: 'object',
       additionalProperties: false,
       description: `Selector '${selectorString}'`,
       properties: {
@@ -136,13 +137,13 @@ function selectorSchema(
         ...selector,
       },
       required: ['selector', 'format'],
-      type: 'object',
     },
   ];
 }
 
 function selectorsSchema(): JSONSchema.JSONSchema4 {
   return {
+    type: 'object',
     additionalProperties: false,
     description: 'Multiple selectors in one config',
     properties: {
@@ -150,42 +151,42 @@ function selectorsSchema(): JSONSchema.JSONSchema4 {
       filter: {
         oneOf: [
           {
-            minLength: 1,
             type: 'string',
+            minLength: 1,
           },
           MATCH_REGEX_SCHEMA,
         ],
       },
       modifiers: {
+        type: 'array',
         additionalItems: false,
         items: {
-          enum: getEnumNames(Modifiers),
           type: 'string',
+          enum: getEnumNames(Modifiers),
         },
-        type: 'array',
       },
       selector: {
+        type: 'array',
         additionalItems: false,
         items: {
-          enum: [...getEnumNames(MetaSelectors), ...getEnumNames(Selectors)],
           type: 'string',
+          enum: [...getEnumNames(MetaSelectors), ...getEnumNames(Selectors)],
         },
-        type: 'array',
       },
       types: {
+        type: 'array',
         additionalItems: false,
         items: {
           $ref: '#/$defs/typeModifiers',
         },
-        type: 'array',
       },
     },
     required: ['selector', 'format'],
-    type: 'object',
   };
 }
 
 const SCHEMA: JSONSchema.JSONSchema4 = {
+  type: 'array',
   $defs: $DEFS,
   additionalItems: false,
   items: {
@@ -327,7 +328,6 @@ const SCHEMA: JSONSchema.JSONSchema4 = {
       ...selectorSchema('import', false, ['default', 'namespace']),
     ],
   },
-  type: 'array',
 };
 
 export { SCHEMA };
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
index afae8bb029b9..b7d68d0f79bf 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/validator.ts
@@ -162,6 +162,7 @@ function createValidator(
     processedName?: string;
   }): Record<string, unknown> {
     return {
+      type: selectorTypeToMessageString(type),
       affixes: affixes?.join(', '),
       count,
       formats: formats?.map(f => PredefinedFormats[f]).join(', '),
@@ -175,7 +176,6 @@ function createValidator(
           : custom?.match === false
             ? 'not match'
             : null,
-      type: selectorTypeToMessageString(type),
     };
   }
 
diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
index 6a4e4bc53c74..e0be03bf54fb 100644
--- a/packages/eslint-plugin/src/rules/naming-convention.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention.ts
@@ -697,6 +697,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: defaultCamelCaseAllTheThingsConfig,
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce naming conventions for everything across a codebase',
@@ -718,7 +719,6 @@ export default createRule<Options, MessageIds>({
         '{{type}} name `{{name}}` must not have a {{position}} underscore.',
     },
     schema: SCHEMA,
-    type: 'suggestion',
   },
   name: 'naming-convention',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index 361928021fee..c6815ceecfd6 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -46,6 +46,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow generic `Array` constructors',
       extendsBaseRule: true,
@@ -56,7 +57,6 @@ export default createRule({
       useLiteral: 'The array literal notation [] is preferable.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-array-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index 161081c56933..3de3cd8792c5 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -93,6 +93,7 @@ export default createRule<[], MessageId>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow using the `delete` operator on array values',
       recommended: 'recommended',
@@ -105,7 +106,6 @@ export default createRule<[], MessageId>({
       useSplice: 'Use `array.splice()` instead.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-array-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index ed2f85fd008f..7312a0817ee6 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -154,6 +154,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require `.toString()` to only be called on objects which provide useful information when stringified',
@@ -166,19 +167,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoredTypeNames: {
+            type: 'array',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-base-to-string',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index 7e16276795c7..abb81f36a279 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -66,6 +66,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertion in locations that may be confusing',
@@ -84,7 +85,6 @@ export default createRule({
         'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-confusing-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 4eb54e068417..80d0845244c0 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -332,6 +332,7 @@ export default createRule<Options, MessageId>({
   },
   defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require expressions of type void to appear in statement position',
@@ -367,15 +368,14 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreArrowShorthand: { type: 'boolean' },
           ignoreVoidOperator: { type: 'boolean' },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-confusing-void-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
index a0d9c8e29eab..9d0154c650fd 100644
--- a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
+++ b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
@@ -47,6 +47,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow duplicate class members',
       extendsBaseRule: true,
@@ -54,7 +55,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'problem',
   },
   name: 'no-dupe-class-members',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index e89f8d66256f..243fe6e6c4f2 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -60,6 +60,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow duplicate enum member values',
       recommended: 'recommended',
@@ -69,7 +70,6 @@ export default createRule({
       duplicateValue: 'Duplicate enum member value {{value}}.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-duplicate-enum-values',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index 65eb54471664..bd7843219161 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -144,13 +144,13 @@ export default createRule<Options, MessageIds>({
       };
       context.report({
         data: {
-          previous: context.sourceCode.getText(
-            duplicateConstituent.duplicatePrevious,
-          ),
           type:
             parentNode.type === AST_NODE_TYPES.TSIntersectionType
               ? 'Intersection'
               : 'Union',
+          previous: context.sourceCode.getText(
+            duplicateConstituent.duplicatePrevious,
+          ),
         },
         fix: fixer => {
           return [
@@ -181,6 +181,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow duplicate constituents of union or intersection types',
@@ -193,6 +194,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreIntersections: {
@@ -202,10 +204,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-duplicate-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index d0da569f7f7e..c6c883a6c16e 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -63,6 +63,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow using the `delete` operator on computed key expressions',
@@ -73,7 +74,6 @@ export default createRule({
       dynamicDelete: 'Do not delete dynamically computed property keys.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-dynamic-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-function.ts b/packages/eslint-plugin/src/rules/no-empty-function.ts
index cb3ecae32597..ed3dbbb08a33 100644
--- a/packages/eslint-plugin/src/rules/no-empty-function.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-function.ts
@@ -25,6 +25,7 @@ const schema = deepMerge(
     properties: {
       allow: {
         items: {
+          type: 'string',
           enum: [
             'functions',
             'arrowFunctions',
@@ -41,7 +42,6 @@ const schema = deepMerge(
             'decoratedFunctions',
             'overrideMethods',
           ],
-          type: 'string',
         },
       },
     },
@@ -165,6 +165,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow empty functions',
       extendsBaseRule: true,
@@ -173,7 +174,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [schema],
-    type: 'suggestion',
   },
   name: 'no-empty-function',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index a31d2fb853bf..dbe3d0bc448d 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -87,6 +87,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     deprecated: true,
     docs: {
       description: 'Disallow the declaration of empty interfaces',
@@ -101,16 +102,15 @@ export default createRule<Options, MessageIds>({
     replacedBy: ['@typescript-eslint/no-empty-object-type'],
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowSingleExtends: {
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-empty-interface',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index f89b603c0629..be9ffd4890cd 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -148,6 +148,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow accidentally using the "empty object" type',
       recommended: 'recommended',
@@ -165,24 +166,23 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowInterfaces: {
-            enum: ['always', 'never', 'with-single-extends'],
             type: 'string',
+            enum: ['always', 'never', 'with-single-extends'],
           },
           allowObjectTypes: {
-            enum: ['always', 'never'],
             type: 'string',
+            enum: ['always', 'never'],
           },
           allowWithName: {
             type: 'string',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-empty-object-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index a945e69aefb3..c49f8741031c 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -177,6 +177,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow the `any` type',
       recommended: 'recommended',
@@ -192,22 +193,21 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           fixToUnknown: {
+            type: 'boolean',
             description:
               'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
-            type: 'boolean',
           },
           ignoreRestArgs: {
-            description: 'Whether to ignore rest parameter arrays.',
             type: 'boolean',
+            description: 'Whether to ignore rest parameter arrays.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-explicit-any',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index 6b9edf3b67fa..260ebe3dd3c6 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -26,6 +26,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow extra non-null assertions',
       recommended: 'recommended',
@@ -35,7 +36,6 @@ export default createRule({
       noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-extra-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 18043abb9833..3c60e98cc2e7 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -114,6 +114,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow classes used as namespaces',
       recommended: 'strict',
@@ -125,33 +126,32 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowConstructorOnly: {
+            type: 'boolean',
             description:
               'Whether to allow extraneous classes that contain only a constructor.',
-            type: 'boolean',
           },
           allowEmpty: {
+            type: 'boolean',
             description:
               'Whether to allow extraneous classes that have no body (i.e. are empty).',
-            type: 'boolean',
           },
           allowStaticOnly: {
+            type: 'boolean',
             description:
               'Whether to allow extraneous classes that only contain static members.',
-            type: 'boolean',
           },
           allowWithDecorator: {
+            type: 'boolean',
             description:
               'Whether to allow extraneous classes that include a decorator.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-extraneous-class',
 });
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 6ad63ce2cc80..812a9f2546e9 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -405,6 +405,7 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require Promise-like statements to be handled appropriately',
@@ -424,29 +425,28 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
           allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
           checkThenables: {
+            type: 'boolean',
             description:
               'Whether to check all "Thenable"s, not just the built-in Promise type.',
-            type: 'boolean',
           },
           ignoreIIFE: {
+            type: 'boolean',
             description:
               'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
-            type: 'boolean',
           },
           ignoreVoid: {
-            description: 'Whether to ignore `void` expressions.',
             type: 'boolean',
+            description: 'Whether to ignore `void` expressions.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-floating-promises',
 });
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index 08fcb66e8413..0382e7e669b1 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -31,6 +31,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow iterating over an array with a for-in loop',
       recommended: 'recommended',
@@ -41,7 +42,6 @@ export default createRule({
         'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-for-in-array',
 });
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index b2f29d50c735..f466c6b5e3b6 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -146,6 +146,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow the use of `eval()`-like methods',
       extendsBaseRule: true,
@@ -158,7 +159,6 @@ export default createRule({
       noImpliedEvalError: 'Implied eval. Consider passing a function.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-implied-eval',
 });
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index 727e55a6ded7..bbefdb01abb5 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -69,6 +69,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
@@ -79,7 +80,6 @@ export default createRule<Options, MessageIds>({
         'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-import-type-side-effects',
 });
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index bd27cd86af07..399bfeccec7a 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -256,6 +256,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
@@ -268,6 +269,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreParameters: {
@@ -277,10 +279,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-inferrable-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-this.ts b/packages/eslint-plugin/src/rules/no-invalid-this.ts
index f27b1ccae90d..4405f381c3c2 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-this.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-this.ts
@@ -85,6 +85,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ capIsConstructor: true }],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow `this` keywords outside of classes or class-like objects',
@@ -93,7 +94,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'suggestion',
   },
   name: 'no-invalid-this',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index e9db3b139152..327223cb6197 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -186,6 +186,7 @@ export default createRule<[Options], MessageIds>({
     { allowAsThisParameter: false, allowInGenericTypeArguments: true },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow `void` type outside of generic or return types',
       recommended: 'strict',
@@ -205,6 +206,7 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowAsThisParameter: {
@@ -214,17 +216,15 @@ export default createRule<[Options], MessageIds>({
             oneOf: [
               { type: 'boolean' },
               {
+                type: 'array',
                 items: { type: 'string' },
                 minItems: 1,
-                type: 'array',
               },
             ],
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-invalid-void-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index d53f1959b906..2384dab24491 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -58,6 +58,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow function declarations that contain unsafe references inside loop statements',
@@ -66,7 +67,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-loop-func',
 });
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
index 1631c33ac46e..df688b952b3e 100644
--- a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
+++ b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
@@ -17,6 +17,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow literal numbers that lose precision',
@@ -25,7 +26,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [],
-    type: 'problem',
   },
   name: 'no-loss-of-precision',
 });
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index 7a39d084d894..929c6a4d7981 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -127,13 +127,13 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow magic numbers',
       extendsBaseRule: true,
     },
     messages: baseRule.meta.messages,
     schema: [schema],
-    type: 'suggestion',
   },
   name: 'no-magic-numbers',
 });
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index 4a7de1f3c2f7..b5d65242c6e6 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -59,6 +59,7 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
   },
   defaultOptions: [{ checkNever: false }],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow the `void` operator except when used to discard a value',
@@ -74,17 +75,16 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           checkNever: {
-            default: false,
             type: 'boolean',
+            default: false,
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-meaningless-void-operator',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index 53c3447357ba..898d292f7e10 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -98,6 +98,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Enforce valid definition of `new` and `constructor`',
       recommended: 'recommended',
@@ -107,7 +108,6 @@ export default createRule({
       errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-misused-new',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index 5d4a4cdb8e3e..4ae67624f1c6 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -535,6 +535,7 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow Promises in places not designed to handle them',
       recommended: 'recommended',
@@ -558,6 +559,7 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           checksConditionals: {
@@ -570,6 +572,7 @@ export default createRule<Options, MessageId>({
             oneOf: [
               { type: 'boolean' },
               {
+                type: 'object',
                 additionalProperties: false,
                 properties: {
                   arguments: { type: 'boolean' },
@@ -579,15 +582,12 @@ export default createRule<Options, MessageId>({
                   returns: { type: 'boolean' },
                   variables: { type: 'boolean' },
                 },
-                type: 'object',
               },
             ],
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-misused-promises',
 });
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index 68e3594b27bb..b114beb79a98 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -206,6 +206,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow enums from having both number and string members',
       recommended: 'strict',
@@ -215,7 +216,6 @@ export default createRule({
       mixed: `Mixing number and string enums can be confusing.`,
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-mixed-enums',
 });
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index 95ddae51a851..9749133535e7 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -48,6 +48,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow TypeScript namespaces',
       recommended: 'recommended',
@@ -58,23 +59,22 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowDeclarations: {
+            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces.',
-            type: 'boolean',
           },
           allowDefinitionFiles: {
+            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-namespace',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index 3315fe241f15..ba8b97824051 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -82,6 +82,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions in the left operand of a nullish coalescing operator',
@@ -94,7 +95,6 @@ export default createRule({
       suggestRemovingNonNull: 'Remove the non-null assertion.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-non-null-asserted-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index 2e474b0a5513..a816a7541a5f 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -55,6 +55,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions after an optional chain expression',
@@ -67,7 +68,6 @@ export default createRule({
       suggestRemovingNonNull: 'You should remove the non-null assertion.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-non-null-asserted-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 422f860489c0..151dce7a5c59 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -105,6 +105,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions using the `!` postfix operator',
@@ -117,7 +118,6 @@ export default createRule<[], MessageIds>({
         'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index 4e77b8adc561..c51572abaf9e 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -52,13 +52,13 @@ export default createRule<Options, MessageIds>({
       ) {
         for (const comment of variable.eslintExplicitGlobalComments) {
           yield {
+            type: 'comment',
             loc: getNameLocationInGlobalDirectiveComment(
               context.sourceCode,
               comment,
               variable.name,
             ),
             node: comment,
-            type: 'comment',
           };
         }
       }
@@ -109,7 +109,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one class declaration, which needs to be reported
           for (const { identifier } of classDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
@@ -130,7 +130,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one function declaration, which needs to be reported
           for (const { identifier } of functionDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
@@ -151,14 +151,14 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one enum declaration, which needs to be reported
           for (const { identifier } of enumDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
       }
 
       for (const { identifier } of identifiers) {
-        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+        yield { type: 'syntax', loc: identifier.loc, node: identifier };
       }
     }
 
@@ -183,7 +183,7 @@ export default createRule<Options, MessageIds>({
         const data = { id: variable.name };
 
         // Report extra declarations.
-        for (const { loc, node, type } of extraDeclarations) {
+        for (const { type, loc, node } of extraDeclarations) {
           const messageId =
             type === declaration.type ? 'redeclared' : detailMessageId;
 
@@ -246,6 +246,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow variable redeclaration',
       extendsBaseRule: true,
@@ -259,6 +260,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           builtinGlobals: {
@@ -268,10 +270,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-redeclare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index 063f9f92f383..c2fcd27ddba5 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -515,6 +515,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow members of unions and intersections that do nothing or override type information',
@@ -529,7 +530,6 @@ export default createRule({
       primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-redundant-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 69337e0d2cd4..86a6498bdf64 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -74,6 +74,7 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [{ allow: [], allowAsImport: false }],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow invocation of `require()`',
       recommended: 'recommended',
@@ -83,22 +84,21 @@ export default util.createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
+            type: 'array',
             description: 'Patterns of import paths to allow requiring from.',
             items: { type: 'string' },
-            type: 'array',
           },
           allowAsImport: {
-            description: 'Allows `require` statements in import declarations.',
             type: 'boolean',
+            description: 'Allows `require` statements in import declarations.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-require-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-imports.ts b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
index 3245778679dc..58c7ace9f7ff 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
@@ -82,16 +82,18 @@ const baseSchema = baseRule.meta.schema as {
 
 const allowTypeImportsOptionSchema: JSONSchema4ObjectSchema['properties'] = {
   allowTypeImports: {
-    description: 'Disallow value imports, but allow type-only imports.',
     type: 'boolean',
+    description: 'Disallow value imports, but allow type-only imports.',
   },
 };
 
 const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
+  type: 'array',
   items: {
     anyOf: [
       { type: 'string' },
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -108,25 +110,25 @@ const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
               .required,
           undefined,
         ),
-        type: 'object',
       },
     ],
   },
-  type: 'array',
   uniqueItems: true,
 };
 
 const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
   anyOf: [
     {
+      type: 'array',
       items: {
         type: 'string',
       },
-      type: 'array',
       uniqueItems: true,
     },
     {
+      type: 'array',
       items: {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -143,9 +145,7 @@ const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
               .required,
           [],
         ),
-        type: 'object',
       },
-      type: 'array',
       uniqueItems: true,
     },
   ],
@@ -155,18 +155,18 @@ const schema: JSONSchema4AnyOfSchema = {
   anyOf: [
     arrayOfStringsOrObjects,
     {
+      type: 'array',
       additionalItems: false,
       items: [
         {
+          type: 'object',
           additionalProperties: false,
           properties: {
             paths: arrayOfStringsOrObjects,
             patterns: arrayOfStringsOrObjectPatterns,
           },
-          type: 'object',
         },
       ],
-      type: 'array',
     },
   ],
 };
@@ -329,19 +329,19 @@ export default createRule<Options, MessageIds>({
         ) {
           const synthesizedImport: TSESTree.ImportDeclaration = {
             ...node,
+            type: AST_NODE_TYPES.ImportDeclaration,
             assertions: [],
             attributes: [],
             source: node.moduleReference.expression,
             specifiers: [
               {
                 ...node.id,
-                local: node.id,
                 type: AST_NODE_TYPES.ImportDefaultSpecifier,
+                local: node.id,
                 // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension
                 parent: node.id.parent,
               },
             ],
-            type: AST_NODE_TYPES.ImportDeclaration,
           };
           return checkImportNode(synthesizedImport);
         }
@@ -350,6 +350,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow specified modules when loaded by `import`',
       extendsBaseRule: true,
@@ -357,7 +358,6 @@ export default createRule<Options, MessageIds>({
     fixable: baseRule.meta.fixable,
     messages: baseRule.meta.messages,
     schema,
-    type: 'suggestion',
   },
   name: 'no-restricted-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index 87ee382ee28c..dbc076a7729a 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -157,6 +157,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow certain types',
     },
@@ -168,38 +169,39 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           banConfig: {
             oneOf: [
               {
+                type: 'boolean',
                 description: 'Bans the type with the default message',
                 enum: [true],
-                type: 'boolean',
               },
               {
-                description: 'Bans the type with a custom message',
                 type: 'string',
+                description: 'Bans the type with a custom message',
               },
               {
+                type: 'object',
                 additionalProperties: false,
                 description: 'Bans a type',
                 properties: {
                   fixWith: {
+                    type: 'string',
                     description:
                       'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
-                    type: 'string',
                   },
                   message: {
-                    description: 'Custom error message',
                     type: 'string',
+                    description: 'Custom error message',
                   },
                   suggest: {
+                    type: 'array',
                     description: 'Types to suggest replacing with.',
                     items: { type: 'string' },
-                    type: 'array',
                   },
                 },
-                type: 'object',
               },
             ],
           },
@@ -207,16 +209,14 @@ export default createRule<Options, MessageIds>({
         additionalProperties: false,
         properties: {
           types: {
+            type: 'object',
             additionalProperties: {
               $ref: '#/items/0/$defs/banConfig',
             },
-            type: 'object',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-restricted-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 049b656f1c6f..58e69c185a2a 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -604,6 +604,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow variable declarations from shadowing variables declared in the outer scope',
@@ -616,20 +617,21 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
+            type: 'array',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           builtinGlobals: {
             type: 'boolean',
           },
           hoist: {
-            enum: ['all', 'functions', 'never'],
             type: 'string',
+            enum: ['all', 'functions', 'never'],
           },
           ignoreFunctionTypeParameterNameValueShadow: {
             type: 'boolean',
@@ -641,10 +643,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-shadow',
 });
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 7bee02498dc0..51468e8a3827 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -49,6 +49,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow aliasing `this`',
       recommended: 'recommended',
@@ -60,26 +61,25 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowDestructuring: {
+            type: 'boolean',
             description:
               'Whether to ignore destructurings, such as `const { props, state } = this`.',
-            type: 'boolean',
           },
           allowedNames: {
+            type: 'array',
             description:
               'Names to ignore, such as ["self"] for `const self = this;`.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-this-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index adf47dad6248..272285b431cb 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -279,6 +279,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     deprecated: true,
     docs: {
       description: 'Disallow type aliases',
@@ -291,8 +292,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           expandedOptions: {
+            type: 'string',
             enum: [
               'always',
               'never',
@@ -300,11 +303,10 @@ export default createRule<Options, MessageIds>({
               'in-intersections',
               'in-unions-and-intersections',
             ] satisfies Values[],
-            type: 'string',
           },
           simpleOptions: {
-            enum: ['always', 'never'],
             type: 'string',
+            enum: ['always', 'never'],
           },
         },
         additionalProperties: false,
@@ -343,10 +345,8 @@ export default createRule<Options, MessageIds>({
             description: 'Whether to allow type aliases with tuple types.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-type-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 4d9df9513e96..0ce2972830a8 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -229,6 +229,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow unnecessary equality comparisons against boolean literals',
@@ -250,23 +251,22 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowComparingNullableBooleansToFalse: {
+            type: 'boolean',
             description:
               'Whether to allow comparisons between nullable boolean variables and `false`.',
-            type: 'boolean',
           },
           allowComparingNullableBooleansToTrue: {
+            type: 'boolean',
             description:
               'Whether to allow comparisons between nullable boolean variables and `true`.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-boolean-literal-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 4e8fea5ee6af..c6e34d8bee93 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -684,6 +684,7 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow conditionals where the type is always truthy or always falsy',
@@ -713,23 +714,22 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowConstantLoopConditions: {
+            type: 'boolean',
             description:
               'Whether to ignore constant loop conditions, such as `while (true)`.',
-            type: 'boolean',
           },
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
             description:
               'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-condition',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index 7a5751430309..49c58f6b361e 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -218,6 +218,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow unnecessary assignment of constructor property parameter',
@@ -227,7 +228,6 @@ export default createRule({
         'This assignment is unnecessary since it is already assigned by a parameter property.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-parameter-property-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index aebd62131a9f..ae8adb5bf5c1 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -176,6 +176,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary namespace qualifiers',
       requiresTypeChecking: true,
@@ -186,7 +187,6 @@ export default createRule({
         "Qualifier is unnecessary since '{{ name }}' is in scope.",
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-qualifier',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index 0698a772a372..f0b25188af86 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -255,6 +255,7 @@ export default createRule<[], MessageId>({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary template expressions',
       recommended: 'strict',
@@ -266,7 +267,6 @@ export default createRule<[], MessageId>({
         'Template literal expression is unnecessary and can be simplified.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-template-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index cb50145babfb..25e0b388ef9a 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -105,6 +105,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow type arguments that are equal to the default',
       recommended: 'strict',
@@ -116,7 +117,6 @@ export default createRule<[], MessageIds>({
         'This is the default value for this type parameter, so it can be omitted.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-type-arguments',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index 6a91baf9336b..4f1cc47c4e52 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -354,6 +354,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow type assertions that do not change the type of an expression',
@@ -369,20 +370,19 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           typesToIgnore: {
+            type: 'array',
             description: 'A list of type names to ignore.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-type-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index 4664ddfc4a47..692e5d878813 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -100,6 +100,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary constraints on generic types',
       recommended: 'recommended',
@@ -112,7 +113,6 @@ export default createRule({
         'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unnecessary-type-constraint',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index 940c5fc05dbe..74c4e2b05179 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -88,6 +88,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: "Disallow type parameters that aren't used multiple times",
       recommended: 'strict',
@@ -97,7 +98,6 @@ export default createRule({
       sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unnecessary-type-parameters',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index 57bc5984f96e..af025fd783ca 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -73,9 +73,9 @@ class FunctionSignature {
         // is a rest param
         if (checker.isArrayType(type)) {
           restType = {
+            type: checker.getTypeArguments(type)[0],
             index: i,
             kind: RestTypeKind.Array,
-            type: checker.getTypeArguments(type)[0],
           };
         } else if (checker.isTupleType(type)) {
           restType = {
@@ -85,9 +85,9 @@ class FunctionSignature {
           };
         } else {
           restType = {
+            type,
             index: i,
             kind: RestTypeKind.Other,
-            type,
           };
         }
         break;
@@ -275,6 +275,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow calling a function with a value with type `any`',
       recommended: 'recommended',
@@ -289,7 +290,6 @@ export default createRule<[], MessageIds>({
         'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-argument',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 3caa4c1cd4bf..07dc9009ad62 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -405,6 +405,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Disallow assigning a value with type `any` to variables and properties',
@@ -426,7 +427,6 @@ export default createRule({
         'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index bf661c03d7d3..270d666983ec 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -74,6 +74,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow calling a value with type `any`',
       recommended: 'recommended',
@@ -89,7 +90,6 @@ export default createRule<[], MessageIds>({
       unsafeTemplateTag: 'Unsafe any typed template tag.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-call',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index 9b698b2ace71..4579ddc21a49 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -58,6 +58,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow unsafe declaration merging',
       recommended: 'recommended',
@@ -68,7 +69,6 @@ export default createRule({
         'Unsafe declaration merging between classes and interfaces.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-declaration-merging',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index eb1045559fa0..0f63e151426b 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -188,6 +188,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow comparing an enum value with a non-enum value',
       recommended: 'recommended',
@@ -202,7 +203,6 @@ export default createRule({
       replaceValueWithEnum: 'Replace with an enum value comparison.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-unsafe-enum-comparison',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index 53ae131c1016..0ef498891eb5 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -33,6 +33,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow using the unsafe built-in Function type',
       recommended: 'recommended',
@@ -45,7 +46,6 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 1d789d949925..2fe732016107 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -75,8 +75,8 @@ export default createRule({
 
         context.report({
           data: {
-            property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
             type: createDataType(type),
+            property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
           },
           messageId,
           node: node.property,
@@ -111,8 +111,8 @@ export default createRule({
           const propertyName = context.sourceCode.getText(node);
           context.report({
             data: {
-              property: `[${propertyName}]`,
               type: createDataType(type),
+              property: `[${propertyName}]`,
             },
             messageId: 'unsafeComputedMemberAccess',
             node,
@@ -123,6 +123,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow member access on a value with type `any`',
       recommended: 'recommended',
@@ -139,7 +140,6 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-member-access',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index 5bda8442c7c5..7321be42b326 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -226,6 +226,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow returning a value with type `any` from a function',
       recommended: 'recommended',
@@ -241,7 +242,6 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-return',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index 2619ea4ec52b..b6fff68e85ec 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -44,6 +44,7 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Require unary negation to take a number',
       recommended: 'recommended',
@@ -54,7 +55,6 @@ export default util.createRule<Options, MessageIds>({
         'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-unsafe-unary-minus',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-expressions.ts b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
index 8f832ca5a780..9b6cfb5b8cf7 100644
--- a/packages/eslint-plugin/src/rules/no-unused-expressions.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
@@ -68,6 +68,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow unused expressions',
       extendsBaseRule: true,
@@ -76,7 +77,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'suggestion',
   },
   name: 'no-unused-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index 28feecb5f887..98bad1eb09fc 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -684,6 +684,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow unused variables',
       extendsBaseRule: true,
@@ -700,22 +701,23 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
-            enum: ['all', 'local'],
             type: 'string',
+            enum: ['all', 'local'],
           },
           {
+            type: 'object',
             additionalProperties: false,
             properties: {
               args: {
-                enum: ['all', 'after-used', 'none'],
                 type: 'string',
+                enum: ['all', 'after-used', 'none'],
               },
               argsIgnorePattern: {
                 type: 'string',
               },
               caughtErrors: {
-                enum: ['all', 'none'],
                 type: 'string',
+                enum: ['all', 'none'],
               },
               caughtErrorsIgnorePattern: {
                 type: 'string',
@@ -733,19 +735,17 @@ export default createRule<Options, MessageIds>({
                 type: 'boolean',
               },
               vars: {
-                enum: ['all', 'local'],
                 type: 'string',
+                enum: ['all', 'local'],
               },
               varsIgnorePattern: {
                 type: 'string',
               },
             },
-            type: 'object',
           },
         ],
       },
     ],
-    type: 'problem',
   },
   name: 'no-unused-vars',
 });
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index cd60bb1e708f..d4bdcc22d99b 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -333,6 +333,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow the use of variables before they are defined',
       extendsBaseRule: true,
@@ -344,10 +345,11 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
-            enum: ['nofunc'],
             type: 'string',
+            enum: ['nofunc'],
           },
           {
+            type: 'object',
             additionalProperties: false,
             properties: {
               allowNamedExports: { type: 'boolean' },
@@ -358,12 +360,10 @@ export default createRule<Options, MessageIds>({
               typedefs: { type: 'boolean' },
               variables: { type: 'boolean' },
             },
-            type: 'object',
           },
         ],
       },
     ],
-    type: 'problem',
   },
   name: 'no-use-before-define',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index 39a28c1e8fa0..41049ca93781 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -60,6 +60,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow unnecessary constructors',
       extendsBaseRule: true,
@@ -68,7 +69,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
-    type: 'problem',
   },
   name: 'no-useless-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index 32befd651a19..3b53a6fddf25 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -68,6 +68,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         "Disallow empty exports that don't change anything in a module file",
@@ -78,7 +79,6 @@ export default createRule({
       uselessExport: 'Empty export does nothing and can be removed.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'no-useless-empty-export',
 });
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index c13c95350c1a..5909069dbc67 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -70,6 +70,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ allow: [] }],
   meta: {
+    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow `require` statements except in import statements',
@@ -80,18 +81,17 @@ export default createRule<Options, MessageIds>({
     replacedBy: ['@typescript-eslint/no-require-imports'],
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
+            type: 'array',
             description: 'Patterns of import paths to allow requiring from.',
             items: { type: 'string' },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'no-var-requires',
 });
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index 433684819dfc..fd5f15c6a7a7 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -56,6 +56,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow using confusing built-in primitive class wrappers',
       recommended: 'recommended',
@@ -66,7 +67,6 @@ export default createRule({
         'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'no-wrapper-object-types',
 });
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index f63b3a9c78fa..447b216ff24d 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -130,6 +130,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce non-null assertions over explicit type casts',
       recommended: 'stylistic',
@@ -141,7 +142,6 @@ export default createRule({
         'Use a ! assertion to more succinctly remove null and undefined from the type.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'non-nullable-type-assertion-style',
 });
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index 2c48b9d2d3db..8d92594119eb 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -69,6 +69,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Disallow throwing non-`Error` values as exceptions',
       extendsBaseRule: 'no-throw-literal',
@@ -81,6 +82,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowThrowingAny: {
@@ -90,10 +92,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'only-throw-error',
 });
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index 4ebdd23264b6..b269026150bd 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -200,6 +200,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require or disallow parameter properties in class constructors',
@@ -212,8 +213,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         $defs: {
           modifier: {
+            type: 'string',
             enum: [
               'readonly',
               'private',
@@ -223,26 +226,23 @@ export default createRule<Options, MessageIds>({
               'protected readonly',
               'public readonly',
             ],
-            type: 'string',
           },
         },
         additionalProperties: false,
         properties: {
           allow: {
+            type: 'array',
             items: {
               $ref: '#/items/0/$defs/modifier',
             },
-            type: 'array',
           },
           prefer: {
-            enum: ['class-property', 'parameter-property'],
             type: 'string',
+            enum: ['class-property', 'parameter-property'],
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'parameter-properties',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index 54841bf69c4f..79a5f742276d 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -62,6 +62,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce the use of `as const` over literal type',
       recommended: 'recommended',
@@ -76,7 +77,6 @@ export default createRule({
       variableSuggest: 'You should use `as const` instead of type annotation.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-as-const',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index dcfa10eb8ab3..750bbe45a887 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -24,6 +24,7 @@ type Options = [BaseOptions[0], EnforcementOptions];
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 const destructuringTypeConfig: JSONSchema4 = {
+  type: 'object',
   additionalProperties: false,
   properties: {
     array: {
@@ -33,24 +34,24 @@ const destructuringTypeConfig: JSONSchema4 = {
       type: 'boolean',
     },
   },
-  type: 'object',
 };
 
 const schema: readonly JSONSchema4[] = [
   {
     oneOf: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           AssignmentExpression: destructuringTypeConfig,
           VariableDeclarator: destructuringTypeConfig,
         },
-        type: 'object',
       },
       destructuringTypeConfig,
     ],
   },
   {
+    type: 'object',
     properties: {
       enforceForDeclarationWithTypeAnnotation: {
         type: 'boolean',
@@ -59,7 +60,6 @@ const schema: readonly JSONSchema4[] = [
         type: 'boolean',
       },
     },
-    type: 'object',
   },
 ];
 
@@ -169,6 +169,7 @@ export default createRule<Options, MessageIds>({
     {},
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require destructuring from arrays and/or objects',
       extendsBaseRule: true,
@@ -178,7 +179,6 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema,
-    type: 'suggestion',
   },
   name: 'prefer-destructuring',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index 14fac17fa4a7..4a15dbcb10fd 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -52,6 +52,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require each enum member value to be explicitly initialized',
@@ -64,7 +65,6 @@ export default createRule<[], MessageIds>({
         'Can be fixed to {{ name }} = {{ suggested }}',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-enum-initializers',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index 1795d966cda5..b0436b392628 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -305,6 +305,7 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
@@ -317,7 +318,6 @@ export default createRule({
       preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-find',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index 2f76b4f09328..98129fa3f7b7 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -149,6 +149,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce the use of `for-of` loop over the standard `for` loop where possible',
@@ -159,7 +160,6 @@ export default createRule({
         'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-for-of',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index 04e1bd174db1..ec91322f7c4a 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -206,6 +206,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce using function types instead of interfaces with call signatures',
@@ -219,7 +220,6 @@ export default createRule({
         "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index 3c905915bd19..53f60c53ff17 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -250,6 +250,7 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Enforce `includes` method over `indexOf` method',
       recommended: 'stylistic',
@@ -262,7 +263,6 @@ export default createRule({
         'Use `String#includes()` method with a string instead.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-includes',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index e2ff6be8757c..035d926ec56f 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -127,6 +127,7 @@ export default createRule({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require all enum members to be literal values',
       recommended: 'strict',
@@ -137,16 +138,15 @@ export default createRule({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowBitwiseExpressions: {
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-literal-enum-member',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index 5d20247caf5b..ad06bd3567ff 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -31,6 +31,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
@@ -42,7 +43,6 @@ export default createRule({
         "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-namespace-keyword',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 360e09f3b7a7..1925ee0b69f5 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -332,6 +332,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
@@ -350,6 +351,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
@@ -364,17 +366,17 @@ export default createRule<Options, MessageIds>({
           ignorePrimitives: {
             oneOf: [
               {
+                type: 'object',
                 properties: {
                   bigint: { type: 'boolean' },
                   boolean: { type: 'boolean' },
                   number: { type: 'boolean' },
                   string: { type: 'boolean' },
                 },
-                type: 'object',
               },
               {
-                enum: [true],
                 type: 'boolean',
+                enum: [true],
               },
             ],
           },
@@ -382,10 +384,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
index 82b519fcd08a..171f6fc966cf 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts
@@ -166,13 +166,13 @@ export function gatherLogicalOperands(
 
             // typeof x.y === 'undefined'
             result.push({
+              type: OperandValidity.Valid,
               comparedName: comparedExpression.argument,
               comparisonType: operand.operator.startsWith('!')
                 ? NullishComparisonType.NotStrictEqualUndefined
                 : NullishComparisonType.StrictEqualUndefined,
               isYoda,
               node: operand,
-              type: OperandValidity.Valid,
             });
             continue;
           }
@@ -191,13 +191,13 @@ export function gatherLogicalOperands(
             ) {
               // x == null, x == undefined
               result.push({
+                type: OperandValidity.Valid,
                 comparedName: comparedExpression,
                 comparisonType: operand.operator.startsWith('!')
                   ? NullishComparisonType.NotEqualNullOrUndefined
                   : NullishComparisonType.EqualNullOrUndefined,
                 isYoda,
                 node: operand,
-                type: OperandValidity.Valid,
               });
               continue;
             }
@@ -211,25 +211,25 @@ export function gatherLogicalOperands(
             switch (comparedValue) {
               case ComparisonValueType.Null:
                 result.push({
+                  type: OperandValidity.Valid,
                   comparedName,
                   comparisonType: operand.operator.startsWith('!')
                     ? NullishComparisonType.NotStrictEqualNull
                     : NullishComparisonType.StrictEqualNull,
                   isYoda,
                   node: operand,
-                  type: OperandValidity.Valid,
                 });
                 continue;
 
               case ComparisonValueType.Undefined:
                 result.push({
+                  type: OperandValidity.Valid,
                   comparedName,
                   comparisonType: operand.operator.startsWith('!')
                     ? NullishComparisonType.NotStrictEqualUndefined
                     : NullishComparisonType.StrictEqualUndefined,
                   isYoda,
                   node: operand,
-                  type: OperandValidity.Valid,
                 });
                 continue;
 
@@ -256,11 +256,11 @@ export function gatherLogicalOperands(
           )
         ) {
           result.push({
+            type: OperandValidity.Valid,
             comparedName: operand.argument,
             comparisonType: NullishComparisonType.NotBoolean,
             isYoda: false,
             node: operand,
-            type: OperandValidity.Valid,
           });
           continue;
         }
@@ -282,11 +282,11 @@ export function gatherLogicalOperands(
           )
         ) {
           result.push({
+            type: OperandValidity.Valid,
             comparedName: operand,
             comparisonType: NullishComparisonType.Boolean,
             isYoda: false,
             node: operand,
-            type: OperandValidity.Valid,
           });
         } else {
           result.push({ type: OperandValidity.Invalid });
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 8bbae4fe808f..97ecd59471fb 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -156,6 +156,7 @@ export default createRule<
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
@@ -171,53 +172,52 @@ export default createRule<
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
+            type: 'boolean',
             description:
               'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
-            type: 'boolean',
           },
           checkAny: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           checkBigInt: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           checkBoolean: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           checkNumber: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           checkString: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           checkUnknown: {
+            type: 'boolean',
             description:
               'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
           requireNullish: {
+            type: 'boolean',
             description:
               'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index 6feb3eaea2f8..af565a76593a 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -128,6 +128,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require using Error objects as Promise rejection reasons',
       extendsBaseRule: true,
@@ -139,16 +140,15 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowEmptyReject: {
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-promise-reject-errors',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index 8909a250d1b4..220710c9cfb8 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -102,6 +102,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
@@ -112,6 +113,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allow: readonlynessOptionsSchema.properties.allow,
@@ -124,10 +126,8 @@ export default createRule<Options, MessageIds>({
           treatMethodsAsReadonly:
             readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-readonly-parameter-types',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index b347e0563b4d..09b545c62b33 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -242,6 +242,7 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ onlyInlineLambdas: false }],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
@@ -254,16 +255,15 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           onlyInlineLambdas: {
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-readonly',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 58e2ec5e384c..020113ca12ef 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -104,6 +104,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Enforce using type parameter when calling `Array#reduce` instead of casting',
@@ -116,7 +117,6 @@ export default createRule({
         'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
     },
     schema: [],
-    type: 'problem',
   },
   name: 'prefer-reduce-type-parameter',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index 73c95321cd26..921538051a6e 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -165,6 +165,7 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
@@ -176,7 +177,6 @@ export default createRule({
       regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-regexp-exec',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 3d7b95137b6f..a9e4c1a01f70 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -153,6 +153,7 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce that `this` is used when only `this` type is returned',
@@ -164,7 +165,6 @@ export default createRule({
       useThisType: 'Use `this` type instead.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'prefer-return-this-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index 7c6d6c131f93..36742de958b4 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -698,6 +698,7 @@ export default createRule<Options, MessageIds>({
   defaultOptions: [{ allowSingleElementEquality: 'never' }],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
@@ -711,19 +712,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowSingleElementEquality: {
+            type: 'string',
             description:
               'Whether to allow equality checks against the first or last element of a string.',
             enum: ['always', 'never'],
-            type: 'string',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'prefer-string-starts-ends-with',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 836719a2b725..3e6be920be76 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -67,6 +67,7 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
@@ -78,7 +79,6 @@ export default createRule<[], MessageIds>({
     },
     replacedBy: ['@typescript-eslint/ban-ts-comment'],
     schema: [],
-    type: 'problem',
   },
   name: 'prefer-ts-expect-error',
 });
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index 8642d77063e7..483544a45ddb 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -204,6 +204,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Require any function or method that returns a Promise to be marked async',
@@ -215,20 +216,21 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: {
+            type: 'boolean',
             description:
               'Whether to consider `any` and `unknown` to be Promises.',
-            type: 'boolean',
           },
           allowedPromiseNames: {
+            type: 'array',
             description:
               'Any extra names of classes or interfaces to be considered Promises.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
           checkArrowFunctions: {
             type: 'boolean',
@@ -243,10 +245,8 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'promise-function-async',
 });
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index 2c8803525731..c35517015433 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -62,6 +62,7 @@ export default createRule<Options, MessageIds>({
   ],
 
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
@@ -72,18 +73,17 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreStringArrays: {
+            type: 'boolean',
             description:
               'Whether to ignore arrays in which all elements are strings.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'require-array-sort-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index 33af3017a3a4..212f869ec37e 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -291,6 +291,7 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow async functions which do not return promises and have no `await` expression',
@@ -304,7 +305,6 @@ export default createRule({
       removeAsync: "Remove 'async'.",
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'require-await',
 });
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index f60ebde2fce6..e039d0f5eb7f 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -100,8 +100,8 @@ export default createRule<Options, MessageIds>({
         ) {
           context.report({
             data: {
-              stringLike,
               type: typeChecker.typeToString(baseType),
+              stringLike,
             },
             messageId: 'invalid',
             node: baseNode,
@@ -122,8 +122,8 @@ export default createRule<Options, MessageIds>({
           ) {
             context.report({
               data: {
-                stringLike,
                 type: typeChecker.typeToString(subBaseType),
+                stringLike,
               },
               messageId: 'invalid',
               node: baseNode,
@@ -194,6 +194,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
@@ -212,48 +213,47 @@ export default createRule<Options, MessageIds>({
       requiresTypeChecking: true,
     },
     messages: {
-      bigintAndNumber:
-        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
       invalid:
         "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
+      bigintAndNumber:
+        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
       mismatched:
         "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: {
-            description: 'Whether to allow `any` typed values.',
             type: 'boolean',
+            description: 'Whether to allow `any` typed values.',
           },
           allowBoolean: {
-            description: 'Whether to allow `boolean` typed values.',
             type: 'boolean',
+            description: 'Whether to allow `boolean` typed values.',
           },
           allowNullish: {
+            type: 'boolean',
             description:
               'Whether to allow potentially `null` or `undefined` typed values.',
-            type: 'boolean',
           },
           allowNumberAndString: {
+            type: 'boolean',
             description:
               'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
-            type: 'boolean',
           },
           allowRegExp: {
-            description: 'Whether to allow `regexp` typed values.',
             type: 'boolean',
+            description: 'Whether to allow `regexp` typed values.',
           },
           skipCompoundAssignments: {
-            description: 'Whether to skip compound assignments such as `+=`.',
             type: 'boolean',
+            description: 'Whether to skip compound assignments such as `+=`.',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'restrict-plus-operands',
 });
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index c733d4f5b9fc..93189f8b8389 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -46,9 +46,9 @@ const optionTesters = (
     ['Never', isTypeNeverType],
   ] satisfies [string, OptionTester][]
 ).map(([type, tester]) => ({
+  type,
   option: `allow${type}` as const,
   tester,
-  type,
 }));
 type Options = [
   { [Type in (typeof optionTesters)[number]['option']]?: boolean },
@@ -115,6 +115,7 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Enforce template literal expressions to be of `string` type',
@@ -138,20 +139,19 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: Object.fromEntries(
-          optionTesters.map(({ option, type }) => [
+          optionTesters.map(({ type, option }) => [
             option,
             {
-              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
               type: 'boolean',
+              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
             },
           ]),
         ),
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'restrict-template-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index e1e8b94fc2f4..b0969142dba8 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -360,6 +360,7 @@ export default createRule({
   },
   defaultOptions: ['in-try-catch'],
   meta: {
+    type: 'problem',
     docs: {
       description: 'Enforce consistent awaiting of returned promises',
       extendsBaseRule: 'no-return-await',
@@ -384,16 +385,15 @@ export default createRule({
     },
     schema: [
       {
+        type: 'string',
         enum: [
           'in-try-catch',
           'always',
           'never',
           'error-handling-correctness-only',
         ] satisfies Option[],
-        type: 'string',
       },
     ],
-    type: 'problem',
   },
   name: 'return-await',
 });
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index d73887909d6d..f6d1c0d024ee 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -162,11 +162,11 @@ export default createRule<Options, MessageIds>({
         if (expectedOrder[i].node !== sourceOrder[i].node) {
           let messageId: MessageIds = 'notSorted';
           const data = {
-            name: '',
             type:
               node.type === AST_NODE_TYPES.TSIntersectionType
                 ? 'Intersection'
                 : 'Union',
+            name: '',
           };
           if (node.parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
             messageId = 'notSortedNamed';
@@ -244,6 +244,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     deprecated: true,
     docs: {
       description:
@@ -262,33 +263,32 @@ export default createRule<Options, MessageIds>({
     ],
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           caseSensitive: {
-            description: 'Whether to sort using case sensitive sorting.',
             type: 'boolean',
+            description: 'Whether to sort using case sensitive sorting.',
           },
           checkIntersections: {
-            description: 'Whether to check intersection types.',
             type: 'boolean',
+            description: 'Whether to check intersection types.',
           },
           checkUnions: {
-            description: 'Whether to check union types.',
             type: 'boolean',
+            description: 'Whether to check union types.',
           },
           groupOrder: {
+            type: 'array',
             description: 'Ordering of the groups.',
             items: {
-              enum: getEnumNames(Group),
               type: 'string',
+              enum: getEnumNames(Group),
             },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'sort-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index 630925365333..e23684132b84 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -975,6 +975,7 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow certain types in boolean expressions',
       requiresTypeChecking: true,
@@ -1043,6 +1044,7 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: { type: 'boolean' },
@@ -1057,10 +1059,8 @@ export default createRule<Options, MessageId>({
           },
           allowString: { type: 'boolean' },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'strict-boolean-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index abce22923154..7a583438205b 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -297,6 +297,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require switch-case statements to be exhaustive',
       requiresTypeChecking: true,
@@ -311,21 +312,20 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowDefaultCaseForExhaustiveSwitch: {
-            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
             type: 'boolean',
+            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
           },
           requireDefaultForNonUnion: {
-            description: `If 'true', require a 'default' clause for switches on non-union types.`,
             type: 'boolean',
+            description: `If 'true', require a 'default' clause for switches on non-union types.`,
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'switch-exhaustiveness-check',
 });
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index 371ce0f38545..9aae4d89952d 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -97,6 +97,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow certain triple slash directives in favor of ES6-style import declarations',
@@ -108,25 +109,24 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           lib: {
-            enum: ['always', 'never'],
             type: 'string',
+            enum: ['always', 'never'],
           },
           path: {
-            enum: ['always', 'never'],
             type: 'string',
+            enum: ['always', 'never'],
           },
           types: {
-            enum: ['always', 'never', 'prefer-import'],
             type: 'string',
+            enum: ['always', 'never', 'prefer-import'],
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'triple-slash-reference',
 });
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index 91e0259fb25c..cd4080409aac 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -250,6 +250,7 @@ export default createRule<[Options], MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Require type annotations in certain places',
     },
@@ -259,6 +260,7 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
@@ -270,10 +272,8 @@ export default createRule<[Options], MessageIds>({
           [OptionKeys.VariableDeclaration]: { type: 'boolean' },
           [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'typedef',
 });
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 33b984972b62..2276abaaa2f2 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -247,6 +247,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'problem',
     docs: {
       description:
         'Enforce unbound methods are called with their expected scope',
@@ -259,18 +260,17 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreStatic: {
+            type: 'boolean',
             description:
               'Whether to skip checking whether `static` methods are correctly bound.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'problem',
   },
   name: 'unbound-method',
 });
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 80f983a727d5..9693a47acc1b 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -556,6 +556,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
@@ -571,18 +572,17 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreDifferentlyNamedParameters: {
+            type: 'boolean',
             description:
               'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'unified-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index dd55fb4fbaa1..ebd3dcb5c322 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -281,6 +281,7 @@ export default createRule<[], MessageIds>({
   defaultOptions: [],
 
   meta: {
+    type: 'suggestion',
     docs: {
       description:
         'Enforce typing arguments in Promise rejection callbacks as `unknown`',
@@ -305,7 +306,6 @@ export default createRule<[], MessageIds>({
         'Change existing type annotation to `: unknown`.',
     },
     schema: [],
-    type: 'suggestion',
   },
   name: 'use-unknown-in-catch-callback-variable',
 });

From d18f0dd6f6a3436f520fccef299fe3d7ec167b38 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Mon, 16 Sep 2024 12:57:24 -0400
Subject: [PATCH 04/13] re-order rules

---
 eslint.config.mjs                             | 40 +++++++++++--------
 .../src/rules/adjacent-overload-signatures.ts | 14 +++----
 .../eslint-plugin/src/rules/array-type.ts     | 12 +++---
 .../eslint-plugin/src/rules/await-thenable.ts |  2 +-
 .../eslint-plugin/src/rules/ban-ts-comment.ts | 12 +++---
 .../src/rules/ban-tslint-comment.ts           |  2 +-
 .../src/rules/class-literal-property-style.ts |  4 +-
 .../src/rules/class-methods-use-this.ts       | 14 +++----
 .../rules/consistent-generic-constructors.ts  |  4 +-
 .../rules/consistent-indexed-object-style.ts  |  4 +-
 .../src/rules/consistent-return.ts            |  2 +-
 .../src/rules/consistent-type-assertions.ts   | 12 +++---
 .../src/rules/consistent-type-definitions.ts  |  4 +-
 .../src/rules/consistent-type-exports.ts      |  4 +-
 .../src/rules/consistent-type-imports.ts      |  8 ++--
 .../src/rules/default-param-last.ts           |  2 +-
 .../eslint-plugin/src/rules/dot-notation.ts   | 14 +++----
 .../rules/explicit-function-return-type.ts    | 20 +++++-----
 .../rules/explicit-member-accessibility.ts    | 28 ++++++-------
 .../rules/explicit-module-boundary-types.ts   | 14 +++----
 .../src/rules/init-declarations.ts            |  2 +-
 .../eslint-plugin/src/rules/max-params.ts     |  8 ++--
 .../src/rules/member-ordering.ts              | 22 +++++-----
 .../src/rules/method-signature-style.ts       |  4 +-
 .../src/rules/naming-convention.ts            |  2 +-
 .../src/rules/no-array-constructor.ts         |  2 +-
 .../src/rules/no-array-delete.ts              |  2 +-
 .../src/rules/no-base-to-string.ts            |  8 ++--
 .../rules/no-confusing-non-null-assertion.ts  |  2 +-
 .../src/rules/no-confusing-void-expression.ts |  4 +-
 .../src/rules/no-dupe-class-members.ts        |  2 +-
 .../src/rules/no-duplicate-enum-values.ts     |  2 +-
 .../rules/no-duplicate-type-constituents.ts   | 10 ++---
 .../src/rules/no-dynamic-delete.ts            |  2 +-
 .../src/rules/no-empty-function.ts            |  4 +-
 .../src/rules/no-empty-interface.ts           |  4 +-
 .../src/rules/no-empty-object-type.ts         |  8 ++--
 .../src/rules/no-explicit-any.ts              |  8 ++--
 .../src/rules/no-extra-non-null-assertion.ts  |  2 +-
 .../src/rules/no-extraneous-class.ts          | 12 +++---
 .../src/rules/no-floating-promises.ts         | 10 ++---
 .../src/rules/no-for-in-array.ts              |  2 +-
 .../src/rules/no-implied-eval.ts              |  2 +-
 .../src/rules/no-import-type-side-effects.ts  |  2 +-
 .../src/rules/no-inferrable-types.ts          |  4 +-
 .../src/rules/no-invalid-this.ts              |  2 +-
 .../src/rules/no-invalid-void-type.ts         |  6 +--
 .../eslint-plugin/src/rules/no-loop-func.ts   |  2 +-
 .../src/rules/no-loss-of-precision.ts         |  2 +-
 .../src/rules/no-magic-numbers.ts             |  2 +-
 .../src/rules/no-meaningless-void-operator.ts |  6 +--
 .../eslint-plugin/src/rules/no-misused-new.ts |  2 +-
 .../src/rules/no-misused-promises.ts          |  6 +--
 .../eslint-plugin/src/rules/no-mixed-enums.ts |  2 +-
 .../eslint-plugin/src/rules/no-namespace.ts   |  8 ++--
 ...no-non-null-asserted-nullish-coalescing.ts |  2 +-
 .../no-non-null-asserted-optional-chain.ts    |  2 +-
 .../src/rules/no-non-null-assertion.ts        |  2 +-
 .../eslint-plugin/src/rules/no-redeclare.ts   | 16 ++++----
 .../rules/no-redundant-type-constituents.ts   |  2 +-
 .../src/rules/no-require-imports.ts           |  8 ++--
 .../src/rules/no-restricted-imports.ts        | 22 +++++-----
 .../src/rules/no-restricted-types.ts          | 20 +++++-----
 packages/eslint-plugin/src/rules/no-shadow.ts |  8 ++--
 .../eslint-plugin/src/rules/no-this-alias.ts  |  8 ++--
 .../eslint-plugin/src/rules/no-type-alias.ts  |  8 ++--
 .../no-unnecessary-boolean-literal-compare.ts |  8 ++--
 .../src/rules/no-unnecessary-condition.ts     |  8 ++--
 ...necessary-parameter-property-assignment.ts |  2 +-
 .../src/rules/no-unnecessary-qualifier.ts     |  2 +-
 .../no-unnecessary-template-expression.ts     |  2 +-
 .../rules/no-unnecessary-type-arguments.ts    |  2 +-
 .../rules/no-unnecessary-type-assertion.ts    |  6 +--
 .../rules/no-unnecessary-type-constraint.ts   |  4 +-
 .../rules/no-unnecessary-type-parameters.ts   |  4 +-
 .../src/rules/no-unsafe-argument.ts           |  6 +--
 .../src/rules/no-unsafe-assignment.ts         |  2 +-
 .../eslint-plugin/src/rules/no-unsafe-call.ts |  2 +-
 .../rules/no-unsafe-declaration-merging.ts    |  2 +-
 .../src/rules/no-unsafe-enum-comparison.ts    |  2 +-
 .../src/rules/no-unsafe-function-type.ts      |  2 +-
 .../src/rules/no-unsafe-member-access.ts      |  6 +--
 .../src/rules/no-unsafe-return.ts             |  2 +-
 .../src/rules/no-unsafe-unary-minus.ts        |  2 +-
 .../src/rules/no-unused-expressions.ts        |  2 +-
 .../eslint-plugin/src/rules/no-unused-vars.ts | 12 +++---
 .../src/rules/no-use-before-define.ts         |  6 +--
 .../src/rules/no-useless-constructor.ts       |  2 +-
 .../src/rules/no-useless-empty-export.ts      |  2 +-
 .../src/rules/no-var-requires.ts              |  6 +--
 .../src/rules/no-wrapper-object-types.ts      |  2 +-
 .../non-nullable-type-assertion-style.ts      |  2 +-
 .../src/rules/only-throw-error.ts             |  4 +-
 .../src/rules/parameter-properties.ts         | 10 ++---
 .../src/rules/prefer-as-const.ts              |  2 +-
 .../src/rules/prefer-destructuring.ts         |  8 ++--
 .../src/rules/prefer-enum-initializers.ts     |  2 +-
 .../eslint-plugin/src/rules/prefer-find.ts    |  2 +-
 .../eslint-plugin/src/rules/prefer-for-of.ts  |  2 +-
 .../src/rules/prefer-function-type.ts         |  2 +-
 .../src/rules/prefer-includes.ts              |  2 +-
 .../src/rules/prefer-literal-enum-member.ts   |  4 +-
 .../src/rules/prefer-namespace-keyword.ts     |  2 +-
 .../src/rules/prefer-nullish-coalescing.ts    |  8 ++--
 .../src/rules/prefer-optional-chain.ts        | 20 +++++-----
 .../src/rules/prefer-promise-reject-errors.ts |  4 +-
 .../rules/prefer-readonly-parameter-types.ts  |  4 +-
 .../src/rules/prefer-readonly.ts              |  4 +-
 .../src/rules/prefer-reduce-type-parameter.ts |  2 +-
 .../src/rules/prefer-regexp-exec.ts           |  2 +-
 .../src/rules/prefer-return-this-type.ts      |  2 +-
 .../rules/prefer-string-starts-ends-with.ts   |  6 +--
 .../src/rules/prefer-ts-expect-error.ts       |  2 +-
 .../src/rules/promise-function-async.ts       |  8 ++--
 .../src/rules/require-array-sort-compare.ts   |  6 +--
 .../eslint-plugin/src/rules/require-await.ts  |  2 +-
 .../src/rules/restrict-plus-operands.ts       | 24 +++++------
 .../rules/restrict-template-expressions.ts    | 10 ++---
 .../eslint-plugin/src/rules/return-await.ts   |  4 +-
 .../src/rules/sort-type-constituents.ts       | 16 ++++----
 .../src/rules/strict-boolean-expressions.ts   |  4 +-
 .../src/rules/switch-exhaustiveness-check.ts  |  8 ++--
 .../src/rules/triple-slash-reference.ts       | 10 ++---
 packages/eslint-plugin/src/rules/typedef.ts   |  4 +-
 .../eslint-plugin/src/rules/unbound-method.ts |  6 +--
 .../src/rules/unified-signatures.ts           |  6 +--
 .../use-unknown-in-catch-callback-variable.ts |  2 +-
 127 files changed, 396 insertions(+), 388 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index b316f8f5c767..e80c39da292c 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -587,22 +587,6 @@ export default tseslint.config(
       '@typescript-eslint/sort-type-constituents': 'off',
       'perfectionist/sort-classes': 'error',
       'perfectionist/sort-enums': 'error',
-      'perfectionist/sort-objects': [
-        'error',
-        {
-          customGroups: {
-            top: [
-              'meta',
-              'defaultOptions',
-              'create',
-              'type',
-              'valid',
-              'invalid',
-            ],
-          },
-          groups: ['top', 'unknown'],
-        },
-      ],
       'perfectionist/sort-union-types': [
         'error',
         {
@@ -619,4 +603,28 @@ export default tseslint.config(
       },
     },
   },
+  {
+    files: ['packages/eslint-plugin/src/rules/*.ts'],
+    rules: {
+      'perfectionist/sort-objects': [
+        'error',
+        {
+          customGroups: { top: ['name', 'meta', 'defaultOptions', 'create'] },
+          groups: ['top', 'unknown'],
+        },
+      ],
+    },
+  },
+  {
+    files: ['packages/eslint-plugin/tests/rules/*.test.ts'],
+    rules: {
+      'perfectionist/sort-objects': [
+        'error',
+        {
+          customGroups: { top: ['invalid'] },
+          groups: ['top', 'unknown'],
+        },
+      ],
+    },
+  },
 );
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index e561f08ad1e2..da57680e4492 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -56,9 +56,9 @@ export default createRule({
             return null;
           }
           return {
-            type: MemberNameType.Normal,
-            callSignature: false,
             name,
+            callSignature: false,
+            type: MemberNameType.Normal,
           };
         }
         case AST_NODE_TYPES.TSMethodSignature:
@@ -69,15 +69,15 @@ export default createRule({
           };
         case AST_NODE_TYPES.TSCallSignatureDeclaration:
           return {
-            type: MemberNameType.Normal,
-            callSignature: true,
             name: 'call',
+            callSignature: true,
+            type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.TSConstructSignatureDeclaration:
           return {
-            type: MemberNameType.Normal,
-            callSignature: false,
             name: 'new',
+            callSignature: false,
+            type: MemberNameType.Normal,
           };
         case AST_NODE_TYPES.MethodDefinition:
           return {
@@ -157,7 +157,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require that function overload signatures be consecutive',
       recommended: 'stylistic',
@@ -166,6 +165,7 @@ export default createRule({
       adjacentSignature: 'All {{name}} signatures should be adjacent.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'adjacent-overload-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 51c2cb7df1f0..92b53a9c7898 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -125,9 +125,9 @@ export default createRule<Options, MessageIds>({
 
         context.report({
           data: {
-            type: getMessageType(node.elementType),
             className: isReadonly ? 'ReadonlyArray' : 'Array',
             readonlyPrefix: isReadonly ? 'readonly ' : '',
+            type: getMessageType(node.elementType),
           },
           fix(fixer) {
             const typeNode = node.elementType;
@@ -193,9 +193,9 @@ export default createRule<Options, MessageIds>({
           // Create an 'any' array
           context.report({
             data: {
-              type: 'any',
               className: isReadonlyArrayType ? 'ReadonlyArray' : 'Array',
               readonlyPrefix,
+              type: 'any',
             },
             fix(fixer) {
               return fixer.replaceText(node, `${readonlyPrefix}any[]`);
@@ -227,9 +227,9 @@ export default createRule<Options, MessageIds>({
         const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`;
         context.report({
           data: {
-            type: getMessageType(type),
             className: isReadonlyArrayType ? node.typeName.name : 'Array',
             readonlyPrefix,
+            type: getMessageType(type),
           },
           fix(fixer) {
             return [
@@ -249,7 +249,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require consistently using either `T[]` or `Array<T>` for arrays',
@@ -272,11 +271,10 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           arrayOption: {
-            type: 'string',
             enum: ['array', 'generic', 'array-simple'],
+            type: 'string',
           },
         },
         additionalProperties: false,
@@ -291,8 +289,10 @@ export default createRule<Options, MessageIds>({
               'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'array-type',
 });
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index a58280939c4c..507b8ededfe9 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -50,7 +50,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow awaiting a value that is not a Thenable',
       recommended: 'recommended',
@@ -62,6 +61,7 @@ export default createRule({
       removeAwait: 'Remove unnecessary `await`.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'await-thenable',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index b981a32f9ac6..f00c6846f85c 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -196,7 +196,6 @@ export default createRule<[Options], MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow `@ts-<directive>` comments or require descriptions after directives',
@@ -220,24 +219,23 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           directiveConfigSchema: {
             oneOf: [
               {
-                type: 'boolean',
                 default: true,
+                type: 'boolean',
               },
               {
-                type: 'string',
                 enum: ['allow-with-description'],
+                type: 'string',
               },
               {
-                type: 'object',
                 additionalProperties: false,
                 properties: {
                   descriptionFormat: { type: 'string' },
                 },
+                type: 'object',
               },
             ],
           },
@@ -245,16 +243,18 @@ export default createRule<[Options], MessageIds>({
         additionalProperties: false,
         properties: {
           minimumDescriptionLength: {
-            type: 'number',
             default: defaultMinimumDescriptionLength,
+            type: 'number',
           },
           'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
           'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'ban-ts-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 8ab0f7704722..95ed5d959788 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -45,7 +45,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow `// tslint:<rule-flag>` comments',
       recommended: 'stylistic',
@@ -55,6 +54,7 @@ export default createRule({
       commentDetected: 'tslint comment detected: "{{ text }}"',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'ban-tslint-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index d9213d2cde4d..13109cb32e28 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -214,7 +214,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['fields'],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Enforce that literals on classes are exposed in a consistent style',
@@ -229,10 +228,11 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'string',
         enum: ['fields', 'getters'],
+        type: 'string',
       },
     ],
+    type: 'problem',
   },
   name: 'class-literal-property-style',
 });
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index b611006bbedd..f0142a26010c 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -232,7 +232,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce that class methods utilize `this`',
       extendsBaseRule: true,
@@ -243,46 +242,47 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           enforceForClassFields: {
-            type: 'boolean',
             default: true,
             description:
               'Enforces that functions used as instance field initializers utilize `this`',
+            type: 'boolean',
           },
           exceptMethods: {
-            type: 'array',
             description:
               'Allows specified method names to be ignored with this rule',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           ignoreClassesThatImplementAnInterface: {
             description:
               'Ignore classes that specifically implement some interface',
             oneOf: [
               {
-                type: 'boolean',
                 description: 'Ignore all classes that implement an interface',
+                type: 'boolean',
               },
               {
-                type: 'string',
                 description:
                   'Ignore only the public fields of classes that implement an interface',
                 enum: ['public-fields'],
+                type: 'string',
               },
             ],
           },
           ignoreOverrideMethods: {
-            type: 'boolean',
             description: 'Ignore members marked with the `override` modifier',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'class-methods-use-this',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index 6bbad334229d..06bddbfc6b52 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -125,7 +125,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['constructor'],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
@@ -140,10 +139,11 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'string',
         enum: ['type-annotation', 'constructor'],
+        type: 'string',
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-generic-constructors',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index 5a29718504ac..88c55a7eec75 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -130,7 +130,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['record'],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require or disallow the `Record` type',
       recommended: 'stylistic',
@@ -142,10 +141,11 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'string',
         enum: ['record', 'index-signature'],
+        type: 'string',
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-indexed-object-style',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-return.ts b/packages/eslint-plugin/src/rules/consistent-return.ts
index 5644278cfae2..2b62e7372e5a 100644
--- a/packages/eslint-plugin/src/rules/consistent-return.ts
+++ b/packages/eslint-plugin/src/rules/consistent-return.ts
@@ -115,7 +115,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ treatUndefinedAsUnspecified: false }],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require `return` statements to either always or never specify values',
@@ -125,6 +124,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'suggestion',
   },
   name: 'consistent-return',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index f91658154481..ed7e641381e5 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -227,7 +227,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type assertions',
       recommended: 'stylistic',
@@ -248,34 +247,35 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
-            type: 'object',
             additionalProperties: false,
             properties: {
               assertionStyle: {
-                type: 'string',
                 enum: ['never'],
+                type: 'string',
               },
             },
             required: ['assertionStyle'],
+            type: 'object',
           },
           {
-            type: 'object',
             additionalProperties: false,
             properties: {
               assertionStyle: {
-                type: 'string',
                 enum: ['as', 'angle-bracket'],
+                type: 'string',
               },
               objectLiteralTypeAssertions: {
-                type: 'string',
                 enum: ['allow', 'allow-as-parameter', 'never'],
+                type: 'string',
               },
             },
             required: ['assertionStyle'],
+            type: 'object',
           },
         ],
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-type-assertions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 633f154fd369..3cc36be45170 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -117,7 +117,6 @@ export default createRule({
   },
   defaultOptions: ['interface'],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce type definitions to consistently use either `interface` or `type`',
@@ -130,10 +129,11 @@ export default createRule({
     },
     schema: [
       {
-        type: 'string',
         enum: ['interface', 'type'],
+        type: 'string',
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-type-definitions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index b581578e5518..1a6041bee233 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -210,7 +210,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type exports',
       requiresTypeChecking: true,
@@ -227,15 +226,16 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           fixMixedExportsWithInlineTypeSpecifier: {
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-type-exports',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index 317156bf90ff..ad001e7aba02 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -909,7 +909,6 @@ export default createRule<Options, MessageIds>({
   ],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce consistent usage of type imports',
     },
@@ -924,23 +923,24 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           disallowTypeAnnotations: {
             type: 'boolean',
           },
           fixStyle: {
-            type: 'string',
             enum: ['separate-type-imports', 'inline-type-imports'],
+            type: 'string',
           },
           prefer: {
-            type: 'string',
             enum: ['type-imports', 'no-type-imports'],
+            type: 'string',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'consistent-type-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index 76b8237f0ddd..acccc135874d 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -72,7 +72,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce default parameters to be last',
       extendsBaseRule: true,
@@ -81,6 +80,7 @@ export default createRule({
       shouldBeLast: 'Default parameters should be last.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'default-param-last',
 });
diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
index 495a4d2b6802..d9efb21a0336 100644
--- a/packages/eslint-plugin/src/rules/dot-notation.ts
+++ b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -91,7 +91,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce dot notation whenever possible',
       extendsBaseRule: true,
@@ -103,32 +102,33 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowIndexSignaturePropertyAccess: {
-            type: 'boolean',
             default: false,
+            type: 'boolean',
           },
           allowKeywords: {
-            type: 'boolean',
             default: true,
+            type: 'boolean',
           },
           allowPattern: {
-            type: 'string',
             default: '',
+            type: 'string',
           },
           allowPrivateClassPropertyAccess: {
-            type: 'boolean',
             default: false,
+            type: 'boolean',
           },
           allowProtectedClassPropertyAccess: {
-            type: 'boolean',
             default: false,
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'dot-notation',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index 97aec257069e..b8264cdec926 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -194,7 +194,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require explicit return types on functions and class methods',
@@ -204,55 +203,56 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowConciseArrowFunctionExpressionsStartingWithVoid: {
-            type: 'boolean',
             description:
               'Whether to allow arrow functions that start with the `void` keyword.',
+            type: 'boolean',
           },
           allowDirectConstAssertionInArrowFunctions: {
-            type: 'boolean',
             description:
               'Whether to ignore arrow functions immediately returning a `as const` value.',
+            type: 'boolean',
           },
           allowedNames: {
-            type: 'array',
             description:
               'An array of function/method names that will not have their arguments or return values checked.',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           allowExpressions: {
-            type: 'boolean',
             description:
               'Whether to ignore function expressions (functions which are not part of a declaration).',
+            type: 'boolean',
           },
           allowFunctionsWithoutTypeParameters: {
-            type: 'boolean',
             description:
               "Whether to ignore functions that don't have generic type parameters.",
+            type: 'boolean',
           },
           allowHigherOrderFunctions: {
-            type: 'boolean',
             description:
               'Whether to ignore functions immediately returning another function expression.',
+            type: 'boolean',
           },
           allowIIFEs: {
-            type: 'boolean',
             description:
               'Whether to ignore immediately invoked function expressions (IIFEs).',
+            type: 'boolean',
           },
           allowTypedFunctionExpressions: {
-            type: 'boolean',
             description:
               'Whether to ignore type annotations on the variable of function expressions.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'explicit-function-return-type',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index e6fbe8e4bc38..1f180ff4c5d8 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -93,8 +93,8 @@ export default createRule<Options, MessageIds>({
         const publicKeyword = findPublicKeyword(methodDefinition);
         context.report({
           data: {
-            type: nodeType,
             name: methodName,
+            type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
           loc: rangeToLoc(context.sourceCode, publicKeyword.range),
@@ -103,8 +103,8 @@ export default createRule<Options, MessageIds>({
       } else if (check === 'explicit' && !methodDefinition.accessibility) {
         context.report({
           data: {
-            type: nodeType,
             name: methodName,
+            type: nodeType,
           },
           loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
           messageId: 'missingAccessibility',
@@ -228,8 +228,8 @@ export default createRule<Options, MessageIds>({
         const publicKeywordRange = findPublicKeyword(propertyDefinition);
         context.report({
           data: {
-            type: nodeType,
             name: propertyName,
+            type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeywordRange.rangeToRemove),
           loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
@@ -241,8 +241,8 @@ export default createRule<Options, MessageIds>({
       ) {
         context.report({
           data: {
-            type: nodeType,
             name: propertyName,
+            type: nodeType,
           },
           loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
           messageId: 'missingAccessibility',
@@ -278,8 +278,8 @@ export default createRule<Options, MessageIds>({
           if (!node.accessibility) {
             context.report({
               data: {
-                type: nodeType,
                 name: nodeName,
+                type: nodeType,
               },
               loc: getParameterPropertyHeadLoc(
                 context.sourceCode,
@@ -297,8 +297,8 @@ export default createRule<Options, MessageIds>({
             const publicKeyword = findPublicKeyword(node);
             context.report({
               data: {
-                type: nodeType,
                 name: nodeName,
+                type: nodeType,
               },
               fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
               loc: rangeToLoc(context.sourceCode, publicKeyword.range),
@@ -320,7 +320,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ accessibility: 'explicit' }],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require explicit accessibility modifiers on class properties and methods',
@@ -337,24 +336,23 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           accessibilityLevel: {
             oneOf: [
               {
-                type: 'string',
                 description: 'Always require an accessor.',
                 enum: ['explicit'],
+                type: 'string',
               },
               {
-                type: 'string',
                 description: 'Require an accessor except when public.',
                 enum: ['no-public'],
+                type: 'string',
               },
               {
-                type: 'string',
                 description: 'Never check whether there is an accessor.',
                 enum: ['off'],
+                type: 'string',
               },
             ],
           },
@@ -363,15 +361,13 @@ export default createRule<Options, MessageIds>({
         properties: {
           accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
           ignoredMethodNames: {
-            type: 'array',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           overrides: {
-            type: 'object',
             additionalProperties: false,
-
             properties: {
               accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
               constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
@@ -381,10 +377,14 @@ export default createRule<Options, MessageIds>({
               },
               properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
             },
+
+            type: 'object',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'explicit-member-accessibility',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index 09cdd8cbf10c..8673c647b6de 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -460,7 +460,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         "Require explicit return and argument types on exported functions' and classes' public class methods",
@@ -475,44 +474,45 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowArgumentsExplicitlyTypedAsAny: {
-            type: 'boolean',
             description:
               'Whether to ignore arguments that are explicitly typed as `any`.',
+            type: 'boolean',
           },
           allowDirectConstAssertionInArrowFunctions: {
-            type: 'boolean',
             description: [
               'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
               'You must still type the parameters of the function.',
             ].join('\n'),
+            type: 'boolean',
           },
           allowedNames: {
-            type: 'array',
             description:
               'An array of function/method names that will not have their arguments or return values checked.',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           allowHigherOrderFunctions: {
-            type: 'boolean',
             description: [
               'Whether to ignore return type annotations on functions immediately returning another function expression.',
               'You must still type the parameters of the function.',
             ].join('\n'),
+            type: 'boolean',
           },
           allowTypedFunctionExpressions: {
-            type: 'boolean',
             description:
               'Whether to ignore type annotations on the variable of a function expression.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'explicit-module-boundary-types',
 });
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 55ffecd7caed..106587e8c47e 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -99,7 +99,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['always'],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require or disallow initialization in variable declarations',
@@ -108,6 +107,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'suggestion',
   },
   name: 'init-declarations',
 });
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index 4a444a1f554f..9ac486e21c37 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -63,7 +63,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ countVoidThis: false, max: 3 }],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce a maximum number of parameters in function definitions',
@@ -72,23 +71,24 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           countVoidThis: {
             type: 'boolean',
           },
           max: {
-            type: 'integer',
             minimum: 0,
+            type: 'integer',
           },
           maximum: {
-            type: 'integer',
             minimum: 0,
+            type: 'integer',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'max-params',
 });
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index c2f61e4c0c3e..20039baa01b2 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -92,29 +92,28 @@ export type Options = [
 ];
 
 const neverConfig: JSONSchema.JSONSchema4 = {
-  type: 'string',
   enum: ['never'],
+  type: 'string',
 };
 
 const arrayConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
-  type: 'array',
   items: {
     oneOf: [
       {
         $ref: memberTypes,
       },
       {
-        type: 'array',
         items: {
           $ref: memberTypes,
         },
+        type: 'array',
       },
     ],
   },
+  type: 'array',
 });
 
 const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
-  type: 'object',
   additionalProperties: false,
   properties: {
     memberTypes: {
@@ -127,6 +126,7 @@ const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
       $ref: '#/items/0/$defs/orderOptions',
     },
   },
+  type: 'object',
 });
 
 export const defaultOrder: MemberType[] = [
@@ -427,7 +427,7 @@ function getMemberRawName(
     | TSESTree.TSPropertySignature,
   sourceCode: TSESLint.SourceCode,
 ): string {
-  const { type, name } = getNameFromMember(member, sourceCode);
+  const { name, type } = getNameFromMember(member, sourceCode);
 
   if (type === MemberNameType.Quoted) {
     return name.slice(1, -1);
@@ -1030,7 +1030,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require a consistent member declaration order',
     },
@@ -1043,18 +1042,16 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           allItems: {
-            type: 'string',
             enum: allMemberTypes as string[],
+            type: 'string',
           },
           optionalityOrderOptions: {
-            type: 'string',
             enum: ['optional-first', 'required-first'],
+            type: 'string',
           },
           orderOptions: {
-            type: 'string',
             enum: [
               'alphabetically',
               'alphabetically-case-insensitive',
@@ -1062,9 +1059,9 @@ export default createRule<Options, MessageIds>({
               'natural',
               'natural-case-insensitive',
             ],
+            type: 'string',
           },
           typeItems: {
-            type: 'string',
             enum: [
               'readonly-signature',
               'signature',
@@ -1073,6 +1070,7 @@ export default createRule<Options, MessageIds>({
               'method',
               'constructor',
             ],
+            type: 'string',
           },
 
           // These properties must follow the preceding ones for ajv logic.
@@ -1109,8 +1107,10 @@ export default createRule<Options, MessageIds>({
             $ref: '#/items/0/$defs/typesConfig',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'member-ordering',
 });
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index 39152b5a239c..dd59ae538c13 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -221,7 +221,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: ['property'],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce using a particular method signature syntax',
     },
@@ -234,10 +233,11 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'string',
         enum: ['property', 'method'],
+        type: 'string',
       },
     ],
+    type: 'suggestion',
   },
   name: 'method-signature-style',
 });
diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
index e0be03bf54fb..6a4e4bc53c74 100644
--- a/packages/eslint-plugin/src/rules/naming-convention.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention.ts
@@ -697,7 +697,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: defaultCamelCaseAllTheThingsConfig,
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce naming conventions for everything across a codebase',
@@ -719,6 +718,7 @@ export default createRule<Options, MessageIds>({
         '{{type}} name `{{name}}` must not have a {{position}} underscore.',
     },
     schema: SCHEMA,
+    type: 'suggestion',
   },
   name: 'naming-convention',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index c6815ceecfd6..361928021fee 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -46,7 +46,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow generic `Array` constructors',
       extendsBaseRule: true,
@@ -57,6 +56,7 @@ export default createRule({
       useLiteral: 'The array literal notation [] is preferable.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-array-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index 3de3cd8792c5..161081c56933 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -93,7 +93,6 @@ export default createRule<[], MessageId>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow using the `delete` operator on array values',
       recommended: 'recommended',
@@ -106,6 +105,7 @@ export default createRule<[], MessageId>({
       useSplice: 'Use `array.splice()` instead.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-array-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index 7312a0817ee6..58fc0089d400 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -38,8 +38,8 @@ export default createRule<Options, MessageIds>({
 
       context.report({
         data: {
-          certainty,
           name: context.sourceCode.getText(node),
+          certainty,
         },
         messageId: 'baseToString',
         node,
@@ -154,7 +154,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require `.toString()` to only be called on objects which provide useful information when stringified',
@@ -167,18 +166,19 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoredTypeNames: {
-            type: 'array',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-base-to-string',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index abb81f36a279..7e16276795c7 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -66,7 +66,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertion in locations that may be confusing',
@@ -85,6 +84,7 @@ export default createRule({
         'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-confusing-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 80d0845244c0..4eb54e068417 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -332,7 +332,6 @@ export default createRule<Options, MessageId>({
   },
   defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require expressions of type void to appear in statement position',
@@ -368,14 +367,15 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreArrowShorthand: { type: 'boolean' },
           ignoreVoidOperator: { type: 'boolean' },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-confusing-void-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
index 9d0154c650fd..a0d9c8e29eab 100644
--- a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
+++ b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
@@ -47,7 +47,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow duplicate class members',
       extendsBaseRule: true,
@@ -55,6 +54,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'problem',
   },
   name: 'no-dupe-class-members',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index 243fe6e6c4f2..e89f8d66256f 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -60,7 +60,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow duplicate enum member values',
       recommended: 'recommended',
@@ -70,6 +69,7 @@ export default createRule({
       duplicateValue: 'Duplicate enum member value {{value}}.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-duplicate-enum-values',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index bd7843219161..65eb54471664 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -144,13 +144,13 @@ export default createRule<Options, MessageIds>({
       };
       context.report({
         data: {
+          previous: context.sourceCode.getText(
+            duplicateConstituent.duplicatePrevious,
+          ),
           type:
             parentNode.type === AST_NODE_TYPES.TSIntersectionType
               ? 'Intersection'
               : 'Union',
-          previous: context.sourceCode.getText(
-            duplicateConstituent.duplicatePrevious,
-          ),
         },
         fix: fixer => {
           return [
@@ -181,7 +181,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow duplicate constituents of union or intersection types',
@@ -194,7 +193,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreIntersections: {
@@ -204,8 +202,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-duplicate-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index c6c883a6c16e..d0da569f7f7e 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -63,7 +63,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow using the `delete` operator on computed key expressions',
@@ -74,6 +73,7 @@ export default createRule({
       dynamicDelete: 'Do not delete dynamically computed property keys.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-dynamic-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-function.ts b/packages/eslint-plugin/src/rules/no-empty-function.ts
index ed3dbbb08a33..cb3ecae32597 100644
--- a/packages/eslint-plugin/src/rules/no-empty-function.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-function.ts
@@ -25,7 +25,6 @@ const schema = deepMerge(
     properties: {
       allow: {
         items: {
-          type: 'string',
           enum: [
             'functions',
             'arrowFunctions',
@@ -42,6 +41,7 @@ const schema = deepMerge(
             'decoratedFunctions',
             'overrideMethods',
           ],
+          type: 'string',
         },
       },
     },
@@ -165,7 +165,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow empty functions',
       extendsBaseRule: true,
@@ -174,6 +173,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [schema],
+    type: 'suggestion',
   },
   name: 'no-empty-function',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index dbe3d0bc448d..a31d2fb853bf 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -87,7 +87,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     deprecated: true,
     docs: {
       description: 'Disallow the declaration of empty interfaces',
@@ -102,15 +101,16 @@ export default createRule<Options, MessageIds>({
     replacedBy: ['@typescript-eslint/no-empty-object-type'],
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowSingleExtends: {
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-empty-interface',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index be9ffd4890cd..f89b603c0629 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -148,7 +148,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow accidentally using the "empty object" type',
       recommended: 'recommended',
@@ -166,23 +165,24 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowInterfaces: {
-            type: 'string',
             enum: ['always', 'never', 'with-single-extends'],
+            type: 'string',
           },
           allowObjectTypes: {
-            type: 'string',
             enum: ['always', 'never'],
+            type: 'string',
           },
           allowWithName: {
             type: 'string',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-empty-object-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index c49f8741031c..a945e69aefb3 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -177,7 +177,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow the `any` type',
       recommended: 'recommended',
@@ -193,21 +192,22 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           fixToUnknown: {
-            type: 'boolean',
             description:
               'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
+            type: 'boolean',
           },
           ignoreRestArgs: {
-            type: 'boolean',
             description: 'Whether to ignore rest parameter arrays.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-explicit-any',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index 260ebe3dd3c6..6b9edf3b67fa 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -26,7 +26,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow extra non-null assertions',
       recommended: 'recommended',
@@ -36,6 +35,7 @@ export default createRule({
       noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-extra-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 3c60e98cc2e7..18043abb9833 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -114,7 +114,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow classes used as namespaces',
       recommended: 'strict',
@@ -126,32 +125,33 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowConstructorOnly: {
-            type: 'boolean',
             description:
               'Whether to allow extraneous classes that contain only a constructor.',
+            type: 'boolean',
           },
           allowEmpty: {
-            type: 'boolean',
             description:
               'Whether to allow extraneous classes that have no body (i.e. are empty).',
+            type: 'boolean',
           },
           allowStaticOnly: {
-            type: 'boolean',
             description:
               'Whether to allow extraneous classes that only contain static members.',
+            type: 'boolean',
           },
           allowWithDecorator: {
-            type: 'boolean',
             description:
               'Whether to allow extraneous classes that include a decorator.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-extraneous-class',
 });
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 812a9f2546e9..6ad63ce2cc80 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -405,7 +405,6 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require Promise-like statements to be handled appropriately',
@@ -425,28 +424,29 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
           allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
           checkThenables: {
-            type: 'boolean',
             description:
               'Whether to check all "Thenable"s, not just the built-in Promise type.',
+            type: 'boolean',
           },
           ignoreIIFE: {
-            type: 'boolean',
             description:
               'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
+            type: 'boolean',
           },
           ignoreVoid: {
-            type: 'boolean',
             description: 'Whether to ignore `void` expressions.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-floating-promises',
 });
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index 0382e7e669b1..08fcb66e8413 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -31,7 +31,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow iterating over an array with a for-in loop',
       recommended: 'recommended',
@@ -42,6 +41,7 @@ export default createRule({
         'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-for-in-array',
 });
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index f466c6b5e3b6..b2f29d50c735 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -146,7 +146,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow the use of `eval()`-like methods',
       extendsBaseRule: true,
@@ -159,6 +158,7 @@ export default createRule({
       noImpliedEvalError: 'Implied eval. Consider passing a function.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-implied-eval',
 });
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index bbefdb01abb5..727e55a6ded7 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -69,7 +69,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
@@ -80,6 +79,7 @@ export default createRule<Options, MessageIds>({
         'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-import-type-side-effects',
 });
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index 399bfeccec7a..bd27cd86af07 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -256,7 +256,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
@@ -269,7 +268,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreParameters: {
@@ -279,8 +277,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-inferrable-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-this.ts b/packages/eslint-plugin/src/rules/no-invalid-this.ts
index 4405f381c3c2..f27b1ccae90d 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-this.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-this.ts
@@ -85,7 +85,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ capIsConstructor: true }],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow `this` keywords outside of classes or class-like objects',
@@ -94,6 +93,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'suggestion',
   },
   name: 'no-invalid-this',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index 327223cb6197..e9db3b139152 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -186,7 +186,6 @@ export default createRule<[Options], MessageIds>({
     { allowAsThisParameter: false, allowInGenericTypeArguments: true },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow `void` type outside of generic or return types',
       recommended: 'strict',
@@ -206,7 +205,6 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowAsThisParameter: {
@@ -216,15 +214,17 @@ export default createRule<[Options], MessageIds>({
             oneOf: [
               { type: 'boolean' },
               {
-                type: 'array',
                 items: { type: 'string' },
                 minItems: 1,
+                type: 'array',
               },
             ],
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-invalid-void-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index 2384dab24491..d53f1959b906 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -58,7 +58,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow function declarations that contain unsafe references inside loop statements',
@@ -67,6 +66,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-loop-func',
 });
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
index df688b952b3e..1631c33ac46e 100644
--- a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
+++ b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
@@ -17,7 +17,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow literal numbers that lose precision',
@@ -26,6 +25,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [],
+    type: 'problem',
   },
   name: 'no-loss-of-precision',
 });
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index 929c6a4d7981..7a39d084d894 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -127,13 +127,13 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow magic numbers',
       extendsBaseRule: true,
     },
     messages: baseRule.meta.messages,
     schema: [schema],
+    type: 'suggestion',
   },
   name: 'no-magic-numbers',
 });
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index b5d65242c6e6..4a7de1f3c2f7 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -59,7 +59,6 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
   },
   defaultOptions: [{ checkNever: false }],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow the `void` operator except when used to discard a value',
@@ -75,16 +74,17 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           checkNever: {
-            type: 'boolean',
             default: false,
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-meaningless-void-operator',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index 898d292f7e10..53c3447357ba 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -98,7 +98,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Enforce valid definition of `new` and `constructor`',
       recommended: 'recommended',
@@ -108,6 +107,7 @@ export default createRule({
       errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-misused-new',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index 4ae67624f1c6..5d4a4cdb8e3e 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -535,7 +535,6 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow Promises in places not designed to handle them',
       recommended: 'recommended',
@@ -559,7 +558,6 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           checksConditionals: {
@@ -572,7 +570,6 @@ export default createRule<Options, MessageId>({
             oneOf: [
               { type: 'boolean' },
               {
-                type: 'object',
                 additionalProperties: false,
                 properties: {
                   arguments: { type: 'boolean' },
@@ -582,12 +579,15 @@ export default createRule<Options, MessageId>({
                   returns: { type: 'boolean' },
                   variables: { type: 'boolean' },
                 },
+                type: 'object',
               },
             ],
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-misused-promises',
 });
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index b114beb79a98..68e3594b27bb 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -206,7 +206,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow enums from having both number and string members',
       recommended: 'strict',
@@ -216,6 +215,7 @@ export default createRule({
       mixed: `Mixing number and string enums can be confusing.`,
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-mixed-enums',
 });
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index 9749133535e7..95ddae51a851 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -48,7 +48,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow TypeScript namespaces',
       recommended: 'recommended',
@@ -59,22 +58,23 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowDeclarations: {
-            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces.',
+            type: 'boolean',
           },
           allowDefinitionFiles: {
-            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-namespace',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index ba8b97824051..3315fe241f15 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -82,7 +82,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions in the left operand of a nullish coalescing operator',
@@ -95,6 +94,7 @@ export default createRule({
       suggestRemovingNonNull: 'Remove the non-null assertion.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-non-null-asserted-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index a816a7541a5f..2e474b0a5513 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -55,7 +55,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions after an optional chain expression',
@@ -68,6 +67,7 @@ export default createRule({
       suggestRemovingNonNull: 'You should remove the non-null assertion.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-non-null-asserted-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 151dce7a5c59..422f860489c0 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -105,7 +105,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow non-null assertions using the `!` postfix operator',
@@ -118,6 +117,7 @@ export default createRule<[], MessageIds>({
         'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index c51572abaf9e..4e77b8adc561 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -52,13 +52,13 @@ export default createRule<Options, MessageIds>({
       ) {
         for (const comment of variable.eslintExplicitGlobalComments) {
           yield {
-            type: 'comment',
             loc: getNameLocationInGlobalDirectiveComment(
               context.sourceCode,
               comment,
               variable.name,
             ),
             node: comment,
+            type: 'comment',
           };
         }
       }
@@ -109,7 +109,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one class declaration, which needs to be reported
           for (const { identifier } of classDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -130,7 +130,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one function declaration, which needs to be reported
           for (const { identifier } of functionDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -151,14 +151,14 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one enum declaration, which needs to be reported
           for (const { identifier } of enumDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
       }
 
       for (const { identifier } of identifiers) {
-        yield { type: 'syntax', loc: identifier.loc, node: identifier };
+        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
       }
     }
 
@@ -183,7 +183,7 @@ export default createRule<Options, MessageIds>({
         const data = { id: variable.name };
 
         // Report extra declarations.
-        for (const { type, loc, node } of extraDeclarations) {
+        for (const { loc, node, type } of extraDeclarations) {
           const messageId =
             type === declaration.type ? 'redeclared' : detailMessageId;
 
@@ -246,7 +246,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow variable redeclaration',
       extendsBaseRule: true,
@@ -260,7 +259,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           builtinGlobals: {
@@ -270,8 +268,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-redeclare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index c2fcd27ddba5..063f9f92f383 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -515,7 +515,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow members of unions and intersections that do nothing or override type information',
@@ -530,6 +529,7 @@ export default createRule({
       primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-redundant-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 86a6498bdf64..69337e0d2cd4 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -74,7 +74,6 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [{ allow: [], allowAsImport: false }],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow invocation of `require()`',
       recommended: 'recommended',
@@ -84,21 +83,22 @@ export default util.createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
-            type: 'array',
             description: 'Patterns of import paths to allow requiring from.',
             items: { type: 'string' },
+            type: 'array',
           },
           allowAsImport: {
-            type: 'boolean',
             description: 'Allows `require` statements in import declarations.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-require-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-imports.ts b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
index 58c7ace9f7ff..3245778679dc 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
@@ -82,18 +82,16 @@ const baseSchema = baseRule.meta.schema as {
 
 const allowTypeImportsOptionSchema: JSONSchema4ObjectSchema['properties'] = {
   allowTypeImports: {
-    type: 'boolean',
     description: 'Disallow value imports, but allow type-only imports.',
+    type: 'boolean',
   },
 };
 
 const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
-  type: 'array',
   items: {
     anyOf: [
       { type: 'string' },
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -110,25 +108,25 @@ const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
               .required,
           undefined,
         ),
+        type: 'object',
       },
     ],
   },
+  type: 'array',
   uniqueItems: true,
 };
 
 const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
   anyOf: [
     {
-      type: 'array',
       items: {
         type: 'string',
       },
+      type: 'array',
       uniqueItems: true,
     },
     {
-      type: 'array',
       items: {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -145,7 +143,9 @@ const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
               .required,
           [],
         ),
+        type: 'object',
       },
+      type: 'array',
       uniqueItems: true,
     },
   ],
@@ -155,18 +155,18 @@ const schema: JSONSchema4AnyOfSchema = {
   anyOf: [
     arrayOfStringsOrObjects,
     {
-      type: 'array',
       additionalItems: false,
       items: [
         {
-          type: 'object',
           additionalProperties: false,
           properties: {
             paths: arrayOfStringsOrObjects,
             patterns: arrayOfStringsOrObjectPatterns,
           },
+          type: 'object',
         },
       ],
+      type: 'array',
     },
   ],
 };
@@ -329,19 +329,19 @@ export default createRule<Options, MessageIds>({
         ) {
           const synthesizedImport: TSESTree.ImportDeclaration = {
             ...node,
-            type: AST_NODE_TYPES.ImportDeclaration,
             assertions: [],
             attributes: [],
             source: node.moduleReference.expression,
             specifiers: [
               {
                 ...node.id,
-                type: AST_NODE_TYPES.ImportDefaultSpecifier,
                 local: node.id,
+                type: AST_NODE_TYPES.ImportDefaultSpecifier,
                 // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension
                 parent: node.id.parent,
               },
             ],
+            type: AST_NODE_TYPES.ImportDeclaration,
           };
           return checkImportNode(synthesizedImport);
         }
@@ -350,7 +350,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow specified modules when loaded by `import`',
       extendsBaseRule: true,
@@ -358,6 +357,7 @@ export default createRule<Options, MessageIds>({
     fixable: baseRule.meta.fixable,
     messages: baseRule.meta.messages,
     schema,
+    type: 'suggestion',
   },
   name: 'no-restricted-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index dbc076a7729a..afdf0cf07e9f 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -94,8 +94,8 @@ export default createRule<Options, MessageIds>({
 
       context.report({
         data: {
-          customMessage,
           name,
+          customMessage,
         },
         fix: fixWith
           ? (fixer): TSESLint.RuleFix => fixer.replaceText(typeNode, fixWith)
@@ -157,7 +157,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow certain types',
     },
@@ -169,39 +168,38 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           banConfig: {
             oneOf: [
               {
-                type: 'boolean',
                 description: 'Bans the type with the default message',
                 enum: [true],
+                type: 'boolean',
               },
               {
-                type: 'string',
                 description: 'Bans the type with a custom message',
+                type: 'string',
               },
               {
-                type: 'object',
                 additionalProperties: false,
                 description: 'Bans a type',
                 properties: {
                   fixWith: {
-                    type: 'string',
                     description:
                       'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
+                    type: 'string',
                   },
                   message: {
-                    type: 'string',
                     description: 'Custom error message',
+                    type: 'string',
                   },
                   suggest: {
-                    type: 'array',
                     description: 'Types to suggest replacing with.',
                     items: { type: 'string' },
+                    type: 'array',
                   },
                 },
+                type: 'object',
               },
             ],
           },
@@ -209,14 +207,16 @@ export default createRule<Options, MessageIds>({
         additionalProperties: false,
         properties: {
           types: {
-            type: 'object',
             additionalProperties: {
               $ref: '#/items/0/$defs/banConfig',
             },
+            type: 'object',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-restricted-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 58e69c185a2a..049b656f1c6f 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -604,7 +604,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow variable declarations from shadowing variables declared in the outer scope',
@@ -617,21 +616,20 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
-            type: 'array',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           builtinGlobals: {
             type: 'boolean',
           },
           hoist: {
-            type: 'string',
             enum: ['all', 'functions', 'never'],
+            type: 'string',
           },
           ignoreFunctionTypeParameterNameValueShadow: {
             type: 'boolean',
@@ -643,8 +641,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-shadow',
 });
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 51468e8a3827..7bee02498dc0 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -49,7 +49,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow aliasing `this`',
       recommended: 'recommended',
@@ -61,25 +60,26 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowDestructuring: {
-            type: 'boolean',
             description:
               'Whether to ignore destructurings, such as `const { props, state } = this`.',
+            type: 'boolean',
           },
           allowedNames: {
-            type: 'array',
             description:
               'Names to ignore, such as ["self"] for `const self = this;`.',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-this-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index 272285b431cb..adf47dad6248 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -279,7 +279,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     deprecated: true,
     docs: {
       description: 'Disallow type aliases',
@@ -292,10 +291,8 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           expandedOptions: {
-            type: 'string',
             enum: [
               'always',
               'never',
@@ -303,10 +300,11 @@ export default createRule<Options, MessageIds>({
               'in-intersections',
               'in-unions-and-intersections',
             ] satisfies Values[],
+            type: 'string',
           },
           simpleOptions: {
-            type: 'string',
             enum: ['always', 'never'],
+            type: 'string',
           },
         },
         additionalProperties: false,
@@ -345,8 +343,10 @@ export default createRule<Options, MessageIds>({
             description: 'Whether to allow type aliases with tuple types.',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-type-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 0ce2972830a8..4d9df9513e96 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -229,7 +229,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow unnecessary equality comparisons against boolean literals',
@@ -251,22 +250,23 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowComparingNullableBooleansToFalse: {
-            type: 'boolean',
             description:
               'Whether to allow comparisons between nullable boolean variables and `false`.',
+            type: 'boolean',
           },
           allowComparingNullableBooleansToTrue: {
-            type: 'boolean',
             description:
               'Whether to allow comparisons between nullable boolean variables and `true`.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-boolean-literal-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index c6e34d8bee93..4e8fea5ee6af 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -684,7 +684,6 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow conditionals where the type is always truthy or always falsy',
@@ -714,22 +713,23 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowConstantLoopConditions: {
-            type: 'boolean',
             description:
               'Whether to ignore constant loop conditions, such as `while (true)`.',
+            type: 'boolean',
           },
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            type: 'boolean',
             description:
               'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-condition',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index 49c58f6b361e..7a5751430309 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -218,7 +218,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow unnecessary assignment of constructor property parameter',
@@ -228,6 +227,7 @@ export default createRule({
         'This assignment is unnecessary since it is already assigned by a parameter property.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-parameter-property-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index ae8adb5bf5c1..aebd62131a9f 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -176,7 +176,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary namespace qualifiers',
       requiresTypeChecking: true,
@@ -187,6 +186,7 @@ export default createRule({
         "Qualifier is unnecessary since '{{ name }}' is in scope.",
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-qualifier',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index f0b25188af86..0698a772a372 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -255,7 +255,6 @@ export default createRule<[], MessageId>({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary template expressions',
       recommended: 'strict',
@@ -267,6 +266,7 @@ export default createRule<[], MessageId>({
         'Template literal expression is unnecessary and can be simplified.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-template-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index 25e0b388ef9a..cb50145babfb 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -105,7 +105,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow type arguments that are equal to the default',
       recommended: 'strict',
@@ -117,6 +116,7 @@ export default createRule<[], MessageIds>({
         'This is the default value for this type parameter, so it can be omitted.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-type-arguments',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index 4f1cc47c4e52..6a91baf9336b 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -354,7 +354,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow type assertions that do not change the type of an expression',
@@ -370,19 +369,20 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           typesToIgnore: {
-            type: 'array',
             description: 'A list of type names to ignore.',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-type-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index 692e5d878813..9c5b8ef6a7ef 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -62,8 +62,8 @@ export default createRule({
       if (constraint) {
         context.report({
           data: {
-            constraint,
             name: node.name.name,
+            constraint,
           },
           messageId: 'unnecessaryConstraint',
           node,
@@ -100,7 +100,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow unnecessary constraints on generic types',
       recommended: 'recommended',
@@ -113,6 +112,7 @@ export default createRule({
         'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unnecessary-type-constraint',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index 74c4e2b05179..809b263d3428 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -54,8 +54,8 @@ export default createRule({
 
         context.report({
           data: {
-            descriptor,
             name: typeParameter.name.text,
+            descriptor,
             uses: identifierCounts === 1 ? 'never used' : 'used only once',
           },
           messageId: 'sole',
@@ -88,7 +88,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: "Disallow type parameters that aren't used multiple times",
       recommended: 'strict',
@@ -98,6 +97,7 @@ export default createRule({
       sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unnecessary-type-parameters',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index af025fd783ca..57bc5984f96e 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -73,9 +73,9 @@ class FunctionSignature {
         // is a rest param
         if (checker.isArrayType(type)) {
           restType = {
-            type: checker.getTypeArguments(type)[0],
             index: i,
             kind: RestTypeKind.Array,
+            type: checker.getTypeArguments(type)[0],
           };
         } else if (checker.isTupleType(type)) {
           restType = {
@@ -85,9 +85,9 @@ class FunctionSignature {
           };
         } else {
           restType = {
-            type,
             index: i,
             kind: RestTypeKind.Other,
+            type,
           };
         }
         break;
@@ -275,7 +275,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow calling a function with a value with type `any`',
       recommended: 'recommended',
@@ -290,6 +289,7 @@ export default createRule<[], MessageIds>({
         'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-argument',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 07dc9009ad62..3caa4c1cd4bf 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -405,7 +405,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Disallow assigning a value with type `any` to variables and properties',
@@ -427,6 +426,7 @@ export default createRule({
         'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 270d666983ec..bf661c03d7d3 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -74,7 +74,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow calling a value with type `any`',
       recommended: 'recommended',
@@ -90,6 +89,7 @@ export default createRule<[], MessageIds>({
       unsafeTemplateTag: 'Unsafe any typed template tag.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-call',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index 4579ddc21a49..9b698b2ace71 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -58,7 +58,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow unsafe declaration merging',
       recommended: 'recommended',
@@ -69,6 +68,7 @@ export default createRule({
         'Unsafe declaration merging between classes and interfaces.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-declaration-merging',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index 0f63e151426b..eb1045559fa0 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -188,7 +188,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow comparing an enum value with a non-enum value',
       recommended: 'recommended',
@@ -203,6 +202,7 @@ export default createRule({
       replaceValueWithEnum: 'Replace with an enum value comparison.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-unsafe-enum-comparison',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index 0ef498891eb5..53ae131c1016 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -33,7 +33,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow using the unsafe built-in Function type',
       recommended: 'recommended',
@@ -46,6 +45,7 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 2fe732016107..1d789d949925 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -75,8 +75,8 @@ export default createRule({
 
         context.report({
           data: {
-            type: createDataType(type),
             property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
+            type: createDataType(type),
           },
           messageId,
           node: node.property,
@@ -111,8 +111,8 @@ export default createRule({
           const propertyName = context.sourceCode.getText(node);
           context.report({
             data: {
-              type: createDataType(type),
               property: `[${propertyName}]`,
+              type: createDataType(type),
             },
             messageId: 'unsafeComputedMemberAccess',
             node,
@@ -123,7 +123,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow member access on a value with type `any`',
       recommended: 'recommended',
@@ -140,6 +139,7 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-member-access',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index 7321be42b326..5bda8442c7c5 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -226,7 +226,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow returning a value with type `any` from a function',
       recommended: 'recommended',
@@ -242,6 +241,7 @@ export default createRule({
       ].join('\n'),
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-return',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index b6fff68e85ec..2619ea4ec52b 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -44,7 +44,6 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Require unary negation to take a number',
       recommended: 'recommended',
@@ -55,6 +54,7 @@ export default util.createRule<Options, MessageIds>({
         'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-unsafe-unary-minus',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-expressions.ts b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
index 9b6cfb5b8cf7..8f832ca5a780 100644
--- a/packages/eslint-plugin/src/rules/no-unused-expressions.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
@@ -68,7 +68,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow unused expressions',
       extendsBaseRule: true,
@@ -77,6 +76,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'suggestion',
   },
   name: 'no-unused-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index 98bad1eb09fc..28feecb5f887 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -684,7 +684,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{}],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow unused variables',
       extendsBaseRule: true,
@@ -701,23 +700,22 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
-            type: 'string',
             enum: ['all', 'local'],
+            type: 'string',
           },
           {
-            type: 'object',
             additionalProperties: false,
             properties: {
               args: {
-                type: 'string',
                 enum: ['all', 'after-used', 'none'],
+                type: 'string',
               },
               argsIgnorePattern: {
                 type: 'string',
               },
               caughtErrors: {
-                type: 'string',
                 enum: ['all', 'none'],
+                type: 'string',
               },
               caughtErrorsIgnorePattern: {
                 type: 'string',
@@ -735,17 +733,19 @@ export default createRule<Options, MessageIds>({
                 type: 'boolean',
               },
               vars: {
-                type: 'string',
                 enum: ['all', 'local'],
+                type: 'string',
               },
               varsIgnorePattern: {
                 type: 'string',
               },
             },
+            type: 'object',
           },
         ],
       },
     ],
+    type: 'problem',
   },
   name: 'no-unused-vars',
 });
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index d4bdcc22d99b..cd60bb1e708f 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -333,7 +333,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow the use of variables before they are defined',
       extendsBaseRule: true,
@@ -345,11 +344,10 @@ export default createRule<Options, MessageIds>({
       {
         oneOf: [
           {
-            type: 'string',
             enum: ['nofunc'],
+            type: 'string',
           },
           {
-            type: 'object',
             additionalProperties: false,
             properties: {
               allowNamedExports: { type: 'boolean' },
@@ -360,10 +358,12 @@ export default createRule<Options, MessageIds>({
               typedefs: { type: 'boolean' },
               variables: { type: 'boolean' },
             },
+            type: 'object',
           },
         ],
       },
     ],
+    type: 'problem',
   },
   name: 'no-use-before-define',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index 41049ca93781..39a28c1e8fa0 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -60,7 +60,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow unnecessary constructors',
       extendsBaseRule: true,
@@ -69,6 +68,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
+    type: 'problem',
   },
   name: 'no-useless-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index 3b53a6fddf25..32befd651a19 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -68,7 +68,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         "Disallow empty exports that don't change anything in a module file",
@@ -79,6 +78,7 @@ export default createRule({
       uselessExport: 'Empty export does nothing and can be removed.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'no-useless-empty-export',
 });
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index 5909069dbc67..c13c95350c1a 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -70,7 +70,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ allow: [] }],
   meta: {
-    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow `require` statements except in import statements',
@@ -81,17 +80,18 @@ export default createRule<Options, MessageIds>({
     replacedBy: ['@typescript-eslint/no-require-imports'],
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allow: {
-            type: 'array',
             description: 'Patterns of import paths to allow requiring from.',
             items: { type: 'string' },
+            type: 'array',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'no-var-requires',
 });
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index fd5f15c6a7a7..433684819dfc 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -56,7 +56,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow using confusing built-in primitive class wrappers',
       recommended: 'recommended',
@@ -67,6 +66,7 @@ export default createRule({
         'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'no-wrapper-object-types',
 });
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index 447b216ff24d..f63b3a9c78fa 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -130,7 +130,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce non-null assertions over explicit type casts',
       recommended: 'stylistic',
@@ -142,6 +141,7 @@ export default createRule({
         'Use a ! assertion to more succinctly remove null and undefined from the type.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'non-nullable-type-assertion-style',
 });
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index 8d92594119eb..2c48b9d2d3db 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -69,7 +69,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Disallow throwing non-`Error` values as exceptions',
       extendsBaseRule: 'no-throw-literal',
@@ -82,7 +81,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowThrowingAny: {
@@ -92,8 +90,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'only-throw-error',
 });
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index b269026150bd..4ebdd23264b6 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -200,7 +200,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require or disallow parameter properties in class constructors',
@@ -213,10 +212,8 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         $defs: {
           modifier: {
-            type: 'string',
             enum: [
               'readonly',
               'private',
@@ -226,23 +223,26 @@ export default createRule<Options, MessageIds>({
               'protected readonly',
               'public readonly',
             ],
+            type: 'string',
           },
         },
         additionalProperties: false,
         properties: {
           allow: {
-            type: 'array',
             items: {
               $ref: '#/items/0/$defs/modifier',
             },
+            type: 'array',
           },
           prefer: {
-            type: 'string',
             enum: ['class-property', 'parameter-property'],
+            type: 'string',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'parameter-properties',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index 79a5f742276d..54841bf69c4f 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -62,7 +62,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce the use of `as const` over literal type',
       recommended: 'recommended',
@@ -77,6 +76,7 @@ export default createRule({
       variableSuggest: 'You should use `as const` instead of type annotation.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-as-const',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index 750bbe45a887..dcfa10eb8ab3 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -24,7 +24,6 @@ type Options = [BaseOptions[0], EnforcementOptions];
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 const destructuringTypeConfig: JSONSchema4 = {
-  type: 'object',
   additionalProperties: false,
   properties: {
     array: {
@@ -34,24 +33,24 @@ const destructuringTypeConfig: JSONSchema4 = {
       type: 'boolean',
     },
   },
+  type: 'object',
 };
 
 const schema: readonly JSONSchema4[] = [
   {
     oneOf: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           AssignmentExpression: destructuringTypeConfig,
           VariableDeclarator: destructuringTypeConfig,
         },
+        type: 'object',
       },
       destructuringTypeConfig,
     ],
   },
   {
-    type: 'object',
     properties: {
       enforceForDeclarationWithTypeAnnotation: {
         type: 'boolean',
@@ -60,6 +59,7 @@ const schema: readonly JSONSchema4[] = [
         type: 'boolean',
       },
     },
+    type: 'object',
   },
 ];
 
@@ -169,7 +169,6 @@ export default createRule<Options, MessageIds>({
     {},
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require destructuring from arrays and/or objects',
       extendsBaseRule: true,
@@ -179,6 +178,7 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema,
+    type: 'suggestion',
   },
   name: 'prefer-destructuring',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index 4a15dbcb10fd..14fac17fa4a7 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -52,7 +52,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require each enum member value to be explicitly initialized',
@@ -65,6 +64,7 @@ export default createRule<[], MessageIds>({
         'Can be fixed to {{ name }} = {{ suggested }}',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-enum-initializers',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index b0436b392628..1795d966cda5 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -305,7 +305,6 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
@@ -318,6 +317,7 @@ export default createRule({
       preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-find',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index 98129fa3f7b7..2f76b4f09328 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -149,7 +149,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce the use of `for-of` loop over the standard `for` loop where possible',
@@ -160,6 +159,7 @@ export default createRule({
         'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-for-of',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index ec91322f7c4a..04e1bd174db1 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -206,7 +206,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce using function types instead of interfaces with call signatures',
@@ -220,6 +219,7 @@ export default createRule({
         "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index 53f60c53ff17..3c905915bd19 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -250,7 +250,6 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Enforce `includes` method over `indexOf` method',
       recommended: 'stylistic',
@@ -263,6 +262,7 @@ export default createRule({
         'Use `String#includes()` method with a string instead.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-includes',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index 035d926ec56f..e2ff6be8757c 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -127,7 +127,6 @@ export default createRule({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require all enum members to be literal values',
       recommended: 'strict',
@@ -138,15 +137,16 @@ export default createRule({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowBitwiseExpressions: {
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-literal-enum-member',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index ad06bd3567ff..5d20247caf5b 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -31,7 +31,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
@@ -43,6 +42,7 @@ export default createRule({
         "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-namespace-keyword',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 1925ee0b69f5..360e09f3b7a7 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -332,7 +332,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
@@ -351,7 +350,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
@@ -366,17 +364,17 @@ export default createRule<Options, MessageIds>({
           ignorePrimitives: {
             oneOf: [
               {
-                type: 'object',
                 properties: {
                   bigint: { type: 'boolean' },
                   boolean: { type: 'boolean' },
                   number: { type: 'boolean' },
                   string: { type: 'boolean' },
                 },
+                type: 'object',
               },
               {
-                type: 'boolean',
                 enum: [true],
+                type: 'boolean',
               },
             ],
           },
@@ -384,8 +382,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 97ecd59471fb..8bbae4fe808f 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -156,7 +156,6 @@ export default createRule<
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
@@ -172,52 +171,53 @@ export default createRule<
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
-            type: 'boolean',
             description:
               'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
+            type: 'boolean',
           },
           checkAny: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           checkBigInt: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           checkBoolean: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           checkNumber: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           checkString: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           checkUnknown: {
-            type: 'boolean',
             description:
               'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
           requireNullish: {
-            type: 'boolean',
             description:
               'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index af565a76593a..6feb3eaea2f8 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -128,7 +128,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require using Error objects as Promise rejection reasons',
       extendsBaseRule: true,
@@ -140,15 +139,16 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowEmptyReject: {
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-promise-reject-errors',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index 220710c9cfb8..8909a250d1b4 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -102,7 +102,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
@@ -113,7 +112,6 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allow: readonlynessOptionsSchema.properties.allow,
@@ -126,8 +124,10 @@ export default createRule<Options, MessageIds>({
           treatMethodsAsReadonly:
             readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-readonly-parameter-types',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index 09b545c62b33..b347e0563b4d 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -242,7 +242,6 @@ export default createRule<Options, MessageIds>({
   },
   defaultOptions: [{ onlyInlineLambdas: false }],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
@@ -255,15 +254,16 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           onlyInlineLambdas: {
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-readonly',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 020113ca12ef..58e2ec5e384c 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -104,7 +104,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Enforce using type parameter when calling `Array#reduce` instead of casting',
@@ -117,6 +116,7 @@ export default createRule({
         'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
     },
     schema: [],
+    type: 'problem',
   },
   name: 'prefer-reduce-type-parameter',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index 921538051a6e..73c95321cd26 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -165,7 +165,6 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
@@ -177,6 +176,7 @@ export default createRule({
       regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-regexp-exec',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index a9e4c1a01f70..3d7b95137b6f 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -153,7 +153,6 @@ export default createRule({
   defaultOptions: [],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce that `this` is used when only `this` type is returned',
@@ -165,6 +164,7 @@ export default createRule({
       useThisType: 'Use `this` type instead.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'prefer-return-this-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index 36742de958b4..7c6d6c131f93 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -698,7 +698,6 @@ export default createRule<Options, MessageIds>({
   defaultOptions: [{ allowSingleElementEquality: 'never' }],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
@@ -712,18 +711,19 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowSingleElementEquality: {
-            type: 'string',
             description:
               'Whether to allow equality checks against the first or last element of a string.',
             enum: ['always', 'never'],
+            type: 'string',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'prefer-string-starts-ends-with',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 3e6be920be76..836719a2b725 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -67,7 +67,6 @@ export default createRule<[], MessageIds>({
   },
   defaultOptions: [],
   meta: {
-    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
@@ -79,6 +78,7 @@ export default createRule<[], MessageIds>({
     },
     replacedBy: ['@typescript-eslint/ban-ts-comment'],
     schema: [],
+    type: 'problem',
   },
   name: 'prefer-ts-expect-error',
 });
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index 483544a45ddb..8642d77063e7 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -204,7 +204,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Require any function or method that returns a Promise to be marked async',
@@ -216,21 +215,20 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: {
-            type: 'boolean',
             description:
               'Whether to consider `any` and `unknown` to be Promises.',
+            type: 'boolean',
           },
           allowedPromiseNames: {
-            type: 'array',
             description:
               'Any extra names of classes or interfaces to be considered Promises.',
             items: {
               type: 'string',
             },
+            type: 'array',
           },
           checkArrowFunctions: {
             type: 'boolean',
@@ -245,8 +243,10 @@ export default createRule<Options, MessageIds>({
             type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'promise-function-async',
 });
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index c35517015433..2c8803525731 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -62,7 +62,6 @@ export default createRule<Options, MessageIds>({
   ],
 
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
@@ -73,17 +72,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreStringArrays: {
-            type: 'boolean',
             description:
               'Whether to ignore arrays in which all elements are strings.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'require-array-sort-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index 212f869ec37e..33af3017a3a4 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -291,7 +291,6 @@ export default createRule({
   },
   defaultOptions: [],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow async functions which do not return promises and have no `await` expression',
@@ -305,6 +304,7 @@ export default createRule({
       removeAsync: "Remove 'async'.",
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'require-await',
 });
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index e039d0f5eb7f..f60ebde2fce6 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -100,8 +100,8 @@ export default createRule<Options, MessageIds>({
         ) {
           context.report({
             data: {
-              type: typeChecker.typeToString(baseType),
               stringLike,
+              type: typeChecker.typeToString(baseType),
             },
             messageId: 'invalid',
             node: baseNode,
@@ -122,8 +122,8 @@ export default createRule<Options, MessageIds>({
           ) {
             context.report({
               data: {
-                type: typeChecker.typeToString(subBaseType),
                 stringLike,
+                type: typeChecker.typeToString(subBaseType),
               },
               messageId: 'invalid',
               node: baseNode,
@@ -194,7 +194,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
@@ -213,47 +212,48 @@ export default createRule<Options, MessageIds>({
       requiresTypeChecking: true,
     },
     messages: {
-      invalid:
-        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
       bigintAndNumber:
         "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
+      invalid:
+        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
       mismatched:
         "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: {
-            type: 'boolean',
             description: 'Whether to allow `any` typed values.',
+            type: 'boolean',
           },
           allowBoolean: {
-            type: 'boolean',
             description: 'Whether to allow `boolean` typed values.',
+            type: 'boolean',
           },
           allowNullish: {
-            type: 'boolean',
             description:
               'Whether to allow potentially `null` or `undefined` typed values.',
+            type: 'boolean',
           },
           allowNumberAndString: {
-            type: 'boolean',
             description:
               'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
+            type: 'boolean',
           },
           allowRegExp: {
-            type: 'boolean',
             description: 'Whether to allow `regexp` typed values.',
+            type: 'boolean',
           },
           skipCompoundAssignments: {
-            type: 'boolean',
             description: 'Whether to skip compound assignments such as `+=`.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'restrict-plus-operands',
 });
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index 93189f8b8389..c733d4f5b9fc 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -46,9 +46,9 @@ const optionTesters = (
     ['Never', isTypeNeverType],
   ] satisfies [string, OptionTester][]
 ).map(([type, tester]) => ({
-  type,
   option: `allow${type}` as const,
   tester,
+  type,
 }));
 type Options = [
   { [Type in (typeof optionTesters)[number]['option']]?: boolean },
@@ -115,7 +115,6 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Enforce template literal expressions to be of `string` type',
@@ -139,19 +138,20 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: Object.fromEntries(
-          optionTesters.map(({ type, option }) => [
+          optionTesters.map(({ option, type }) => [
             option,
             {
-              type: 'boolean',
               description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
+              type: 'boolean',
             },
           ]),
         ),
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'restrict-template-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index b0969142dba8..e1e8b94fc2f4 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -360,7 +360,6 @@ export default createRule({
   },
   defaultOptions: ['in-try-catch'],
   meta: {
-    type: 'problem',
     docs: {
       description: 'Enforce consistent awaiting of returned promises',
       extendsBaseRule: 'no-return-await',
@@ -385,15 +384,16 @@ export default createRule({
     },
     schema: [
       {
-        type: 'string',
         enum: [
           'in-try-catch',
           'always',
           'never',
           'error-handling-correctness-only',
         ] satisfies Option[],
+        type: 'string',
       },
     ],
+    type: 'problem',
   },
   name: 'return-await',
 });
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index f6d1c0d024ee..d73887909d6d 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -162,11 +162,11 @@ export default createRule<Options, MessageIds>({
         if (expectedOrder[i].node !== sourceOrder[i].node) {
           let messageId: MessageIds = 'notSorted';
           const data = {
+            name: '',
             type:
               node.type === AST_NODE_TYPES.TSIntersectionType
                 ? 'Intersection'
                 : 'Union',
-            name: '',
           };
           if (node.parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
             messageId = 'notSortedNamed';
@@ -244,7 +244,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     deprecated: true,
     docs: {
       description:
@@ -263,32 +262,33 @@ export default createRule<Options, MessageIds>({
     ],
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           caseSensitive: {
-            type: 'boolean',
             description: 'Whether to sort using case sensitive sorting.',
+            type: 'boolean',
           },
           checkIntersections: {
-            type: 'boolean',
             description: 'Whether to check intersection types.',
+            type: 'boolean',
           },
           checkUnions: {
-            type: 'boolean',
             description: 'Whether to check union types.',
+            type: 'boolean',
           },
           groupOrder: {
-            type: 'array',
             description: 'Ordering of the groups.',
             items: {
-              type: 'string',
               enum: getEnumNames(Group),
+              type: 'string',
             },
+            type: 'array',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'sort-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index e23684132b84..630925365333 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -975,7 +975,6 @@ export default createRule<Options, MessageId>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Disallow certain types in boolean expressions',
       requiresTypeChecking: true,
@@ -1044,7 +1043,6 @@ export default createRule<Options, MessageId>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowAny: { type: 'boolean' },
@@ -1059,8 +1057,10 @@ export default createRule<Options, MessageId>({
           },
           allowString: { type: 'boolean' },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'strict-boolean-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index 7a583438205b..abce22923154 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -297,7 +297,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require switch-case statements to be exhaustive',
       requiresTypeChecking: true,
@@ -312,20 +311,21 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           allowDefaultCaseForExhaustiveSwitch: {
-            type: 'boolean',
             description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
+            type: 'boolean',
           },
           requireDefaultForNonUnion: {
-            type: 'boolean',
             description: `If 'true', require a 'default' clause for switches on non-union types.`,
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'switch-exhaustiveness-check',
 });
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index 9aae4d89952d..371ce0f38545 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -97,7 +97,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow certain triple slash directives in favor of ES6-style import declarations',
@@ -109,24 +108,25 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           lib: {
-            type: 'string',
             enum: ['always', 'never'],
+            type: 'string',
           },
           path: {
-            type: 'string',
             enum: ['always', 'never'],
+            type: 'string',
           },
           types: {
-            type: 'string',
             enum: ['always', 'never', 'prefer-import'],
+            type: 'string',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'triple-slash-reference',
 });
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index cd4080409aac..91e0259fb25c 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -250,7 +250,6 @@ export default createRule<[Options], MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description: 'Require type annotations in certain places',
     },
@@ -260,7 +259,6 @@ export default createRule<[Options], MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
@@ -272,8 +270,10 @@ export default createRule<[Options], MessageIds>({
           [OptionKeys.VariableDeclaration]: { type: 'boolean' },
           [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'typedef',
 });
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 2276abaaa2f2..33b984972b62 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -247,7 +247,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'problem',
     docs: {
       description:
         'Enforce unbound methods are called with their expected scope',
@@ -260,17 +259,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreStatic: {
-            type: 'boolean',
             description:
               'Whether to skip checking whether `static` methods are correctly bound.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'problem',
   },
   name: 'unbound-method',
 });
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 9693a47acc1b..80f983a727d5 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -556,7 +556,6 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
@@ -572,17 +571,18 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
-        type: 'object',
         additionalProperties: false,
         properties: {
           ignoreDifferentlyNamedParameters: {
-            type: 'boolean',
             description:
               'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
+            type: 'boolean',
           },
         },
+        type: 'object',
       },
     ],
+    type: 'suggestion',
   },
   name: 'unified-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index ebd3dcb5c322..dd55fb4fbaa1 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -281,7 +281,6 @@ export default createRule<[], MessageIds>({
   defaultOptions: [],
 
   meta: {
-    type: 'suggestion',
     docs: {
       description:
         'Enforce typing arguments in Promise rejection callbacks as `unknown`',
@@ -306,6 +305,7 @@ export default createRule<[], MessageIds>({
         'Change existing type annotation to `: unknown`.',
     },
     schema: [],
+    type: 'suggestion',
   },
   name: 'use-unknown-in-catch-callback-variable',
 });

From 4298e75243c550941fcfe5861482fc7d63a362da Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Mon, 16 Sep 2024 13:01:30 -0400
Subject: [PATCH 05/13] re-order rules, correctly this time

---
 eslint.config.mjs                             |   2 +-
 .../src/rules/adjacent-overload-signatures.ts |  32 +--
 .../eslint-plugin/src/rules/array-type.ts     | 110 +++++-----
 .../eslint-plugin/src/rules/await-thenable.ts |  32 +--
 .../eslint-plugin/src/rules/ban-ts-comment.ts | 142 ++++++------
 .../src/rules/ban-tslint-comment.ts           |  28 +--
 .../src/rules/class-literal-property-style.ts |  46 ++--
 .../src/rules/class-methods-use-this.ts       | 124 +++++------
 .../rules/consistent-generic-constructors.ts  |  46 ++--
 .../rules/consistent-indexed-object-style.ts  |  40 ++--
 .../src/rules/consistent-return.ts            |  28 +--
 .../src/rules/consistent-type-assertions.ts   | 116 +++++-----
 .../src/rules/consistent-type-definitions.ts  |  42 ++--
 .../src/rules/consistent-type-exports.ts      |  68 +++---
 .../src/rules/consistent-type-imports.ts      |  86 ++++----
 .../src/rules/default-param-last.ts           |  26 +--
 .../eslint-plugin/src/rules/dot-notation.ts   | 100 ++++-----
 .../rules/explicit-function-return-type.ts    | 148 ++++++-------
 .../rules/explicit-member-accessibility.ts    | 138 ++++++------
 .../rules/explicit-module-boundary-types.ts   | 130 +++++------
 .../src/rules/init-declarations.ts            |  26 +--
 .../eslint-plugin/src/rules/max-params.ts     |  60 +++---
 .../src/rules/member-ordering.ts              | 190 ++++++++--------
 .../src/rules/method-signature-style.ts       |  42 ++--
 .../src/rules/naming-convention.ts            |  52 ++---
 .../src/rules/no-array-constructor.ts         |  30 +--
 .../src/rules/no-array-delete.ts              |  34 +--
 .../src/rules/no-base-to-string.ts            |  66 +++---
 .../rules/no-confusing-non-null-assertion.ts  |  46 ++--
 .../src/rules/no-confusing-void-expression.ts |  96 ++++-----
 .../src/rules/no-dupe-class-members.ts        |  24 +--
 .../src/rules/no-duplicate-enum-values.ts     |  28 +--
 .../rules/no-duplicate-type-constituents.ts   |  74 +++----
 .../src/rules/no-dynamic-delete.ts            |  30 +--
 .../src/rules/no-empty-function.ts            |  36 ++--
 .../src/rules/no-empty-interface.ts           |  64 +++---
 .../src/rules/no-empty-object-type.ts         |  88 ++++----
 .../src/rules/no-explicit-any.ts              |  80 +++----
 .../src/rules/no-extra-non-null-assertion.ts  |  28 +--
 .../src/rules/no-extraneous-class.ts          |  98 ++++-----
 .../src/rules/no-floating-promises.ts         | 108 +++++-----
 .../src/rules/no-for-in-array.ts              |  30 +--
 .../src/rules/no-implied-eval.ts              |  34 +--
 .../src/rules/no-import-type-side-effects.ts  |  30 +--
 .../src/rules/no-inferrable-types.ts          |  68 +++---
 .../src/rules/no-invalid-this.ts              |  26 +--
 .../src/rules/no-invalid-void-type.ts         |  90 ++++----
 .../eslint-plugin/src/rules/no-loop-func.ts   |  26 +--
 .../src/rules/no-loss-of-precision.ts         |   8 +-
 .../src/rules/no-magic-numbers.ts             |  44 ++--
 .../src/rules/no-meaningless-void-operator.ts |  60 +++---
 .../eslint-plugin/src/rules/no-misused-new.ts |  28 +--
 .../src/rules/no-misused-promises.ts          | 126 +++++------
 .../eslint-plugin/src/rules/no-mixed-enums.ts |  28 +--
 .../eslint-plugin/src/rules/no-namespace.ts   |  64 +++---
 ...no-non-null-asserted-nullish-coalescing.ts |  34 +--
 .../no-non-null-asserted-optional-chain.ts    |  34 +--
 .../src/rules/no-non-null-assertion.ts        |  34 +--
 .../eslint-plugin/src/rules/no-redeclare.ts   |  82 +++----
 .../rules/no-redundant-type-constituents.ts   |  38 ++--
 .../src/rules/no-require-imports.ts           |  58 ++---
 .../src/rules/no-restricted-imports.ts        |  44 ++--
 .../src/rules/no-restricted-types.ts          | 128 +++++------
 packages/eslint-plugin/src/rules/no-shadow.ts | 108 +++++-----
 .../eslint-plugin/src/rules/no-this-alias.ts  |  66 +++---
 .../eslint-plugin/src/rules/no-type-alias.ts  | 166 +++++++-------
 .../no-unnecessary-boolean-literal-compare.ts |  94 ++++----
 .../src/rules/no-unnecessary-condition.ts     | 110 +++++-----
 ...necessary-parameter-property-assignment.ts |  28 +--
 .../src/rules/no-unnecessary-qualifier.ts     |  30 +--
 .../no-unnecessary-template-expression.ts     |  32 +--
 .../rules/no-unnecessary-type-arguments.ts    |  32 +--
 .../rules/no-unnecessary-type-assertion.ts    |  66 +++---
 .../rules/no-unnecessary-type-constraint.ts   |  34 +--
 .../rules/no-unnecessary-type-parameters.ts   |  28 +--
 .../src/rules/no-unsafe-argument.ts           |  42 ++--
 .../src/rules/no-unsafe-assignment.ts         |  52 ++---
 .../eslint-plugin/src/rules/no-unsafe-call.ts |  40 ++--
 .../rules/no-unsafe-declaration-merging.ts    |  30 +--
 .../src/rules/no-unsafe-enum-comparison.ts    |  38 ++--
 .../src/rules/no-unsafe-function-type.ts      |  34 +--
 .../src/rules/no-unsafe-member-access.ts      |  46 ++--
 .../src/rules/no-unsafe-return.ts             |  40 ++--
 .../src/rules/no-unsafe-unary-minus.ts        |  30 +--
 .../src/rules/no-unused-expressions.ts        |  38 ++--
 .../eslint-plugin/src/rules/no-unused-vars.ts | 132 ++++++------
 .../src/rules/no-use-before-define.ts         |  90 ++++----
 .../src/rules/no-useless-constructor.ts       |  26 +--
 .../src/rules/no-useless-empty-export.ts      |  30 +--
 .../src/rules/no-var-requires.ts              |  52 ++---
 .../src/rules/no-wrapper-object-types.ts      |  30 +--
 .../non-nullable-type-assertion-style.ts      |  32 +--
 .../src/rules/only-throw-error.ts             |  68 +++---
 .../src/rules/parameter-properties.ts         | 104 ++++-----
 .../src/rules/prefer-as-const.ts              |  38 ++--
 .../src/rules/prefer-destructuring.ts         |  58 ++---
 .../src/rules/prefer-enum-initializers.ts     |  34 +--
 .../eslint-plugin/src/rules/prefer-find.ts    |  36 ++--
 .../eslint-plugin/src/rules/prefer-for-of.ts  |  30 +--
 .../src/rules/prefer-function-type.ts         |  36 ++--
 .../src/rules/prefer-includes.ts              |  36 ++--
 .../src/rules/prefer-literal-enum-member.ts   |  56 ++---
 .../src/rules/prefer-namespace-keyword.ts     |  32 +--
 .../src/rules/prefer-nullish-coalescing.ts    | 142 ++++++------
 .../src/rules/prefer-optional-chain.ts        | 154 ++++++-------
 .../src/rules/prefer-promise-reject-errors.ts |  58 ++---
 .../rules/prefer-readonly-parameter-types.ts  |  76 +++----
 .../src/rules/prefer-readonly.ts              |  52 ++---
 .../src/rules/prefer-reduce-type-parameter.ts |  34 +--
 .../src/rules/prefer-regexp-exec.ts           |  34 +--
 .../src/rules/prefer-return-this-type.ts      |  34 +--
 .../rules/prefer-string-starts-ends-with.ts   |  62 +++---
 .../src/rules/prefer-ts-expect-error.ts       |  32 +--
 .../src/rules/promise-function-async.ts       | 112 +++++-----
 .../src/rules/require-array-sort-compare.ts   |  62 +++---
 .../eslint-plugin/src/rules/require-await.ts  |  36 ++--
 .../src/rules/restrict-plus-operands.ts       | 150 ++++++-------
 .../rules/restrict-template-expressions.ts    | 100 ++++-----
 .../eslint-plugin/src/rules/return-await.ts   |  76 +++----
 .../src/rules/sort-type-constituents.ts       | 138 ++++++------
 .../src/rules/strict-boolean-expressions.ts   | 204 +++++++++---------
 .../src/rules/switch-exhaustiveness-check.ts  |  76 +++----
 .../src/rules/triple-slash-reference.ts       |  80 +++----
 packages/eslint-plugin/src/rules/typedef.ts   |  78 +++----
 .../eslint-plugin/src/rules/unbound-method.ts |  64 +++---
 .../src/rules/unified-signatures.ts           |  70 +++---
 .../use-unknown-in-catch-callback-variable.ts |  60 +++---
 127 files changed, 3993 insertions(+), 3993 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index e80c39da292c..07ba62bce173 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -609,7 +609,7 @@ export default tseslint.config(
       'perfectionist/sort-objects': [
         'error',
         {
-          customGroups: { top: ['name', 'meta', 'defaultOptions', 'create'] },
+          customGroups: { top: ['type', 'name', 'meta', 'defaultOptions'] },
           groups: ['top', 'unknown'],
         },
       ],
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index da57680e4492..4f09e8b687bd 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -22,6 +22,19 @@ type MemberDeclaration =
   | TSESTree.NamedExportDeclarations;
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require that function overload signatures be consecutive',
+      recommended: 'stylistic',
+    },
+    messages: {
+      adjacentSignature: 'All {{name}} signatures should be adjacent.',
+    },
+    schema: [],
+  },
+  name: 'adjacent-overload-signatures',
   create(context) {
     interface Method {
       callSignature: boolean;
@@ -57,8 +70,8 @@ export default createRule({
           }
           return {
             name,
-            callSignature: false,
             type: MemberNameType.Normal,
+            callSignature: false,
           };
         }
         case AST_NODE_TYPES.TSMethodSignature:
@@ -70,14 +83,14 @@ export default createRule({
         case AST_NODE_TYPES.TSCallSignatureDeclaration:
           return {
             name: 'call',
-            callSignature: true,
             type: MemberNameType.Normal,
+            callSignature: true,
           };
         case AST_NODE_TYPES.TSConstructSignatureDeclaration:
           return {
             name: 'new',
-            callSignature: false,
             type: MemberNameType.Normal,
+            callSignature: false,
           };
         case AST_NODE_TYPES.MethodDefinition:
           return {
@@ -155,17 +168,4 @@ export default createRule({
       TSTypeLiteral: checkBodyForOverloadMethods,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Require that function overload signatures be consecutive',
-      recommended: 'stylistic',
-    },
-    messages: {
-      adjacentSignature: 'All {{name}} signatures should be adjacent.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'adjacent-overload-signatures',
 });
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 92b53a9c7898..3b8ff8a728ac 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -88,6 +88,58 @@ type MessageIds =
   | 'errorStringGenericSimple';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      default: 'array',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require consistently using either `T[]` or `Array<T>` for arrays',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      errorStringArray:
+        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}[]' instead.",
+      errorStringArrayReadonly:
+        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}' instead.",
+      errorStringArraySimple:
+        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}[]' instead.",
+      errorStringArraySimpleReadonly:
+        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.",
+      errorStringGeneric:
+        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden. Use '{{className}}<{{type}}>' instead.",
+      errorStringGenericSimple:
+        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.",
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          arrayOption: {
+            type: 'string',
+            enum: ['array', 'generic', 'array-simple'],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          default: {
+            $ref: '#/items/0/$defs/arrayOption',
+            description: 'The array type expected for mutable cases.',
+          },
+          readonly: {
+            $ref: '#/items/0/$defs/arrayOption',
+            description:
+              'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'array-type',
   create(context, [options]) {
     const defaultOption = options.default;
     const readonlyOption = options.readonly ?? defaultOption;
@@ -125,9 +177,9 @@ export default createRule<Options, MessageIds>({
 
         context.report({
           data: {
+            type: getMessageType(node.elementType),
             className: isReadonly ? 'ReadonlyArray' : 'Array',
             readonlyPrefix: isReadonly ? 'readonly ' : '',
-            type: getMessageType(node.elementType),
           },
           fix(fixer) {
             const typeNode = node.elementType;
@@ -193,9 +245,9 @@ export default createRule<Options, MessageIds>({
           // Create an 'any' array
           context.report({
             data: {
+              type: 'any',
               className: isReadonlyArrayType ? 'ReadonlyArray' : 'Array',
               readonlyPrefix,
-              type: 'any',
             },
             fix(fixer) {
               return fixer.replaceText(node, `${readonlyPrefix}any[]`);
@@ -227,9 +279,9 @@ export default createRule<Options, MessageIds>({
         const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`;
         context.report({
           data: {
+            type: getMessageType(type),
             className: isReadonlyArrayType ? node.typeName.name : 'Array',
             readonlyPrefix,
-            type: getMessageType(type),
           },
           fix(fixer) {
             return [
@@ -243,56 +295,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      default: 'array',
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require consistently using either `T[]` or `Array<T>` for arrays',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      errorStringArray:
-        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}[]' instead.",
-      errorStringArrayReadonly:
-        "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}' instead.",
-      errorStringArraySimple:
-        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}[]' instead.",
-      errorStringArraySimpleReadonly:
-        "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.",
-      errorStringGeneric:
-        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden. Use '{{className}}<{{type}}>' instead.",
-      errorStringGenericSimple:
-        "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.",
-    },
-    schema: [
-      {
-        $defs: {
-          arrayOption: {
-            enum: ['array', 'generic', 'array-simple'],
-            type: 'string',
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          default: {
-            $ref: '#/items/0/$defs/arrayOption',
-            description: 'The array type expected for mutable cases.',
-          },
-          readonly: {
-            $ref: '#/items/0/$defs/arrayOption',
-            description:
-              'The array type expected for readonly cases. If omitted, the value for `default` will be used.',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'array-type',
 });
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index 507b8ededfe9..cb925f3d5f2f 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -13,6 +13,22 @@ import {
 } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow awaiting a value that is not a Thenable',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
+      removeAwait: 'Remove unnecessary `await`.',
+    },
+    schema: [],
+  },
+  name: 'await-thenable',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -48,20 +64,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow awaiting a value that is not a Thenable',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
-      removeAwait: 'Remove unnecessary `await`.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'await-thenable',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index f00c6846f85c..9e475f552b81 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -32,6 +32,77 @@ interface MatchedTSDirective {
 }
 
 export default createRule<[Options], MessageIds>({
+  defaultOptions: [
+    {
+      minimumDescriptionLength: defaultMinimumDescriptionLength,
+      'ts-check': false,
+      'ts-expect-error': 'allow-with-description',
+      'ts-ignore': true,
+      'ts-nocheck': true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow `@ts-<directive>` comments or require descriptions after directives',
+      recommended: {
+        recommended: true,
+        strict: [{ minimumDescriptionLength: 10 }],
+      },
+    },
+    hasSuggestions: true,
+    messages: {
+      replaceTsIgnoreWithTsExpectError:
+        'Replace "@ts-ignore" with "@ts-expect-error".',
+      tsDirectiveComment:
+        'Do not use "@ts-{{directive}}" because it alters compilation errors.',
+      tsDirectiveCommentDescriptionNotMatchPattern:
+        'The description for the "@ts-{{directive}}" directive must match the {{format}} format.',
+      tsDirectiveCommentRequiresDescription:
+        'Include a description after the "@ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.',
+      tsIgnoreInsteadOfExpectError:
+        'Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free.',
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          directiveConfigSchema: {
+            oneOf: [
+              {
+                type: 'boolean',
+                default: true,
+              },
+              {
+                type: 'string',
+                enum: ['allow-with-description'],
+              },
+              {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                  descriptionFormat: { type: 'string' },
+                },
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          minimumDescriptionLength: {
+            type: 'number',
+            default: defaultMinimumDescriptionLength,
+          },
+          'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+          'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
+        },
+      },
+    ],
+  },
+  name: 'ban-ts-comment',
   create(context, [options]) {
     // https://github.com/microsoft/TypeScript/blob/6f1ad5ad8bec5671f7e951a3524b62d82ec4be68/src/compiler/parser.ts#L10591
     const singleLinePragmaRegEx =
@@ -186,75 +257,4 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      minimumDescriptionLength: defaultMinimumDescriptionLength,
-      'ts-check': false,
-      'ts-expect-error': 'allow-with-description',
-      'ts-ignore': true,
-      'ts-nocheck': true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow `@ts-<directive>` comments or require descriptions after directives',
-      recommended: {
-        recommended: true,
-        strict: [{ minimumDescriptionLength: 10 }],
-      },
-    },
-    hasSuggestions: true,
-    messages: {
-      replaceTsIgnoreWithTsExpectError:
-        'Replace "@ts-ignore" with "@ts-expect-error".',
-      tsDirectiveComment:
-        'Do not use "@ts-{{directive}}" because it alters compilation errors.',
-      tsDirectiveCommentDescriptionNotMatchPattern:
-        'The description for the "@ts-{{directive}}" directive must match the {{format}} format.',
-      tsDirectiveCommentRequiresDescription:
-        'Include a description after the "@ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.',
-      tsIgnoreInsteadOfExpectError:
-        'Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free.',
-    },
-    schema: [
-      {
-        $defs: {
-          directiveConfigSchema: {
-            oneOf: [
-              {
-                default: true,
-                type: 'boolean',
-              },
-              {
-                enum: ['allow-with-description'],
-                type: 'string',
-              },
-              {
-                additionalProperties: false,
-                properties: {
-                  descriptionFormat: { type: 'string' },
-                },
-                type: 'object',
-              },
-            ],
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          minimumDescriptionLength: {
-            default: defaultMinimumDescriptionLength,
-            type: 'number',
-          },
-          'ts-check': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-expect-error': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-ignore': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-          'ts-nocheck': { $ref: '#/items/0/$defs/directiveConfigSchema' },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'ban-ts-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 95ed5d959788..8f3f05fb9446 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -16,6 +16,20 @@ const toText = (
     : ['/*', text.trim(), '*/'].join(' ');
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow `// tslint:<rule-flag>` comments',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      commentDetected: 'tslint comment detected: "{{ text }}"',
+    },
+    schema: [],
+  },
+  name: 'ban-tslint-comment',
   create: context => {
     return {
       Program(): void {
@@ -43,18 +57,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow `// tslint:<rule-flag>` comments',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      commentDetected: 'tslint comment detected: "{{ text }}"',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'ban-tslint-comment',
 });
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index 13109cb32e28..ab53cbaefbc3 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -54,6 +54,29 @@ const isSupportedLiteral = (
 };
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: ['fields'],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce that literals on classes are exposed in a consistent style',
+      recommended: 'stylistic',
+    },
+    hasSuggestions: true,
+    messages: {
+      preferFieldStyle: 'Literals should be exposed using readonly fields.',
+      preferFieldStyleSuggestion: 'Replace the literals with readonly fields.',
+      preferGetterStyle: 'Literals should be exposed using getters.',
+      preferGetterStyleSuggestion: 'Replace the literals with getters.',
+    },
+    schema: [
+      {
+        type: 'string',
+        enum: ['fields', 'getters'],
+      },
+    ],
+  },
+  name: 'class-literal-property-style',
   create(context, [style]) {
     const propertiesInfoStack: PropertiesInfo[] = [];
 
@@ -212,27 +235,4 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: ['fields'],
-  meta: {
-    docs: {
-      description:
-        'Enforce that literals on classes are exposed in a consistent style',
-      recommended: 'stylistic',
-    },
-    hasSuggestions: true,
-    messages: {
-      preferFieldStyle: 'Literals should be exposed using readonly fields.',
-      preferFieldStyleSuggestion: 'Replace the literals with readonly fields.',
-      preferGetterStyle: 'Literals should be exposed using getters.',
-      preferGetterStyleSuggestion: 'Replace the literals with getters.',
-    },
-    schema: [
-      {
-        enum: ['fields', 'getters'],
-        type: 'string',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'class-literal-property-style',
 });
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index f0142a26010c..f1f9c3e3f824 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -20,6 +20,68 @@ type Options = [
 type MessageIds = 'missingThis';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      enforceForClassFields: true,
+      exceptMethods: [],
+      ignoreClassesThatImplementAnInterface: false,
+      ignoreOverrideMethods: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce that class methods utilize `this`',
+      extendsBaseRule: true,
+      requiresTypeChecking: false,
+    },
+    messages: {
+      missingThis: "Expected 'this' to be used by class {{name}}.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          enforceForClassFields: {
+            type: 'boolean',
+            default: true,
+            description:
+              'Enforces that functions used as instance field initializers utilize `this`',
+          },
+          exceptMethods: {
+            type: 'array',
+            description:
+              'Allows specified method names to be ignored with this rule',
+            items: {
+              type: 'string',
+            },
+          },
+          ignoreClassesThatImplementAnInterface: {
+            description:
+              'Ignore classes that specifically implement some interface',
+            oneOf: [
+              {
+                type: 'boolean',
+                description: 'Ignore all classes that implement an interface',
+              },
+              {
+                type: 'string',
+                description:
+                  'Ignore only the public fields of classes that implement an interface',
+                enum: ['public-fields'],
+              },
+            ],
+          },
+          ignoreOverrideMethods: {
+            type: 'boolean',
+            description: 'Ignore members marked with the `override` modifier',
+          },
+        },
+      },
+    ],
+  },
+  name: 'class-methods-use-this',
   create(
     context,
     [
@@ -223,66 +285,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      enforceForClassFields: true,
-      exceptMethods: [],
-      ignoreClassesThatImplementAnInterface: false,
-      ignoreOverrideMethods: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Enforce that class methods utilize `this`',
-      extendsBaseRule: true,
-      requiresTypeChecking: false,
-    },
-    messages: {
-      missingThis: "Expected 'this' to be used by class {{name}}.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          enforceForClassFields: {
-            default: true,
-            description:
-              'Enforces that functions used as instance field initializers utilize `this`',
-            type: 'boolean',
-          },
-          exceptMethods: {
-            description:
-              'Allows specified method names to be ignored with this rule',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          ignoreClassesThatImplementAnInterface: {
-            description:
-              'Ignore classes that specifically implement some interface',
-            oneOf: [
-              {
-                description: 'Ignore all classes that implement an interface',
-                type: 'boolean',
-              },
-              {
-                description:
-                  'Ignore only the public fields of classes that implement an interface',
-                enum: ['public-fields'],
-                type: 'string',
-              },
-            ],
-          },
-          ignoreOverrideMethods: {
-            description: 'Ignore members marked with the `override` modifier',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'class-methods-use-this',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index 06bddbfc6b52..04838d228af6 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -8,6 +8,29 @@ type MessageIds = 'preferConstructor' | 'preferTypeAnnotation';
 type Options = ['constructor' | 'type-annotation'];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: ['constructor'],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      preferConstructor:
+        'The generic type arguments should be specified as part of the constructor type arguments.',
+      preferTypeAnnotation:
+        'The generic type arguments should be specified as part of the type annotation.',
+    },
+    schema: [
+      {
+        type: 'string',
+        enum: ['type-annotation', 'constructor'],
+      },
+    ],
+  },
+  name: 'consistent-generic-constructors',
   create(context, [mode]) {
     return {
       'VariableDeclarator,PropertyDefinition,:matches(FunctionDeclaration,FunctionExpression) > AssignmentPattern'(
@@ -123,27 +146,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: ['constructor'],
-  meta: {
-    docs: {
-      description:
-        'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      preferConstructor:
-        'The generic type arguments should be specified as part of the constructor type arguments.',
-      preferTypeAnnotation:
-        'The generic type arguments should be specified as part of the type annotation.',
-    },
-    schema: [
-      {
-        enum: ['type-annotation', 'constructor'],
-        type: 'string',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-generic-constructors',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index 88c55a7eec75..a2d32d7718bc 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -8,6 +8,26 @@ type MessageIds = 'preferIndexSignature' | 'preferRecord';
 type Options = ['index-signature' | 'record'];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: ['record'],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require or disallow the `Record` type',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      preferIndexSignature: 'An index signature is preferred over a record.',
+      preferRecord: 'A record is preferred over an index signature.',
+    },
+    schema: [
+      {
+        type: 'string',
+        enum: ['record', 'index-signature'],
+      },
+    ],
+  },
+  name: 'consistent-indexed-object-style',
   create(context, [mode]) {
     function checkMembers(
       members: TSESTree.TypeElement[],
@@ -128,26 +148,6 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: ['record'],
-  meta: {
-    docs: {
-      description: 'Require or disallow the `Record` type',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      preferIndexSignature: 'An index signature is preferred over a record.',
-      preferRecord: 'A record is preferred over an index signature.',
-    },
-    schema: [
-      {
-        enum: ['record', 'index-signature'],
-        type: 'string',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-indexed-object-style',
 });
 
 function findParentDeclaration(
diff --git a/packages/eslint-plugin/src/rules/consistent-return.ts b/packages/eslint-plugin/src/rules/consistent-return.ts
index 2b62e7372e5a..1ebf7a08c90e 100644
--- a/packages/eslint-plugin/src/rules/consistent-return.ts
+++ b/packages/eslint-plugin/src/rules/consistent-return.ts
@@ -22,6 +22,20 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require `return` statements to either always or never specify values',
+      extendsBaseRule: true,
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'consistent-return',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -113,18 +127,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
-  meta: {
-    docs: {
-      description:
-        'Require `return` statements to either always or never specify values',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'suggestion',
-  },
-  name: 'consistent-return',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index ed7e641381e5..dc234014750e 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -32,6 +32,64 @@ type OptUnion =
 export type Options = readonly [OptUnion];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      assertionStyle: 'as',
+      objectLiteralTypeAssertions: 'allow',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce consistent usage of type assertions',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
+      as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
+      never: 'Do not use any type assertions.',
+      replaceObjectTypeAssertionWithAnnotation:
+        'Use const x: {{cast}} = { ... } instead.',
+      replaceObjectTypeAssertionWithSatisfies:
+        'Use const x = { ... } satisfies {{cast}} instead.',
+      unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              assertionStyle: {
+                type: 'string',
+                enum: ['never'],
+              },
+            },
+            required: ['assertionStyle'],
+          },
+          {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              assertionStyle: {
+                type: 'string',
+                enum: ['as', 'angle-bracket'],
+              },
+              objectLiteralTypeAssertions: {
+                type: 'string',
+                enum: ['allow', 'allow-as-parameter', 'never'],
+              },
+            },
+            required: ['assertionStyle'],
+          },
+        ],
+      },
+    ],
+  },
+  name: 'consistent-type-assertions',
   create(context, [options]) {
     const parserServices = getParserServices(context, true);
 
@@ -220,62 +278,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      assertionStyle: 'as',
-      objectLiteralTypeAssertions: 'allow',
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Enforce consistent usage of type assertions',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.",
-      as: "Use 'as {{cast}}' instead of '<{{cast}}>'.",
-      never: 'Do not use any type assertions.',
-      replaceObjectTypeAssertionWithAnnotation:
-        'Use const x: {{cast}} = { ... } instead.',
-      replaceObjectTypeAssertionWithSatisfies:
-        'Use const x = { ... } satisfies {{cast}} instead.',
-      unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.',
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            additionalProperties: false,
-            properties: {
-              assertionStyle: {
-                enum: ['never'],
-                type: 'string',
-              },
-            },
-            required: ['assertionStyle'],
-            type: 'object',
-          },
-          {
-            additionalProperties: false,
-            properties: {
-              assertionStyle: {
-                enum: ['as', 'angle-bracket'],
-                type: 'string',
-              },
-              objectLiteralTypeAssertions: {
-                enum: ['allow', 'allow-as-parameter', 'never'],
-                type: 'string',
-              },
-            },
-            required: ['assertionStyle'],
-            type: 'object',
-          },
-        ],
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-type-assertions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 3cc36be45170..21f657850c01 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -5,6 +5,27 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: ['interface'],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce type definitions to consistently use either `interface` or `type`',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      interfaceOverType: 'Use an `interface` instead of a `type`.',
+      typeOverInterface: 'Use a `type` instead of an `interface`.',
+    },
+    schema: [
+      {
+        type: 'string',
+        enum: ['interface', 'type'],
+      },
+    ],
+  },
+  name: 'consistent-type-definitions',
   create(context, [option]) {
     /**
      * Iterates from the highest parent to the currently traversed node
@@ -115,25 +136,4 @@ export default createRule({
       }),
     };
   },
-  defaultOptions: ['interface'],
-  meta: {
-    docs: {
-      description:
-        'Enforce type definitions to consistently use either `interface` or `type`',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      interfaceOverType: 'Use an `interface` instead of a `type`.',
-      typeOverInterface: 'Use a `type` instead of an `interface`.',
-    },
-    schema: [
-      {
-        enum: ['interface', 'type'],
-        type: 'string',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-type-definitions',
 });
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index 1a6041bee233..d90a99fc1103 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -39,6 +39,40 @@ type MessageIds =
   | 'typeOverValue';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      fixMixedExportsWithInlineTypeSpecifier: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce consistent usage of type exports',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      multipleExportsAreTypes:
+        'Type exports {{exportNames}} are not values and should be exported using `export type`.',
+
+      singleExportIsType:
+        'Type export {{exportNames}} is not a value and should be exported using `export type`.',
+      typeOverValue:
+        'All exports in the declaration are only used as types. Use `export type`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          fixMixedExportsWithInlineTypeSpecifier: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'consistent-type-exports',
   create(context, [{ fixMixedExportsWithInlineTypeSpecifier }]) {
     const sourceExportsMap: Record<string, SourceExports> = {};
     const services = getParserServices(context);
@@ -204,40 +238,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      fixMixedExportsWithInlineTypeSpecifier: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Enforce consistent usage of type exports',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      multipleExportsAreTypes:
-        'Type exports {{exportNames}} are not values and should be exported using `export type`.',
-
-      singleExportIsType:
-        'Type export {{exportNames}} is not a value and should be exported using `export type`.',
-      typeOverValue:
-        'All exports in the declaration are only used as types. Use `export type`.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          fixMixedExportsWithInlineTypeSpecifier: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-type-exports',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index ad001e7aba02..20a97ce870c2 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -51,6 +51,49 @@ type MessageIds =
   | 'someImportsAreOnlyTypes'
   | 'typeOverValue';
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      disallowTypeAnnotations: true,
+      fixStyle: 'separate-type-imports',
+      prefer: 'type-imports',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce consistent usage of type imports',
+    },
+    fixable: 'code',
+    messages: {
+      avoidImportType: 'Use an `import` instead of an `import type`.',
+      noImportTypeAnnotations: '`import()` type annotations are forbidden.',
+
+      someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as type.',
+      typeOverValue:
+        'All imports in the declaration are only used as types. Use `import type`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          disallowTypeAnnotations: {
+            type: 'boolean',
+          },
+          fixStyle: {
+            type: 'string',
+            enum: ['separate-type-imports', 'inline-type-imports'],
+          },
+          prefer: {
+            type: 'string',
+            enum: ['type-imports', 'no-type-imports'],
+          },
+        },
+      },
+    ],
+  },
+
+  name: 'consistent-type-imports',
   create(context, [option]) {
     const prefer = option.prefer ?? 'type-imports';
     const disallowTypeAnnotations = option.disallowTypeAnnotations !== false;
@@ -900,47 +943,4 @@ export default createRule<Options, MessageIds>({
       yield fixer.removeRange([typeToken.range[0], afterToken.range[0]]);
     }
   },
-  defaultOptions: [
-    {
-      disallowTypeAnnotations: true,
-      fixStyle: 'separate-type-imports',
-      prefer: 'type-imports',
-    },
-  ],
-
-  meta: {
-    docs: {
-      description: 'Enforce consistent usage of type imports',
-    },
-    fixable: 'code',
-    messages: {
-      avoidImportType: 'Use an `import` instead of an `import type`.',
-      noImportTypeAnnotations: '`import()` type annotations are forbidden.',
-
-      someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as type.',
-      typeOverValue:
-        'All imports in the declaration are only used as types. Use `import type`.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          disallowTypeAnnotations: {
-            type: 'boolean',
-          },
-          fixStyle: {
-            enum: ['separate-type-imports', 'inline-type-imports'],
-            type: 'string',
-          },
-          prefer: {
-            enum: ['type-imports', 'no-type-imports'],
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'consistent-type-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index acccc135874d..0e0b7aa8f640 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -5,6 +5,19 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce default parameters to be last',
+      extendsBaseRule: true,
+    },
+    messages: {
+      shouldBeLast: 'Default parameters should be last.',
+    },
+    schema: [],
+  },
+  name: 'default-param-last',
   create(context) {
     /**
      * checks if node is optional parameter
@@ -70,17 +83,4 @@ export default createRule({
       FunctionExpression: checkDefaultParamLast,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Enforce default parameters to be last',
-      extendsBaseRule: true,
-    },
-    messages: {
-      shouldBeLast: 'Default parameters should be last.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'default-param-last',
 });
diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
index d9efb21a0336..c7dd52c72f8d 100644
--- a/packages/eslint-plugin/src/rules/dot-notation.ts
+++ b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -18,6 +18,56 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowIndexSignaturePropertyAccess: false,
+      allowKeywords: true,
+      allowPattern: '',
+      allowPrivateClassPropertyAccess: false,
+      allowProtectedClassPropertyAccess: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce dot notation whenever possible',
+      extendsBaseRule: true,
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: baseRule.meta.fixable,
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowIndexSignaturePropertyAccess: {
+            type: 'boolean',
+            default: false,
+          },
+          allowKeywords: {
+            type: 'boolean',
+            default: true,
+          },
+          allowPattern: {
+            type: 'string',
+            default: '',
+          },
+          allowPrivateClassPropertyAccess: {
+            type: 'boolean',
+            default: false,
+          },
+          allowProtectedClassPropertyAccess: {
+            type: 'boolean',
+            default: false,
+          },
+        },
+      },
+    ],
+  },
+  name: 'dot-notation',
   create(context, [options]) {
     const rules = baseRule.create(context);
     const services = getParserServices(context);
@@ -81,54 +131,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowIndexSignaturePropertyAccess: false,
-      allowKeywords: true,
-      allowPattern: '',
-      allowPrivateClassPropertyAccess: false,
-      allowProtectedClassPropertyAccess: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Enforce dot notation whenever possible',
-      extendsBaseRule: true,
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: baseRule.meta.fixable,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowIndexSignaturePropertyAccess: {
-            default: false,
-            type: 'boolean',
-          },
-          allowKeywords: {
-            default: true,
-            type: 'boolean',
-          },
-          allowPattern: {
-            default: '',
-            type: 'string',
-          },
-          allowPrivateClassPropertyAccess: {
-            default: false,
-            type: 'boolean',
-          },
-          allowProtectedClassPropertyAccess: {
-            default: false,
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'dot-notation',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index b8264cdec926..1205fd4cc727 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -31,6 +31,80 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowExpressions: false,
+      allowFunctionsWithoutTypeParameters: false,
+      allowHigherOrderFunctions: true,
+      allowIIFEs: false,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require explicit return types on functions and class methods',
+    },
+    messages: {
+      missingReturnType: 'Missing return type on function.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowConciseArrowFunctionExpressionsStartingWithVoid: {
+            type: 'boolean',
+            description:
+              'Whether to allow arrow functions that start with the `void` keyword.',
+          },
+          allowDirectConstAssertionInArrowFunctions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore arrow functions immediately returning a `as const` value.',
+          },
+          allowedNames: {
+            type: 'array',
+            description:
+              'An array of function/method names that will not have their arguments or return values checked.',
+            items: {
+              type: 'string',
+            },
+          },
+          allowExpressions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore function expressions (functions which are not part of a declaration).',
+          },
+          allowFunctionsWithoutTypeParameters: {
+            type: 'boolean',
+            description:
+              "Whether to ignore functions that don't have generic type parameters.",
+          },
+          allowHigherOrderFunctions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore functions immediately returning another function expression.',
+          },
+          allowIIFEs: {
+            type: 'boolean',
+            description:
+              'Whether to ignore immediately invoked function expressions (IIFEs).',
+          },
+          allowTypedFunctionExpressions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore type annotations on the variable of function expressions.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'explicit-function-return-type',
   create(context, [options]) {
     const functionInfoStack: FunctionInfo<FunctionNode>[] = [];
 
@@ -181,78 +255,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowedNames: [],
-      allowExpressions: false,
-      allowFunctionsWithoutTypeParameters: false,
-      allowHigherOrderFunctions: true,
-      allowIIFEs: false,
-      allowTypedFunctionExpressions: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require explicit return types on functions and class methods',
-    },
-    messages: {
-      missingReturnType: 'Missing return type on function.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowConciseArrowFunctionExpressionsStartingWithVoid: {
-            description:
-              'Whether to allow arrow functions that start with the `void` keyword.',
-            type: 'boolean',
-          },
-          allowDirectConstAssertionInArrowFunctions: {
-            description:
-              'Whether to ignore arrow functions immediately returning a `as const` value.',
-            type: 'boolean',
-          },
-          allowedNames: {
-            description:
-              'An array of function/method names that will not have their arguments or return values checked.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          allowExpressions: {
-            description:
-              'Whether to ignore function expressions (functions which are not part of a declaration).',
-            type: 'boolean',
-          },
-          allowFunctionsWithoutTypeParameters: {
-            description:
-              "Whether to ignore functions that don't have generic type parameters.",
-            type: 'boolean',
-          },
-          allowHigherOrderFunctions: {
-            description:
-              'Whether to ignore functions immediately returning another function expression.',
-            type: 'boolean',
-          },
-          allowIIFEs: {
-            description:
-              'Whether to ignore immediately invoked function expressions (IIFEs).',
-            type: 'boolean',
-          },
-          allowTypedFunctionExpressions: {
-            description:
-              'Whether to ignore type annotations on the variable of function expressions.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'explicit-function-return-type',
 });
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 1f180ff4c5d8..5ecb2ab4927e 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -38,6 +38,75 @@ type MessageIds =
   | 'unwantedPublicAccessibility';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ accessibility: 'explicit' }],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require explicit accessibility modifiers on class properties and methods',
+      // too opinionated to be recommended
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      addExplicitAccessibility: "Add '{{ type }}' accessibility modifier",
+      missingAccessibility:
+        'Missing accessibility modifier on {{type}} {{name}}.',
+      unwantedPublicAccessibility:
+        'Public accessibility modifier on {{type}} {{name}}.',
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          accessibilityLevel: {
+            oneOf: [
+              {
+                type: 'string',
+                description: 'Always require an accessor.',
+                enum: ['explicit'],
+              },
+              {
+                type: 'string',
+                description: 'Require an accessor except when public.',
+                enum: ['no-public'],
+              },
+              {
+                type: 'string',
+                description: 'Never check whether there is an accessor.',
+                enum: ['off'],
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
+          ignoredMethodNames: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+          overrides: {
+            type: 'object',
+            additionalProperties: false,
+
+            properties: {
+              accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
+              parameterProperties: {
+                $ref: '#/items/0/$defs/accessibilityLevel',
+              },
+              properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
+            },
+          },
+        },
+      },
+    ],
+  },
+  name: 'explicit-member-accessibility',
   create(context, [option]) {
     const baseCheck: AccessibilityLevel = option.accessibility ?? 'explicit';
     const overrides = option.overrides ?? {};
@@ -318,75 +387,6 @@ export default createRule<Options, MessageIds>({
       TSParameterProperty: checkParameterPropertyAccessibilityModifier,
     };
   },
-  defaultOptions: [{ accessibility: 'explicit' }],
-  meta: {
-    docs: {
-      description:
-        'Require explicit accessibility modifiers on class properties and methods',
-      // too opinionated to be recommended
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      addExplicitAccessibility: "Add '{{ type }}' accessibility modifier",
-      missingAccessibility:
-        'Missing accessibility modifier on {{type}} {{name}}.',
-      unwantedPublicAccessibility:
-        'Public accessibility modifier on {{type}} {{name}}.',
-    },
-    schema: [
-      {
-        $defs: {
-          accessibilityLevel: {
-            oneOf: [
-              {
-                description: 'Always require an accessor.',
-                enum: ['explicit'],
-                type: 'string',
-              },
-              {
-                description: 'Require an accessor except when public.',
-                enum: ['no-public'],
-                type: 'string',
-              },
-              {
-                description: 'Never check whether there is an accessor.',
-                enum: ['off'],
-                type: 'string',
-              },
-            ],
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          accessibility: { $ref: '#/items/0/$defs/accessibilityLevel' },
-          ignoredMethodNames: {
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          overrides: {
-            additionalProperties: false,
-            properties: {
-              accessors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              constructors: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              methods: { $ref: '#/items/0/$defs/accessibilityLevel' },
-              parameterProperties: {
-                $ref: '#/items/0/$defs/accessibilityLevel',
-              },
-              properties: { $ref: '#/items/0/$defs/accessibilityLevel' },
-            },
-
-            type: 'object',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'explicit-member-accessibility',
 });
 
 function rangeToLoc(
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index 8673c647b6de..c956abe8efd3 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -35,6 +35,71 @@ type MessageIds =
   | 'missingReturnType';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowArgumentsExplicitlyTypedAsAny: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowHigherOrderFunctions: true,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Require explicit return and argument types on exported functions' and classes' public class methods",
+    },
+    messages: {
+      anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
+      anyTypedArgUnnamed:
+        '{{type}} argument should be typed with a non-any type.',
+      missingArgType: "Argument '{{name}}' should be typed.",
+      missingArgTypeUnnamed: '{{type}} argument should be typed.',
+      missingReturnType: 'Missing return type on function.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowArgumentsExplicitlyTypedAsAny: {
+            type: 'boolean',
+            description:
+              'Whether to ignore arguments that are explicitly typed as `any`.',
+          },
+          allowDirectConstAssertionInArrowFunctions: {
+            type: 'boolean',
+            description: [
+              'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
+              'You must still type the parameters of the function.',
+            ].join('\n'),
+          },
+          allowedNames: {
+            type: 'array',
+            description:
+              'An array of function/method names that will not have their arguments or return values checked.',
+            items: {
+              type: 'string',
+            },
+          },
+          allowHigherOrderFunctions: {
+            type: 'boolean',
+            description: [
+              'Whether to ignore return type annotations on functions immediately returning another function expression.',
+              'You must still type the parameters of the function.',
+            ].join('\n'),
+          },
+          allowTypedFunctionExpressions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore type annotations on the variable of a function expression.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'explicit-module-boundary-types',
   create(context, [options]) {
     // tracks all of the functions we've already checked
     const checkedFunctions = new Set<FunctionNode>();
@@ -450,69 +515,4 @@ export default createRule<Options, MessageIds>({
       checkParameters(node);
     }
   },
-  defaultOptions: [
-    {
-      allowArgumentsExplicitlyTypedAsAny: false,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowedNames: [],
-      allowHigherOrderFunctions: true,
-      allowTypedFunctionExpressions: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        "Require explicit return and argument types on exported functions' and classes' public class methods",
-    },
-    messages: {
-      anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.",
-      anyTypedArgUnnamed:
-        '{{type}} argument should be typed with a non-any type.',
-      missingArgType: "Argument '{{name}}' should be typed.",
-      missingArgTypeUnnamed: '{{type}} argument should be typed.',
-      missingReturnType: 'Missing return type on function.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowArgumentsExplicitlyTypedAsAny: {
-            description:
-              'Whether to ignore arguments that are explicitly typed as `any`.',
-            type: 'boolean',
-          },
-          allowDirectConstAssertionInArrowFunctions: {
-            description: [
-              'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.',
-              'You must still type the parameters of the function.',
-            ].join('\n'),
-            type: 'boolean',
-          },
-          allowedNames: {
-            description:
-              'An array of function/method names that will not have their arguments or return values checked.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          allowHigherOrderFunctions: {
-            description: [
-              'Whether to ignore return type annotations on functions immediately returning another function expression.',
-              'You must still type the parameters of the function.',
-            ].join('\n'),
-            type: 'boolean',
-          },
-          allowTypedFunctionExpressions: {
-            description:
-              'Whether to ignore type annotations on the variable of a function expression.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'explicit-module-boundary-types',
 });
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 106587e8c47e..33c43dc48a18 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -16,6 +16,19 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: ['always'],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require or disallow initialization in variable declarations',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'init-declarations',
   create(context, [mode]) {
     // Make a custom context to adjust the loc of reports where the base
     // rule's behavior is a bit too aggressive with TS-specific syntax (namely,
@@ -97,19 +110,6 @@ export default createRule<Options, MessageIds>({
       return false;
     }
   },
-  defaultOptions: ['always'],
-  meta: {
-    docs: {
-      description:
-        'Require or disallow initialization in variable declarations',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'suggestion',
-  },
-  name: 'init-declarations',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index 9ac486e21c37..0e12ca2c7d7d 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -23,6 +23,36 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ countVoidThis: false, max: 3 }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce a maximum number of parameters in function definitions',
+      extendsBaseRule: true,
+    },
+    messages: baseRule.meta.messages,
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          countVoidThis: {
+            type: 'boolean',
+          },
+          max: {
+            type: 'integer',
+            minimum: 0,
+          },
+          maximum: {
+            type: 'integer',
+            minimum: 0,
+          },
+        },
+      },
+    ],
+  },
+  name: 'max-params',
   create(context, [{ countVoidThis }]) {
     const baseRules = baseRule.create(context);
 
@@ -61,34 +91,4 @@ export default createRule<Options, MessageIds>({
       FunctionExpression: wrapListener(baseRules.FunctionExpression),
     };
   },
-  defaultOptions: [{ countVoidThis: false, max: 3 }],
-  meta: {
-    docs: {
-      description:
-        'Enforce a maximum number of parameters in function definitions',
-      extendsBaseRule: true,
-    },
-    messages: baseRule.meta.messages,
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          countVoidThis: {
-            type: 'boolean',
-          },
-          max: {
-            minimum: 0,
-            type: 'integer',
-          },
-          maximum: {
-            minimum: 0,
-            type: 'integer',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'max-params',
 });
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index 20039baa01b2..b9439eb5ae73 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -92,28 +92,29 @@ export type Options = [
 ];
 
 const neverConfig: JSONSchema.JSONSchema4 = {
-  enum: ['never'],
   type: 'string',
+  enum: ['never'],
 };
 
 const arrayConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
+  type: 'array',
   items: {
     oneOf: [
       {
         $ref: memberTypes,
       },
       {
+        type: 'array',
         items: {
           $ref: memberTypes,
         },
-        type: 'array',
       },
     ],
   },
-  type: 'array',
 });
 
 const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
+  type: 'object',
   additionalProperties: false,
   properties: {
     memberTypes: {
@@ -126,7 +127,6 @@ const objectConfig = (memberTypes: string): JSONSchema.JSONSchema4 => ({
       $ref: '#/items/0/$defs/orderOptions',
     },
   },
-  type: 'object',
 });
 
 export const defaultOrder: MemberType[] = [
@@ -718,6 +718,97 @@ function getLowestRank(
 }
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      default: {
+        memberTypes: defaultOrder,
+      },
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require a consistent member declaration order',
+    },
+    messages: {
+      incorrectGroupOrder:
+        'Member {{name}} should be declared before all {{rank}} definitions.',
+      incorrectOrder:
+        'Member {{member}} should be declared before member {{beforeMember}}.',
+      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          allItems: {
+            type: 'string',
+            enum: allMemberTypes as string[],
+          },
+          optionalityOrderOptions: {
+            type: 'string',
+            enum: ['optional-first', 'required-first'],
+          },
+          orderOptions: {
+            type: 'string',
+            enum: [
+              'alphabetically',
+              'alphabetically-case-insensitive',
+              'as-written',
+              'natural',
+              'natural-case-insensitive',
+            ],
+          },
+          typeItems: {
+            type: 'string',
+            enum: [
+              'readonly-signature',
+              'signature',
+              'readonly-field',
+              'field',
+              'method',
+              'constructor',
+            ],
+          },
+
+          // These properties must follow the preceding ones for ajv logic.
+          baseConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/allItems'),
+              objectConfig('#/items/0/$defs/allItems'),
+            ],
+          },
+          typesConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/typeItems'),
+              objectConfig('#/items/0/$defs/typeItems'),
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          classes: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          classExpressions: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          default: {
+            $ref: '#/items/0/$defs/baseConfig',
+          },
+          interfaces: {
+            $ref: '#/items/0/$defs/typesConfig',
+          },
+          typeLiterals: {
+            $ref: '#/items/0/$defs/typesConfig',
+          },
+        },
+      },
+    ],
+  },
+  name: 'member-ordering',
   create(context, [options]) {
     /**
      * Checks if the member groups are correctly sorted.
@@ -1022,95 +1113,4 @@ export default createRule<Options, MessageIds>({
     };
     /* eslint-enable @typescript-eslint/no-non-null-assertion */
   },
-  defaultOptions: [
-    {
-      default: {
-        memberTypes: defaultOrder,
-      },
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Require a consistent member declaration order',
-    },
-    messages: {
-      incorrectGroupOrder:
-        'Member {{name}} should be declared before all {{rank}} definitions.',
-      incorrectOrder:
-        'Member {{member}} should be declared before member {{beforeMember}}.',
-      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
-    },
-    schema: [
-      {
-        $defs: {
-          allItems: {
-            enum: allMemberTypes as string[],
-            type: 'string',
-          },
-          optionalityOrderOptions: {
-            enum: ['optional-first', 'required-first'],
-            type: 'string',
-          },
-          orderOptions: {
-            enum: [
-              'alphabetically',
-              'alphabetically-case-insensitive',
-              'as-written',
-              'natural',
-              'natural-case-insensitive',
-            ],
-            type: 'string',
-          },
-          typeItems: {
-            enum: [
-              'readonly-signature',
-              'signature',
-              'readonly-field',
-              'field',
-              'method',
-              'constructor',
-            ],
-            type: 'string',
-          },
-
-          // These properties must follow the preceding ones for ajv logic.
-          baseConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/allItems'),
-              objectConfig('#/items/0/$defs/allItems'),
-            ],
-          },
-          typesConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/typeItems'),
-              objectConfig('#/items/0/$defs/typeItems'),
-            ],
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          classes: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          classExpressions: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          default: {
-            $ref: '#/items/0/$defs/baseConfig',
-          },
-          interfaces: {
-            $ref: '#/items/0/$defs/typesConfig',
-          },
-          typeLiterals: {
-            $ref: '#/items/0/$defs/typesConfig',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'member-ordering',
 });
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index dd59ae538c13..c51bdd6685b7 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -15,6 +15,27 @@ export type Options = [('method' | 'property')?];
 export type MessageIds = 'errorMethod' | 'errorProperty';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: ['property'],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce using a particular method signature syntax',
+    },
+    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: [
+      {
+        type: 'string',
+        enum: ['property', 'method'],
+      },
+    ],
+  },
+  name: 'method-signature-style',
   create(context, [mode]) {
     function getMethodKey(
       node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature,
@@ -219,25 +240,4 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: ['property'],
-  meta: {
-    docs: {
-      description: 'Enforce using a particular method signature syntax',
-    },
-    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'],
-        type: 'string',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'method-signature-style',
 });
diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
index 6a4e4bc53c74..174263b4e527 100644
--- a/packages/eslint-plugin/src/rules/naming-convention.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention.ts
@@ -63,6 +63,32 @@ const defaultCamelCaseAllTheThingsConfig: Options = [
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: defaultCamelCaseAllTheThingsConfig,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce naming conventions for everything across a codebase',
+      // technically only requires type checking if the user uses "type" modifiers
+      requiresTypeChecking: true,
+    },
+    messages: {
+      doesNotMatchFormat:
+        '{{type}} name `{{name}}` must match one of the following formats: {{formats}}',
+      doesNotMatchFormatTrimmed:
+        '{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}',
+      missingAffix:
+        '{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}',
+      missingUnderscore:
+        '{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).',
+      satisfyCustom:
+        '{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}',
+      unexpectedUnderscore:
+        '{{type}} name `{{name}}` must not have a {{position}} underscore.',
+    },
+    schema: SCHEMA,
+  },
+  name: 'naming-convention',
   create(contextWithoutDefaults) {
     const context =
       contextWithoutDefaults.options.length > 0
@@ -695,32 +721,6 @@ export default createRule<Options, MessageIds>({
       }),
     );
   },
-  defaultOptions: defaultCamelCaseAllTheThingsConfig,
-  meta: {
-    docs: {
-      description:
-        'Enforce naming conventions for everything across a codebase',
-      // technically only requires type checking if the user uses "type" modifiers
-      requiresTypeChecking: true,
-    },
-    messages: {
-      doesNotMatchFormat:
-        '{{type}} name `{{name}}` must match one of the following formats: {{formats}}',
-      doesNotMatchFormatTrimmed:
-        '{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}',
-      missingAffix:
-        '{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}',
-      missingUnderscore:
-        '{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).',
-      satisfyCustom:
-        '{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}',
-      unexpectedUnderscore:
-        '{{type}} name `{{name}}` must not have a {{position}} underscore.',
-    },
-    schema: SCHEMA,
-    type: 'suggestion',
-  },
-  name: 'naming-convention',
 });
 
 function getIdentifiersFromPattern(
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index 361928021fee..96b7a446bb3a 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -5,6 +5,21 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isOptionalCallExpression } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow generic `Array` constructors',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      useLiteral: 'The array literal notation [] is preferable.',
+    },
+    schema: [],
+  },
+  name: 'no-array-constructor',
   create(context) {
     /**
      * Disallow construction of dense arrays using the Array constructor
@@ -44,19 +59,4 @@ export default createRule({
       NewExpression: check,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow generic `Array` constructors',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      useLiteral: 'The array literal notation [] is preferable.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-array-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index 161081c56933..0b955d946fae 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -12,6 +12,23 @@ import {
 type MessageId = 'noArrayDelete' | 'useSplice';
 
 export default createRule<[], MessageId>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow using the `delete` operator on array values',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      noArrayDelete:
+        'Using the `delete` operator with an array expression is unsafe.',
+      useSplice: 'Use `array.splice()` instead.',
+    },
+    schema: [],
+  },
+  name: 'no-array-delete',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -91,21 +108,4 @@ export default createRule<[], MessageId>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow using the `delete` operator on array values',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      noArrayDelete:
-        'Using the `delete` operator with an array expression is unsafe.',
-      useSplice: 'Use `array.splice()` instead.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-array-delete',
 });
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index 58fc0089d400..3e3bb03a9322 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -19,6 +19,39 @@ type Options = [
 type MessageIds = 'baseToString';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require `.toString()` to only be called on objects which provide useful information when stringified',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      baseToString:
+        "'{{name}}' {{certainty}} use Object's default stringification format ('[object Object]') when stringified.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoredTypeNames: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-base-to-string',
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -148,37 +181,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require `.toString()` to only be called on objects which provide useful information when stringified',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      baseToString:
-        "'{{name}}' {{certainty}} use Object's default stringification format ('[object Object]') when stringified.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoredTypeNames: {
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-base-to-string',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index 7e16276795c7..9901c199fadf 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -5,6 +5,29 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow non-null assertion in locations that may be confusing',
+      recommended: 'stylistic',
+    },
+    hasSuggestions: true,
+    messages: {
+      confusingAssign:
+        'Confusing combinations of non-null assertion and equal test like "a! = b", which looks very similar to not equal "a != b".',
+      confusingEqual:
+        'Confusing combinations of non-null assertion and equal test like "a! == b", which looks very similar to not equal "a !== b".',
+      notNeedInAssign:
+        'Unnecessary non-null assertion (!) in assignment left hand.',
+      notNeedInEqualTest: 'Unnecessary non-null assertion (!) in equal test.',
+      wrapUpLeft:
+        'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
+    },
+    schema: [],
+  },
+  name: 'no-confusing-non-null-assertion',
   create(context) {
     return {
       'BinaryExpression, AssignmentExpression'(
@@ -64,27 +87,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow non-null assertion in locations that may be confusing',
-      recommended: 'stylistic',
-    },
-    hasSuggestions: true,
-    messages: {
-      confusingAssign:
-        'Confusing combinations of non-null assertion and equal test like "a! = b", which looks very similar to not equal "a != b".',
-      confusingEqual:
-        'Confusing combinations of non-null assertion and equal test like "a! == b", which looks very similar to not equal "a !== b".',
-      notNeedInAssign:
-        'Unnecessary non-null assertion (!) in assignment left hand.',
-      notNeedInEqualTest: 'Unnecessary non-null assertion (!) in equal test.',
-      wrapUpLeft:
-        'Wrap up left hand to avoid putting non-null assertion "!" and "=" together.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-confusing-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 4eb54e068417..9ee8c384e9f7 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -35,6 +35,54 @@ export type MessageId =
   | 'voidExprWrapVoid';
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require expressions of type void to appear in statement position',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      invalidVoidExpr:
+        'Placing a void expression inside another expression is forbidden. ' +
+        'Move it to its own statement instead.',
+      invalidVoidExprArrow:
+        'Returning a void expression from an arrow function shorthand is forbidden. ' +
+        'Please add braces to the arrow function.',
+      invalidVoidExprArrowWrapVoid:
+        'Void expressions returned from an arrow function shorthand ' +
+        'must be marked explicitly with the `void` operator.',
+      invalidVoidExprReturn:
+        'Returning a void expression from a function is forbidden. ' +
+        'Please move it before the `return` statement.',
+      invalidVoidExprReturnLast:
+        'Returning a void expression from a function is forbidden. ' +
+        'Please remove the `return` statement.',
+      invalidVoidExprReturnWrapVoid:
+        'Void expressions returned from a function ' +
+        'must be marked explicitly with the `void` operator.',
+      invalidVoidExprWrapVoid:
+        'Void expressions used inside another expression ' +
+        'must be moved to its own statement ' +
+        'or marked explicitly with the `void` operator.',
+      voidExprWrapVoid: 'Mark with an explicit `void` operator.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreArrowShorthand: { type: 'boolean' },
+          ignoreVoidOperator: { type: 'boolean' },
+        },
+      },
+    ],
+  },
+  name: 'no-confusing-void-expression',
   create(context, [options]) {
     return {
       'AwaitExpression, CallExpression, TaggedTemplateExpression'(
@@ -330,52 +378,4 @@ export default createRule<Options, MessageId>({
       return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
     }
   },
-  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
-  meta: {
-    docs: {
-      description:
-        'Require expressions of type void to appear in statement position',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      invalidVoidExpr:
-        'Placing a void expression inside another expression is forbidden. ' +
-        'Move it to its own statement instead.',
-      invalidVoidExprArrow:
-        'Returning a void expression from an arrow function shorthand is forbidden. ' +
-        'Please add braces to the arrow function.',
-      invalidVoidExprArrowWrapVoid:
-        'Void expressions returned from an arrow function shorthand ' +
-        'must be marked explicitly with the `void` operator.',
-      invalidVoidExprReturn:
-        'Returning a void expression from a function is forbidden. ' +
-        'Please move it before the `return` statement.',
-      invalidVoidExprReturnLast:
-        'Returning a void expression from a function is forbidden. ' +
-        'Please remove the `return` statement.',
-      invalidVoidExprReturnWrapVoid:
-        'Void expressions returned from a function ' +
-        'must be marked explicitly with the `void` operator.',
-      invalidVoidExprWrapVoid:
-        'Void expressions used inside another expression ' +
-        'must be moved to its own statement ' +
-        'or marked explicitly with the `void` operator.',
-      voidExprWrapVoid: 'Mark with an explicit `void` operator.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreArrowShorthand: { type: 'boolean' },
-          ignoreVoidOperator: { type: 'boolean' },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-confusing-void-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
index a0d9c8e29eab..3d6746cf336e 100644
--- a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
+++ b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
@@ -16,6 +16,18 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow duplicate class members',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'no-dupe-class-members',
   create(context) {
     const rules = baseRule.create(context);
 
@@ -45,16 +57,4 @@ export default createRule<Options, MessageIds>({
       ),
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow duplicate class members',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'problem',
-  },
-  name: 'no-dupe-class-members',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index e89f8d66256f..65ae2c7680d5 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -5,6 +5,20 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow duplicate enum member values',
+      recommended: 'recommended',
+    },
+    hasSuggestions: false,
+    messages: {
+      duplicateValue: 'Duplicate enum member value {{value}}.',
+    },
+    schema: [],
+  },
+  name: 'no-duplicate-enum-values',
   create(context) {
     function isStringLiteral(
       node: TSESTree.Expression,
@@ -58,18 +72,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow duplicate enum member values',
-      recommended: 'recommended',
-    },
-    hasSuggestions: false,
-    messages: {
-      duplicateValue: 'Duplicate enum member value {{value}}.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-duplicate-enum-values',
 });
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index 65eb54471664..6ef7ecce3d34 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -68,6 +68,40 @@ const isSameAstNode = (actualNode: unknown, expectedNode: unknown): boolean => {
 };
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoreIntersections: false,
+      ignoreUnions: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow duplicate constituents of union or intersection types',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreIntersections: {
+            type: 'boolean',
+          },
+          ignoreUnions: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-duplicate-type-constituents',
   create(context, [{ ignoreIntersections, ignoreUnions }]) {
     const parserServices = getParserServices(context);
 
@@ -144,13 +178,13 @@ export default createRule<Options, MessageIds>({
       };
       context.report({
         data: {
-          previous: context.sourceCode.getText(
-            duplicateConstituent.duplicatePrevious,
-          ),
           type:
             parentNode.type === AST_NODE_TYPES.TSIntersectionType
               ? 'Intersection'
               : 'Union',
+          previous: context.sourceCode.getText(
+            duplicateConstituent.duplicatePrevious,
+          ),
         },
         fix: fixer => {
           return [
@@ -174,38 +208,4 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: [
-    {
-      ignoreIntersections: false,
-      ignoreUnions: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow duplicate constituents of union or intersection types',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreIntersections: {
-            type: 'boolean',
-          },
-          ignoreUnions: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-duplicate-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index d0da569f7f7e..c614082d450c 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -5,6 +5,21 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow using the `delete` operator on computed key expressions',
+      recommended: 'strict',
+    },
+    fixable: 'code',
+    messages: {
+      dynamicDelete: 'Do not delete dynamically computed property keys.',
+    },
+    schema: [],
+  },
+  name: 'no-dynamic-delete',
   create(context) {
     function createFixer(
       member: TSESTree.MemberExpression,
@@ -61,21 +76,6 @@ export default createRule({
       ];
     }
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow using the `delete` operator on computed key expressions',
-      recommended: 'strict',
-    },
-    fixable: 'code',
-    messages: {
-      dynamicDelete: 'Do not delete dynamically computed property keys.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-dynamic-delete',
 });
 
 function isAcceptableIndexExpression(property: TSESTree.Expression): boolean {
diff --git a/packages/eslint-plugin/src/rules/no-empty-function.ts b/packages/eslint-plugin/src/rules/no-empty-function.ts
index cb3ecae32597..5c461960b040 100644
--- a/packages/eslint-plugin/src/rules/no-empty-function.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-function.ts
@@ -25,6 +25,7 @@ const schema = deepMerge(
     properties: {
       allow: {
         items: {
+          type: 'string',
           enum: [
             'functions',
             'arrowFunctions',
@@ -41,7 +42,6 @@ const schema = deepMerge(
             'decoratedFunctions',
             'overrideMethods',
           ],
-          type: 'string',
         },
       },
     },
@@ -49,6 +49,23 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allow: [],
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow empty functions',
+      extendsBaseRule: true,
+      recommended: 'stylistic',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [schema],
+  },
+  name: 'no-empty-function',
   create(context, [{ allow = [] }]) {
     const rules = baseRule.create(context);
 
@@ -159,21 +176,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allow: [],
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow empty functions',
-      extendsBaseRule: true,
-      recommended: 'stylistic',
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: [schema],
-    type: 'suggestion',
-  },
-  name: 'no-empty-function',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index a31d2fb853bf..9fcfbb36a4d5 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -13,6 +13,38 @@ type Options = [
 type MessageIds = 'noEmpty' | 'noEmptyWithSuper';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowSingleExtends: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    deprecated: true,
+    docs: {
+      description: 'Disallow the declaration of empty interfaces',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      noEmpty: 'An empty interface is equivalent to `{}`.',
+      noEmptyWithSuper:
+        'An interface declaring no members is equivalent to its supertype.',
+    },
+    replacedBy: ['@typescript-eslint/no-empty-object-type'],
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowSingleExtends: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-empty-interface',
   create(context, [{ allowSingleExtends }]) {
     return {
       TSInterfaceDeclaration(node): void {
@@ -81,36 +113,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowSingleExtends: false,
-    },
-  ],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: 'Disallow the declaration of empty interfaces',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      noEmpty: 'An empty interface is equivalent to `{}`.',
-      noEmptyWithSuper:
-        'An interface declaring no members is equivalent to its supertype.',
-    },
-    replacedBy: ['@typescript-eslint/no-empty-object-type'],
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowSingleExtends: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-empty-interface',
 });
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index f89b603c0629..8cc92e098af2 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -33,6 +33,50 @@ const noEmptyMessage = (emptyType: string): string =>
   ].join('\n');
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowInterfaces: 'never',
+      allowObjectTypes: 'never',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow accidentally using the "empty object" type',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      noEmptyInterface: noEmptyMessage('An empty interface declaration'),
+      noEmptyInterfaceWithSuper:
+        'An interface declaring no members is equivalent to its supertype.',
+      noEmptyObject: noEmptyMessage('The `{}` ("empty object") type'),
+      replaceEmptyInterface: 'Replace empty interface with `{{replacement}}`.',
+      replaceEmptyInterfaceWithSuper:
+        'Replace empty interface with a type alias.',
+      replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowInterfaces: {
+            type: 'string',
+            enum: ['always', 'never', 'with-single-extends'],
+          },
+          allowObjectTypes: {
+            type: 'string',
+            enum: ['always', 'never'],
+          },
+          allowWithName: {
+            type: 'string',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-empty-object-type',
   create(context, [{ allowInterfaces, allowObjectTypes, allowWithName }]) {
     const allowWithNameTester = allowWithName
       ? new RegExp(allowWithName, 'u')
@@ -141,48 +185,4 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: [
-    {
-      allowInterfaces: 'never',
-      allowObjectTypes: 'never',
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow accidentally using the "empty object" type',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      noEmptyInterface: noEmptyMessage('An empty interface declaration'),
-      noEmptyInterfaceWithSuper:
-        'An interface declaring no members is equivalent to its supertype.',
-      noEmptyObject: noEmptyMessage('The `{}` ("empty object") type'),
-      replaceEmptyInterface: 'Replace empty interface with `{{replacement}}`.',
-      replaceEmptyInterfaceWithSuper:
-        'Replace empty interface with a type alias.',
-      replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowInterfaces: {
-            enum: ['always', 'never', 'with-single-extends'],
-            type: 'string',
-          },
-          allowObjectTypes: {
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-          allowWithName: {
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-empty-object-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index a945e69aefb3..1b8c064d1cd2 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -13,6 +13,46 @@ export type Options = [
 export type MessageIds = 'suggestNever' | 'suggestUnknown' | 'unexpectedAny';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      fixToUnknown: false,
+      ignoreRestArgs: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow the `any` type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      suggestNever:
+        "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.",
+      suggestUnknown:
+        'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.',
+      unexpectedAny: 'Unexpected any. Specify a different type.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          fixToUnknown: {
+            type: 'boolean',
+            description:
+              'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
+          },
+          ignoreRestArgs: {
+            type: 'boolean',
+            description: 'Whether to ignore rest parameter arrays.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-explicit-any',
   create(context, [{ fixToUnknown, ignoreRestArgs }]) {
     /**
      * Checks if the node is an arrow function, function/constructor declaration or function expression
@@ -170,44 +210,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      fixToUnknown: false,
-      ignoreRestArgs: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow the `any` type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      suggestNever:
-        "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.",
-      suggestUnknown:
-        'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.',
-      unexpectedAny: 'Unexpected any. Specify a different type.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          fixToUnknown: {
-            description:
-              'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.',
-            type: 'boolean',
-          },
-          ignoreRestArgs: {
-            description: 'Whether to ignore rest parameter arrays.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-explicit-any',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index 6b9edf3b67fa..23257d5ca28b 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -3,6 +3,20 @@ import type { TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow extra non-null assertions',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
+    },
+    schema: [],
+  },
+  name: 'no-extra-non-null-assertion',
   create(context) {
     function checkExtraNonNullAssertion(
       node: TSESTree.TSNonNullExpression,
@@ -24,18 +38,4 @@ export default createRule({
       'TSNonNullExpression > TSNonNullExpression': checkExtraNonNullAssertion,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow extra non-null assertions',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      noExtraNonNullAssertion: 'Forbidden extra non-null assertion.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-extra-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 18043abb9833..3e0e1c7de486 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -15,6 +15,55 @@ type Options = [
 type MessageIds = 'empty' | 'onlyConstructor' | 'onlyStatic';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowConstructorOnly: false,
+      allowEmpty: false,
+      allowStaticOnly: false,
+      allowWithDecorator: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow classes used as namespaces',
+      recommended: 'strict',
+    },
+    messages: {
+      empty: 'Unexpected empty class.',
+      onlyConstructor: 'Unexpected class with only a constructor.',
+      onlyStatic: 'Unexpected class with only static properties.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowConstructorOnly: {
+            type: 'boolean',
+            description:
+              'Whether to allow extraneous classes that contain only a constructor.',
+          },
+          allowEmpty: {
+            type: 'boolean',
+            description:
+              'Whether to allow extraneous classes that have no body (i.e. are empty).',
+          },
+          allowStaticOnly: {
+            type: 'boolean',
+            description:
+              'Whether to allow extraneous classes that only contain static members.',
+          },
+          allowWithDecorator: {
+            type: 'boolean',
+            description:
+              'Whether to allow extraneous classes that include a decorator.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-extraneous-class',
   create(
     context,
     [{ allowConstructorOnly, allowEmpty, allowStaticOnly, allowWithDecorator }],
@@ -105,53 +154,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowConstructorOnly: false,
-      allowEmpty: false,
-      allowStaticOnly: false,
-      allowWithDecorator: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow classes used as namespaces',
-      recommended: 'strict',
-    },
-    messages: {
-      empty: 'Unexpected empty class.',
-      onlyConstructor: 'Unexpected class with only a constructor.',
-      onlyStatic: 'Unexpected class with only static properties.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowConstructorOnly: {
-            description:
-              'Whether to allow extraneous classes that contain only a constructor.',
-            type: 'boolean',
-          },
-          allowEmpty: {
-            description:
-              'Whether to allow extraneous classes that have no body (i.e. are empty).',
-            type: 'boolean',
-          },
-          allowStaticOnly: {
-            description:
-              'Whether to allow extraneous classes that only contain static members.',
-            type: 'boolean',
-          },
-          allowWithDecorator: {
-            description:
-              'Whether to allow extraneous classes that include a decorator.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-extraneous-class',
 });
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 6ad63ce2cc80..72faa95d685d 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -55,6 +55,60 @@ const messagePromiseArrayVoid =
   ' or explicitly marking the expression as ignored with the `void` operator.';
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [
+    {
+      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
+      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
+      checkThenables: false,
+      ignoreIIFE: false,
+      ignoreVoid: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require Promise-like statements to be handled appropriately',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      floating: messageBase,
+      floatingFixAwait: 'Add await operator.',
+      floatingFixVoid: 'Add void operator to ignore.',
+      floatingPromiseArray: messagePromiseArray,
+      floatingPromiseArrayVoid: messagePromiseArrayVoid,
+      floatingUselessRejectionHandler: `${messageBase} ${messageRejectionHandler}`,
+      floatingUselessRejectionHandlerVoid: `${messageBaseVoid} ${messageRejectionHandler}`,
+      floatingVoid: messageBaseVoid,
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
+          allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
+          checkThenables: {
+            type: 'boolean',
+            description:
+              'Whether to check all "Thenable"s, not just the built-in Promise type.',
+          },
+          ignoreIIFE: {
+            type: 'boolean',
+            description:
+              'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
+          },
+          ignoreVoid: {
+            type: 'boolean',
+            description: 'Whether to ignore `void` expressions.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-floating-promises',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -395,60 +449,6 @@ export default createRule<Options, MessageId>({
       return false;
     }
   },
-  defaultOptions: [
-    {
-      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
-      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
-      checkThenables: false,
-      ignoreIIFE: false,
-      ignoreVoid: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require Promise-like statements to be handled appropriately',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      floating: messageBase,
-      floatingFixAwait: 'Add await operator.',
-      floatingFixVoid: 'Add void operator to ignore.',
-      floatingPromiseArray: messagePromiseArray,
-      floatingPromiseArrayVoid: messagePromiseArrayVoid,
-      floatingUselessRejectionHandler: `${messageBase} ${messageRejectionHandler}`,
-      floatingUselessRejectionHandlerVoid: `${messageBaseVoid} ${messageRejectionHandler}`,
-      floatingVoid: messageBaseVoid,
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowForKnownSafeCalls: readonlynessOptionsSchema.properties.allow,
-          allowForKnownSafePromises: readonlynessOptionsSchema.properties.allow,
-          checkThenables: {
-            description:
-              'Whether to check all "Thenable"s, not just the built-in Promise type.',
-            type: 'boolean',
-          },
-          ignoreIIFE: {
-            description:
-              'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).',
-            type: 'boolean',
-          },
-          ignoreVoid: {
-            description: 'Whether to ignore `void` expressions.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-floating-promises',
 });
 
 function hasMatchingSignature(
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index 08fcb66e8413..310c7eea6491 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -9,6 +9,21 @@ import {
 import { getForStatementHeadLoc } from '../util/getForStatementHeadLoc';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow iterating over an array with a for-in loop',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      forInViolation:
+        'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
+    },
+    schema: [],
+  },
+  name: 'no-for-in-array',
   create(context) {
     return {
       ForInStatement(node): void {
@@ -29,19 +44,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow iterating over an array with a for-in loop',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      forInViolation:
-        'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-for-in-array',
 });
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index b2f29d50c735..85e15162a4e1 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -21,6 +21,23 @@ const EVAL_LIKE_METHODS = new Set([
 ]);
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow the use of `eval()`-like methods',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      noFunctionConstructor:
+        'Implied eval. Do not use the Function constructor to create functions.',
+      noImpliedEvalError: 'Implied eval. Consider passing a function.',
+    },
+    schema: [],
+  },
+  name: 'no-implied-eval',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -144,21 +161,4 @@ export default createRule({
       NewExpression: checkImpliedEval,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow the use of `eval()`-like methods',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      noFunctionConstructor:
-        'Implied eval. Do not use the Function constructor to create functions.',
-      noImpliedEvalError: 'Implied eval. Consider passing a function.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-implied-eval',
 });
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index 727e55a6ded7..8353fc26ef99 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -14,6 +14,21 @@ type Options = [];
 type MessageIds = 'useTopLevelQualifier';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
+    },
+    fixable: 'code',
+    messages: {
+      useTopLevelQualifier:
+        'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
+    },
+    schema: [],
+  },
+  name: 'no-import-type-side-effects',
   create(context) {
     return {
       'ImportDeclaration[importKind!="type"]'(
@@ -67,19 +82,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers',
-    },
-    fixable: 'code',
-    messages: {
-      useTopLevelQualifier:
-        'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-import-type-side-effects',
 });
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index bd27cd86af07..11e50fe49e46 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -14,6 +14,40 @@ type Options = [
 type MessageIds = 'noInferrableType';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoreParameters: false,
+      ignoreProperties: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      noInferrableType:
+        'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreParameters: {
+            type: 'boolean',
+          },
+          ignoreProperties: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-inferrable-types',
   create(context, [{ ignoreParameters, ignoreProperties }]) {
     function isFunctionCall(
       init: TSESTree.Expression,
@@ -249,38 +283,4 @@ export default createRule<Options, MessageIds>({
       VariableDeclarator: inferrableVariableVisitor,
     };
   },
-  defaultOptions: [
-    {
-      ignoreParameters: false,
-      ignoreProperties: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      noInferrableType:
-        'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreParameters: {
-            type: 'boolean',
-          },
-          ignoreProperties: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-inferrable-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-this.ts b/packages/eslint-plugin/src/rules/no-invalid-this.ts
index f27b1ccae90d..2919cc426f90 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-this.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-this.ts
@@ -16,6 +16,19 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ capIsConstructor: true }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow `this` keywords outside of classes or class-like objects',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'no-invalid-this',
   create(context) {
     const rules = baseRule.create(context);
 
@@ -83,17 +96,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ capIsConstructor: true }],
-  meta: {
-    docs: {
-      description:
-        'Disallow `this` keywords outside of classes or class-like objects',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'suggestion',
-  },
-  name: 'no-invalid-this',
 });
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index e9db3b139152..25ec23ae8951 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -18,6 +18,51 @@ type MessageIds =
   | 'invalidVoidUnionConstituent';
 
 export default createRule<[Options], MessageIds>({
+  defaultOptions: [
+    { allowAsThisParameter: false, allowInGenericTypeArguments: true },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow `void` type outside of generic or return types',
+      recommended: 'strict',
+    },
+    messages: {
+      invalidVoidForGeneric:
+        '{{ generic }} may not have void as a type argument.',
+      invalidVoidNotReturn: 'void is only valid as a return type.',
+      invalidVoidNotReturnOrGeneric:
+        'void is only valid as a return type or generic type argument.',
+      invalidVoidNotReturnOrThisParam:
+        'void is only valid as return type or type of `this` parameter.',
+      invalidVoidNotReturnOrThisParamOrGeneric:
+        'void is only valid as a return type or generic type argument or the type of a `this` parameter.',
+      invalidVoidUnionConstituent:
+        'void is not valid as a constituent in a union type',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowAsThisParameter: {
+            type: 'boolean',
+          },
+          allowInGenericTypeArguments: {
+            oneOf: [
+              { type: 'boolean' },
+              {
+                type: 'array',
+                items: { type: 'string' },
+                minItems: 1,
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-invalid-void-type',
   create(context, [{ allowAsThisParameter, allowInGenericTypeArguments }]) {
     const validParents: AST_NODE_TYPES[] = [
       AST_NODE_TYPES.TSTypeAnnotation, //
@@ -182,51 +227,6 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    { allowAsThisParameter: false, allowInGenericTypeArguments: true },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow `void` type outside of generic or return types',
-      recommended: 'strict',
-    },
-    messages: {
-      invalidVoidForGeneric:
-        '{{ generic }} may not have void as a type argument.',
-      invalidVoidNotReturn: 'void is only valid as a return type.',
-      invalidVoidNotReturnOrGeneric:
-        'void is only valid as a return type or generic type argument.',
-      invalidVoidNotReturnOrThisParam:
-        'void is only valid as return type or type of `this` parameter.',
-      invalidVoidNotReturnOrThisParamOrGeneric:
-        'void is only valid as a return type or generic type argument or the type of a `this` parameter.',
-      invalidVoidUnionConstituent:
-        'void is not valid as a constituent in a union type',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowAsThisParameter: {
-            type: 'boolean',
-          },
-          allowInGenericTypeArguments: {
-            oneOf: [
-              { type: 'boolean' },
-              {
-                items: { type: 'string' },
-                minItems: 1,
-                type: 'array',
-              },
-            ],
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-invalid-void-type',
 });
 
 function getNotReturnOrGenericMessageId(
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index d53f1959b906..9fc340f999e8 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -16,6 +16,19 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow function declarations that contain unsafe references inside loop statements',
+      extendsBaseRule: true,
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: [],
+  },
+  name: 'no-loop-func',
   create(context) {
     /**
      * Reports functions which match the following condition:
@@ -56,19 +69,6 @@ export default createRule<Options, MessageIds>({
       FunctionExpression: checkForLoops,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow function declarations that contain unsafe references inside loop statements',
-      extendsBaseRule: true,
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-loop-func',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
index 1631c33ac46e..3c2bf0e572ad 100644
--- a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
+++ b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
@@ -12,11 +12,9 @@ type Options = InferOptionsTypeFromRule<NonNullable<typeof baseRule>>;
 type MessageIds = InferMessageIdsTypeFromRule<NonNullable<typeof baseRule>>;
 
 export default createRule<Options, MessageIds>({
-  create(context) {
-    return baseRule.create(context);
-  },
   defaultOptions: [],
   meta: {
+    type: 'problem',
     deprecated: true,
     docs: {
       description: 'Disallow literal numbers that lose precision',
@@ -25,7 +23,9 @@ export default createRule<Options, MessageIds>({
     hasSuggestions: baseRule.meta.hasSuggestions,
     messages: baseRule.meta.messages,
     schema: [],
-    type: 'problem',
   },
   name: 'no-loss-of-precision',
+  create(context) {
+    return baseRule.create(context);
+  },
 });
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index 7a39d084d894..7f015b424186 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -41,6 +41,28 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      detectObjects: false,
+      enforceConst: false,
+      ignore: [],
+      ignoreArrayIndexes: false,
+      ignoreEnums: false,
+      ignoreNumericLiteralTypes: false,
+      ignoreReadonlyClassProperties: false,
+      ignoreTypeIndexes: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow magic numbers',
+      extendsBaseRule: true,
+    },
+    messages: baseRule.meta.messages,
+    schema: [schema],
+  },
+  name: 'no-magic-numbers',
   create(context, [options]) {
     const rules = baseRule.create(context);
 
@@ -114,28 +136,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      detectObjects: false,
-      enforceConst: false,
-      ignore: [],
-      ignoreArrayIndexes: false,
-      ignoreEnums: false,
-      ignoreNumericLiteralTypes: false,
-      ignoreReadonlyClassProperties: false,
-      ignoreTypeIndexes: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow magic numbers',
-      extendsBaseRule: true,
-    },
-    messages: baseRule.meta.messages,
-    schema: [schema],
-    type: 'suggestion',
-  },
-  name: 'no-magic-numbers',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index 4a7de1f3c2f7..6463bb89aa1f 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -13,6 +13,36 @@ type Options = [
 ];
 
 export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
+  defaultOptions: [{ checkNever: false }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow the `void` operator except when used to discard a value',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      meaninglessVoidOperator:
+        "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
+      removeVoid: "Remove 'void'",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          checkNever: {
+            type: 'boolean',
+            default: false,
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-meaningless-void-operator',
   create(context, [{ checkNever }]) {
     const services = ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -57,34 +87,4 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
       },
     };
   },
-  defaultOptions: [{ checkNever: false }],
-  meta: {
-    docs: {
-      description:
-        'Disallow the `void` operator except when used to discard a value',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      meaninglessVoidOperator:
-        "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
-      removeVoid: "Remove 'void'",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          checkNever: {
-            default: false,
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-meaningless-void-operator',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index 53c3447357ba..cbdbe9b6f661 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -5,6 +5,20 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce valid definition of `new` and `constructor`',
+      recommended: 'recommended',
+    },
+    messages: {
+      errorMessageClass: 'Class cannot have method named `new`.',
+      errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
+    },
+    schema: [],
+  },
+  name: 'no-misused-new',
   create(context) {
     /**
      * @param node type to be inspected.
@@ -96,18 +110,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Enforce valid definition of `new` and `constructor`',
-      recommended: 'recommended',
-    },
-    messages: {
-      errorMessageClass: 'Class cannot have method named `new`.',
-      errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-misused-new',
 });
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index 5d4a4cdb8e3e..c917d5a13ab2 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -71,6 +71,69 @@ function parseChecksVoidReturn(
 }
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [
+    {
+      checksConditionals: true,
+      checksSpreads: true,
+      checksVoidReturn: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow Promises in places not designed to handle them',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      conditional: 'Expected non-Promise value in a boolean conditional.',
+      spread: 'Expected a non-Promise value to be spreaded in an object.',
+      voidReturnArgument:
+        'Promise returned in function argument where a void return was expected.',
+      voidReturnAttribute:
+        'Promise-returning function provided to attribute where a void return was expected.',
+      voidReturnInheritedMethod:
+        "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.",
+      voidReturnProperty:
+        'Promise-returning function provided to property where a void return was expected.',
+      voidReturnReturnValue:
+        'Promise-returning function provided to return value where a void return was expected.',
+      voidReturnVariable:
+        'Promise-returning function provided to variable where a void return was expected.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          checksConditionals: {
+            type: 'boolean',
+          },
+          checksSpreads: {
+            type: 'boolean',
+          },
+          checksVoidReturn: {
+            oneOf: [
+              { type: 'boolean' },
+              {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                  arguments: { type: 'boolean' },
+                  attributes: { type: 'boolean' },
+                  inheritedMethods: { type: 'boolean' },
+                  properties: { type: 'boolean' },
+                  returns: { type: 'boolean' },
+                  variables: { type: 'boolean' },
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-misused-promises',
   create(context, [{ checksConditionals, checksSpreads, checksVoidReturn }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -527,69 +590,6 @@ export default createRule<Options, MessageId>({
       ...(checksSpreads ? spreadChecks : {}),
     };
   },
-  defaultOptions: [
-    {
-      checksConditionals: true,
-      checksSpreads: true,
-      checksVoidReturn: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow Promises in places not designed to handle them',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      conditional: 'Expected non-Promise value in a boolean conditional.',
-      spread: 'Expected a non-Promise value to be spreaded in an object.',
-      voidReturnArgument:
-        'Promise returned in function argument where a void return was expected.',
-      voidReturnAttribute:
-        'Promise-returning function provided to attribute where a void return was expected.',
-      voidReturnInheritedMethod:
-        "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.",
-      voidReturnProperty:
-        'Promise-returning function provided to property where a void return was expected.',
-      voidReturnReturnValue:
-        'Promise-returning function provided to return value where a void return was expected.',
-      voidReturnVariable:
-        'Promise-returning function provided to variable where a void return was expected.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          checksConditionals: {
-            type: 'boolean',
-          },
-          checksSpreads: {
-            type: 'boolean',
-          },
-          checksVoidReturn: {
-            oneOf: [
-              { type: 'boolean' },
-              {
-                additionalProperties: false,
-                properties: {
-                  arguments: { type: 'boolean' },
-                  attributes: { type: 'boolean' },
-                  inheritedMethods: { type: 'boolean' },
-                  properties: { type: 'boolean' },
-                  returns: { type: 'boolean' },
-                  variables: { type: 'boolean' },
-                },
-                type: 'object',
-              },
-            ],
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-misused-promises',
 });
 
 function isSometimesThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index 68e3594b27bb..911f70bf9a87 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -15,6 +15,20 @@ enum AllowedType {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow enums from having both number and string members',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      mixed: `Mixing number and string enums can be confusing.`,
+    },
+    schema: [],
+  },
+  name: 'no-mixed-enums',
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
@@ -204,18 +218,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow enums from having both number and string members',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      mixed: `Mixing number and string enums can be confusing.`,
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-mixed-enums',
 });
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index 95ddae51a851..821b9a1e7075 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -13,34 +13,6 @@ type Options = [
 type MessageIds = 'moduleSyntaxIsPreferred';
 
 export default createRule<Options, MessageIds>({
-  create(context, [{ allowDeclarations, allowDefinitionFiles }]) {
-    function isDeclaration(node: TSESTree.Node): boolean {
-      if (node.type === AST_NODE_TYPES.TSModuleDeclaration && node.declare) {
-        return true;
-      }
-
-      return node.parent != null && isDeclaration(node.parent);
-    }
-
-    return {
-      "TSModuleDeclaration[global!=true][id.type!='Literal']"(
-        node: TSESTree.TSModuleDeclaration,
-      ): void {
-        if (
-          node.parent.type === AST_NODE_TYPES.TSModuleDeclaration ||
-          (allowDefinitionFiles && isDefinitionFile(context.filename)) ||
-          (allowDeclarations && isDeclaration(node))
-        ) {
-          return;
-        }
-
-        context.report({
-          messageId: 'moduleSyntaxIsPreferred',
-          node,
-        });
-      },
-    };
-  },
   defaultOptions: [
     {
       allowDeclarations: false,
@@ -48,6 +20,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow TypeScript namespaces',
       recommended: 'recommended',
@@ -58,23 +31,50 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowDeclarations: {
+            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces.',
-            type: 'boolean',
           },
           allowDefinitionFiles: {
+            type: 'boolean',
             description:
               'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
-            type: 'boolean',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-namespace',
+  create(context, [{ allowDeclarations, allowDefinitionFiles }]) {
+    function isDeclaration(node: TSESTree.Node): boolean {
+      if (node.type === AST_NODE_TYPES.TSModuleDeclaration && node.declare) {
+        return true;
+      }
+
+      return node.parent != null && isDeclaration(node.parent);
+    }
+
+    return {
+      "TSModuleDeclaration[global!=true][id.type!='Literal']"(
+        node: TSESTree.TSModuleDeclaration,
+      ): void {
+        if (
+          node.parent.type === AST_NODE_TYPES.TSModuleDeclaration ||
+          (allowDefinitionFiles && isDefinitionFile(context.filename)) ||
+          (allowDeclarations && isDeclaration(node))
+        ) {
+          return;
+        }
+
+        context.report({
+          messageId: 'moduleSyntaxIsPreferred',
+          node,
+        });
+      },
+    };
+  },
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index 3315fe241f15..9c387f3b2f9d 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -31,6 +31,23 @@ function isDefinitionWithAssignment(definition: Definition): boolean {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow non-null assertions in the left operand of a nullish coalescing operator',
+      recommended: 'strict',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNullAssertedNullishCoalescing:
+        'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
+      suggestRemovingNonNull: 'Remove the non-null assertion.',
+    },
+    schema: [],
+  },
+  name: 'no-non-null-asserted-nullish-coalescing',
   create(context) {
     return {
       'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(
@@ -80,21 +97,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow non-null assertions in the left operand of a nullish coalescing operator',
-      recommended: 'strict',
-    },
-    hasSuggestions: true,
-    messages: {
-      noNonNullAssertedNullishCoalescing:
-        'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
-      suggestRemovingNonNull: 'Remove the non-null assertion.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-non-null-asserted-nullish-coalescing',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index 2e474b0a5513..8eb850f779ae 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -3,6 +3,23 @@ import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow non-null assertions after an optional chain expression',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNullOptionalChain:
+        'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.',
+      suggestRemovingNonNull: 'You should remove the non-null assertion.',
+    },
+    schema: [],
+  },
+  name: 'no-non-null-asserted-optional-chain',
   create(context) {
     return {
       // non-nulling a wrapped chain will scrub all nulls introduced by the chain
@@ -53,21 +70,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow non-null assertions after an optional chain expression',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      noNonNullOptionalChain:
-        'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.',
-      suggestRemovingNonNull: 'You should remove the non-null assertion.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-non-null-asserted-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 422f860489c0..1729b31a1a6a 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -12,6 +12,23 @@ import {
 type MessageIds = 'noNonNull' | 'suggestOptionalChain';
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow non-null assertions using the `!` postfix operator',
+      recommended: 'strict',
+    },
+    hasSuggestions: true,
+    messages: {
+      noNonNull: 'Forbidden non-null assertion.',
+      suggestOptionalChain:
+        'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
+    },
+    schema: [],
+  },
+  name: 'no-non-null-assertion',
   create(context) {
     return {
       TSNonNullExpression(node): void {
@@ -103,21 +120,4 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow non-null assertions using the `!` postfix operator',
-      recommended: 'strict',
-    },
-    hasSuggestions: true,
-    messages: {
-      noNonNull: 'Forbidden non-null assertion.',
-      suggestOptionalChain:
-        'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-non-null-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index 4e77b8adc561..e5e072abedfe 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -14,6 +14,41 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      builtinGlobals: true,
+      ignoreDeclarationMerge: true,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow variable redeclaration',
+      extendsBaseRule: true,
+    },
+    messages: {
+      redeclared: "'{{id}}' is already defined.",
+      redeclaredAsBuiltin:
+        "'{{id}}' is already defined as a built-in global variable.",
+      redeclaredBySyntax:
+        "'{{id}}' is already defined by a variable declaration.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          builtinGlobals: {
+            type: 'boolean',
+          },
+          ignoreDeclarationMerge: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-redeclare',
   create(context, [options]) {
     const CLASS_DECLARATION_MERGE_NODES = new Set<AST_NODE_TYPES>([
       AST_NODE_TYPES.TSInterfaceDeclaration,
@@ -52,13 +87,13 @@ export default createRule<Options, MessageIds>({
       ) {
         for (const comment of variable.eslintExplicitGlobalComments) {
           yield {
+            type: 'comment',
             loc: getNameLocationInGlobalDirectiveComment(
               context.sourceCode,
               comment,
               variable.name,
             ),
             node: comment,
-            type: 'comment',
           };
         }
       }
@@ -109,7 +144,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one class declaration, which needs to be reported
           for (const { identifier } of classDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
@@ -130,7 +165,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one function declaration, which needs to be reported
           for (const { identifier } of functionDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
@@ -151,14 +186,14 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one enum declaration, which needs to be reported
           for (const { identifier } of enumDecls) {
-            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            yield { type: 'syntax', loc: identifier.loc, node: identifier };
           }
           return;
         }
       }
 
       for (const { identifier } of identifiers) {
-        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+        yield { type: 'syntax', loc: identifier.loc, node: identifier };
       }
     }
 
@@ -183,7 +218,7 @@ export default createRule<Options, MessageIds>({
         const data = { id: variable.name };
 
         // Report extra declarations.
-        for (const { loc, node, type } of extraDeclarations) {
+        for (const { type, loc, node } of extraDeclarations) {
           const messageId =
             type === declaration.type ? 'redeclared' : detailMessageId;
 
@@ -239,39 +274,4 @@ export default createRule<Options, MessageIds>({
       SwitchStatement: checkForBlock,
     };
   },
-  defaultOptions: [
-    {
-      builtinGlobals: true,
-      ignoreDeclarationMerge: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow variable redeclaration',
-      extendsBaseRule: true,
-    },
-    messages: {
-      redeclared: "'{{id}}' is already defined.",
-      redeclaredAsBuiltin:
-        "'{{id}}' is already defined as a built-in global variable.",
-      redeclaredBySyntax:
-        "'{{id}}' is already defined by a variable declaration.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          builtinGlobals: {
-            type: 'boolean',
-          },
-          ignoreDeclarationMerge: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-redeclare',
 });
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index 063f9f92f383..c76589d5d53b 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -192,6 +192,25 @@ function unionTypePartsUnlessBoolean(type: ts.Type): ts.Type[] {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow members of unions and intersections that do nothing or override type information',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
+      literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
+      overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
+      overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
+      primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
+    },
+    schema: [],
+  },
+  name: 'no-redundant-type-constituents',
   create(context) {
     const services = getParserServices(context);
     const typesCache = new Map<TSESTree.TypeNode, TypeFlagsWithName[]>();
@@ -513,23 +532,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow members of unions and intersections that do nothing or override type information',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
-      literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
-      overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
-      overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
-      primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-redundant-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 69337e0d2cd4..2873bf2d6e45 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -13,6 +13,35 @@ type Options = [
 type MessageIds = 'noRequireImports';
 
 export default util.createRule<Options, MessageIds>({
+  defaultOptions: [{ allow: [], allowAsImport: false }],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow invocation of `require()`',
+      recommended: 'recommended',
+    },
+    messages: {
+      noRequireImports: 'A `require()` style import is forbidden.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allow: {
+            type: 'array',
+            description: 'Patterns of import paths to allow requiring from.',
+            items: { type: 'string' },
+          },
+          allowAsImport: {
+            type: 'boolean',
+            description: 'Allows `require` statements in import declarations.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-require-imports',
   create(context, options) {
     const allowAsImport = options[0].allowAsImport;
     const allowPatterns = options[0].allow?.map(
@@ -72,33 +101,4 @@ export default util.createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ allow: [], allowAsImport: false }],
-  meta: {
-    docs: {
-      description: 'Disallow invocation of `require()`',
-      recommended: 'recommended',
-    },
-    messages: {
-      noRequireImports: 'A `require()` style import is forbidden.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allow: {
-            description: 'Patterns of import paths to allow requiring from.',
-            items: { type: 'string' },
-            type: 'array',
-          },
-          allowAsImport: {
-            description: 'Allows `require` statements in import declarations.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-require-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-imports.ts b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
index 3245778679dc..71dfdc1931de 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
@@ -82,16 +82,18 @@ const baseSchema = baseRule.meta.schema as {
 
 const allowTypeImportsOptionSchema: JSONSchema4ObjectSchema['properties'] = {
   allowTypeImports: {
-    description: 'Disallow value imports, but allow type-only imports.',
     type: 'boolean',
+    description: 'Disallow value imports, but allow type-only imports.',
   },
 };
 
 const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
+  type: 'array',
   items: {
     anyOf: [
       { type: 'string' },
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -108,25 +110,25 @@ const arrayOfStringsOrObjects: JSONSchema4ArraySchema = {
               .required,
           undefined,
         ),
-        type: 'object',
       },
     ],
   },
-  type: 'array',
   uniqueItems: true,
 };
 
 const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
   anyOf: [
     {
+      type: 'array',
       items: {
         type: 'string',
       },
-      type: 'array',
       uniqueItems: true,
     },
     {
+      type: 'array',
       items: {
+        type: 'object',
         additionalProperties: false,
         properties: {
           ...tryAccess(
@@ -143,9 +145,7 @@ const arrayOfStringsOrObjectPatterns: JSONSchema4AnyOfSchema = {
               .required,
           [],
         ),
-        type: 'object',
       },
-      type: 'array',
       uniqueItems: true,
     },
   ],
@@ -155,18 +155,18 @@ const schema: JSONSchema4AnyOfSchema = {
   anyOf: [
     arrayOfStringsOrObjects,
     {
+      type: 'array',
       additionalItems: false,
       items: [
         {
+          type: 'object',
           additionalProperties: false,
           properties: {
             paths: arrayOfStringsOrObjects,
             patterns: arrayOfStringsOrObjectPatterns,
           },
-          type: 'object',
         },
       ],
-      type: 'array',
     },
   ],
 };
@@ -230,6 +230,18 @@ function shouldCreateRule(
 }
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow specified modules when loaded by `import`',
+      extendsBaseRule: true,
+    },
+    fixable: baseRule.meta.fixable,
+    messages: baseRule.meta.messages,
+    schema,
+  },
+  name: 'no-restricted-imports',
   create(context) {
     const rules = baseRule.create(context);
     const { options } = context;
@@ -329,35 +341,23 @@ export default createRule<Options, MessageIds>({
         ) {
           const synthesizedImport: TSESTree.ImportDeclaration = {
             ...node,
+            type: AST_NODE_TYPES.ImportDeclaration,
             assertions: [],
             attributes: [],
             source: node.moduleReference.expression,
             specifiers: [
               {
                 ...node.id,
-                local: node.id,
                 type: AST_NODE_TYPES.ImportDefaultSpecifier,
+                local: node.id,
                 // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension
                 parent: node.id.parent,
               },
             ],
-            type: AST_NODE_TYPES.ImportDeclaration,
           };
           return checkImportNode(synthesizedImport);
         }
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow specified modules when loaded by `import`',
-      extendsBaseRule: true,
-    },
-    fixable: baseRule.meta.fixable,
-    messages: baseRule.meta.messages,
-    schema,
-    type: 'suggestion',
-  },
-  name: 'no-restricted-imports',
 });
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index afdf0cf07e9f..97c36ef23a4d 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -69,6 +69,70 @@ const TYPE_KEYWORDS = {
 };
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{}],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow certain types',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
+      bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          banConfig: {
+            oneOf: [
+              {
+                type: 'boolean',
+                description: 'Bans the type with the default message',
+                enum: [true],
+              },
+              {
+                type: 'string',
+                description: 'Bans the type with a custom message',
+              },
+              {
+                type: 'object',
+                additionalProperties: false,
+                description: 'Bans a type',
+                properties: {
+                  fixWith: {
+                    type: 'string',
+                    description:
+                      'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
+                  },
+                  message: {
+                    type: 'string',
+                    description: 'Custom error message',
+                  },
+                  suggest: {
+                    type: 'array',
+                    description: 'Types to suggest replacing with.',
+                    items: { type: 'string' },
+                  },
+                },
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          types: {
+            type: 'object',
+            additionalProperties: {
+              $ref: '#/items/0/$defs/banConfig',
+            },
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-restricted-types',
   create(context, [{ types = {} }]) {
     const bannedTypes = new Map(
       Object.entries(types).map(([type, data]) => [removeSpaces(type), data]),
@@ -155,68 +219,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{}],
-  meta: {
-    docs: {
-      description: 'Disallow certain types',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
-      bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.',
-    },
-    schema: [
-      {
-        $defs: {
-          banConfig: {
-            oneOf: [
-              {
-                description: 'Bans the type with the default message',
-                enum: [true],
-                type: 'boolean',
-              },
-              {
-                description: 'Bans the type with a custom message',
-                type: 'string',
-              },
-              {
-                additionalProperties: false,
-                description: 'Bans a type',
-                properties: {
-                  fixWith: {
-                    description:
-                      'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
-                    type: 'string',
-                  },
-                  message: {
-                    description: 'Custom error message',
-                    type: 'string',
-                  },
-                  suggest: {
-                    description: 'Types to suggest replacing with.',
-                    items: { type: 'string' },
-                    type: 'array',
-                  },
-                },
-                type: 'object',
-              },
-            ],
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          types: {
-            additionalProperties: {
-              $ref: '#/items/0/$defs/banConfig',
-            },
-            type: 'object',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-restricted-types',
 });
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 049b656f1c6f..62e92e43554f 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -25,6 +25,60 @@ const allowedFunctionVariableDefTypes = new Set([
 ]);
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allow: [],
+      builtinGlobals: false,
+      hoist: 'functions',
+      ignoreFunctionTypeParameterNameValueShadow: true,
+      ignoreOnInitialization: false,
+      ignoreTypeValueShadow: true,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow variable declarations from shadowing variables declared in the outer scope',
+      extendsBaseRule: true,
+    },
+    messages: {
+      noShadow:
+        "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
+      noShadowGlobal: "'{{name}}' is already a global variable.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allow: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+          builtinGlobals: {
+            type: 'boolean',
+          },
+          hoist: {
+            type: 'string',
+            enum: ['all', 'functions', 'never'],
+          },
+          ignoreFunctionTypeParameterNameValueShadow: {
+            type: 'boolean',
+          },
+          ignoreOnInitialization: {
+            type: 'boolean',
+          },
+          ignoreTypeValueShadow: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-shadow',
   create(context, [options]) {
     /**
      * Check if a scope is a TypeScript module augmenting the global namespace.
@@ -593,58 +647,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allow: [],
-      builtinGlobals: false,
-      hoist: 'functions',
-      ignoreFunctionTypeParameterNameValueShadow: true,
-      ignoreOnInitialization: false,
-      ignoreTypeValueShadow: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow variable declarations from shadowing variables declared in the outer scope',
-      extendsBaseRule: true,
-    },
-    messages: {
-      noShadow:
-        "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
-      noShadowGlobal: "'{{name}}' is already a global variable.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allow: {
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          builtinGlobals: {
-            type: 'boolean',
-          },
-          hoist: {
-            enum: ['all', 'functions', 'never'],
-            type: 'string',
-          },
-          ignoreFunctionTypeParameterNameValueShadow: {
-            type: 'boolean',
-          },
-          ignoreOnInitialization: {
-            type: 'boolean',
-          },
-          ignoreTypeValueShadow: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-shadow',
 });
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 7bee02498dc0..82851be9ade7 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -13,35 +13,6 @@ type Options = [
 type MessageIds = 'thisAssignment' | 'thisDestructure';
 
 export default createRule<Options, MessageIds>({
-  create(context, [{ allowDestructuring, allowedNames }]) {
-    return {
-      "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(
-        node: TSESTree.AssignmentExpression | TSESTree.VariableDeclarator,
-      ): void {
-        const id =
-          node.type === AST_NODE_TYPES.VariableDeclarator ? node.id : node.left;
-        if (allowDestructuring && id.type !== AST_NODE_TYPES.Identifier) {
-          return;
-        }
-
-        const hasAllowedName =
-          id.type === AST_NODE_TYPES.Identifier
-            ? // https://github.com/typescript-eslint/typescript-eslint/issues/5439
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              allowedNames!.includes(id.name)
-            : false;
-        if (!hasAllowedName) {
-          context.report({
-            messageId:
-              id.type === AST_NODE_TYPES.Identifier
-                ? 'thisAssignment'
-                : 'thisDestructure',
-            node: id,
-          });
-        }
-      },
-    };
-  },
   defaultOptions: [
     {
       allowDestructuring: true,
@@ -49,6 +20,7 @@ export default createRule<Options, MessageIds>({
     },
   ],
   meta: {
+    type: 'suggestion',
     docs: {
       description: 'Disallow aliasing `this`',
       recommended: 'recommended',
@@ -60,26 +32,54 @@ export default createRule<Options, MessageIds>({
     },
     schema: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           allowDestructuring: {
+            type: 'boolean',
             description:
               'Whether to ignore destructurings, such as `const { props, state } = this`.',
-            type: 'boolean',
           },
           allowedNames: {
+            type: 'array',
             description:
               'Names to ignore, such as ["self"] for `const self = this;`.',
             items: {
               type: 'string',
             },
-            type: 'array',
           },
         },
-        type: 'object',
       },
     ],
-    type: 'suggestion',
   },
   name: 'no-this-alias',
+  create(context, [{ allowDestructuring, allowedNames }]) {
+    return {
+      "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(
+        node: TSESTree.AssignmentExpression | TSESTree.VariableDeclarator,
+      ): void {
+        const id =
+          node.type === AST_NODE_TYPES.VariableDeclarator ? node.id : node.left;
+        if (allowDestructuring && id.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+
+        const hasAllowedName =
+          id.type === AST_NODE_TYPES.Identifier
+            ? // https://github.com/typescript-eslint/typescript-eslint/issues/5439
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              allowedNames!.includes(id.name)
+            : false;
+        if (!hasAllowedName) {
+          context.report({
+            messageId:
+              id.type === AST_NODE_TYPES.Identifier
+                ? 'thisAssignment'
+                : 'thisDestructure',
+            node: id,
+          });
+        }
+      },
+    };
+  },
 });
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index adf47dad6248..bd6ff3bebf86 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -34,6 +34,89 @@ interface TypeWithLabel {
 }
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowAliases: 'never',
+      allowCallbacks: 'never',
+      allowConditionalTypes: 'never',
+      allowConstructors: 'never',
+      allowGenerics: 'never',
+      allowLiterals: 'never',
+      allowMappedTypes: 'never',
+      allowTupleTypes: 'never',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    deprecated: true,
+    docs: {
+      description: 'Disallow type aliases',
+      // too opinionated to be recommended
+    },
+    messages: {
+      noCompositionAlias:
+        '{{typeName}} in {{compositionType}} types are not allowed.',
+      noTypeAlias: 'Type {{alias}} are not allowed.',
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          expandedOptions: {
+            type: 'string',
+            enum: [
+              'always',
+              'never',
+              'in-unions',
+              'in-intersections',
+              'in-unions-and-intersections',
+            ] satisfies Values[],
+          },
+          simpleOptions: {
+            type: 'string',
+            enum: ['always', 'never'],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          allowAliases: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow direct one-to-one type aliases.',
+          },
+          allowCallbacks: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases for callbacks.',
+          },
+          allowConditionalTypes: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases for conditional types.',
+          },
+          allowConstructors: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases with constructors.',
+          },
+          allowGenerics: {
+            $ref: '#/items/0/$defs/simpleOptions',
+            description: 'Whether to allow type aliases with generic types.',
+          },
+          allowLiterals: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description:
+              'Whether to allow type aliases with object literal types.',
+          },
+          allowMappedTypes: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow type aliases with mapped types.',
+          },
+          allowTupleTypes: {
+            $ref: '#/items/0/$defs/expandedOptions',
+            description: 'Whether to allow type aliases with tuple types.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-type-alias',
   create(
     context,
     [
@@ -266,87 +349,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowAliases: 'never',
-      allowCallbacks: 'never',
-      allowConditionalTypes: 'never',
-      allowConstructors: 'never',
-      allowGenerics: 'never',
-      allowLiterals: 'never',
-      allowMappedTypes: 'never',
-      allowTupleTypes: 'never',
-    },
-  ],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: 'Disallow type aliases',
-      // too opinionated to be recommended
-    },
-    messages: {
-      noCompositionAlias:
-        '{{typeName}} in {{compositionType}} types are not allowed.',
-      noTypeAlias: 'Type {{alias}} are not allowed.',
-    },
-    schema: [
-      {
-        $defs: {
-          expandedOptions: {
-            enum: [
-              'always',
-              'never',
-              'in-unions',
-              'in-intersections',
-              'in-unions-and-intersections',
-            ] satisfies Values[],
-            type: 'string',
-          },
-          simpleOptions: {
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          allowAliases: {
-            $ref: '#/items/0/$defs/expandedOptions',
-            description: 'Whether to allow direct one-to-one type aliases.',
-          },
-          allowCallbacks: {
-            $ref: '#/items/0/$defs/simpleOptions',
-            description: 'Whether to allow type aliases for callbacks.',
-          },
-          allowConditionalTypes: {
-            $ref: '#/items/0/$defs/simpleOptions',
-            description: 'Whether to allow type aliases for conditional types.',
-          },
-          allowConstructors: {
-            $ref: '#/items/0/$defs/simpleOptions',
-            description: 'Whether to allow type aliases with constructors.',
-          },
-          allowGenerics: {
-            $ref: '#/items/0/$defs/simpleOptions',
-            description: 'Whether to allow type aliases with generic types.',
-          },
-          allowLiterals: {
-            $ref: '#/items/0/$defs/expandedOptions',
-            description:
-              'Whether to allow type aliases with object literal types.',
-          },
-          allowMappedTypes: {
-            $ref: '#/items/0/$defs/expandedOptions',
-            description: 'Whether to allow type aliases with mapped types.',
-          },
-          allowTupleTypes: {
-            $ref: '#/items/0/$defs/expandedOptions',
-            description: 'Whether to allow type aliases with tuple types.',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-type-alias',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 4d9df9513e96..57d9294303e5 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -31,6 +31,53 @@ interface BooleanComparisonWithTypeInformation extends BooleanComparison {
 }
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowComparingNullableBooleansToFalse: true,
+      allowComparingNullableBooleansToTrue: true,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow unnecessary equality comparisons against boolean literals',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      comparingNullableToFalse:
+        'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.',
+      comparingNullableToTrueDirect:
+        'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.',
+      comparingNullableToTrueNegated:
+        'This expression unnecessarily compares a nullable boolean value to true instead of negating it.',
+      direct:
+        'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
+      negated:
+        'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowComparingNullableBooleansToFalse: {
+            type: 'boolean',
+            description:
+              'Whether to allow comparisons between nullable boolean variables and `false`.',
+          },
+          allowComparingNullableBooleansToTrue: {
+            type: 'boolean',
+            description:
+              'Whether to allow comparisons between nullable boolean variables and `true`.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-unnecessary-boolean-literal-compare',
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -222,53 +269,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowComparingNullableBooleansToFalse: true,
-      allowComparingNullableBooleansToTrue: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow unnecessary equality comparisons against boolean literals',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      comparingNullableToFalse:
-        'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.',
-      comparingNullableToTrueDirect:
-        'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.',
-      comparingNullableToTrueNegated:
-        'This expression unnecessarily compares a nullable boolean value to true instead of negating it.',
-      direct:
-        'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
-      negated:
-        'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowComparingNullableBooleansToFalse: {
-            description:
-              'Whether to allow comparisons between nullable boolean variables and `false`.',
-            type: 'boolean',
-          },
-          allowComparingNullableBooleansToTrue: {
-            description:
-              'Whether to allow comparisons between nullable boolean variables and `true`.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-boolean-literal-compare',
 });
 
 interface EqualsKind {
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 4e8fea5ee6af..093c180243d8 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -88,6 +88,61 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [
+    {
+      allowConstantLoopConditions: false,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow conditionals where the type is always truthy or always falsy',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
+      alwaysFalsyFunc:
+        'This callback should return a conditional, but return is always falsy.',
+      alwaysNullish:
+        'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
+      alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
+      alwaysTruthyFunc:
+        'This callback should return a conditional, but return is always truthy.',
+      literalBooleanExpression:
+        'Unnecessary conditional, both sides of the expression are literal values.',
+      never: 'Unnecessary conditional, value is `never`.',
+      neverNullish:
+        'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
+      neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
+      noOverlapBooleanExpression:
+        'Unnecessary conditional, the types have no overlap.',
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowConstantLoopConditions: {
+            type: 'boolean',
+            description:
+              'Whether to ignore constant loop conditions, such as `while (true)`.',
+          },
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+            description:
+              'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-unnecessary-condition',
   create(
     context,
     [
@@ -677,59 +732,4 @@ export default createRule<Options, MessageId>({
       WhileStatement: checkIfLoopIsNecessaryConditional,
     };
   },
-  defaultOptions: [
-    {
-      allowConstantLoopConditions: false,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow conditionals where the type is always truthy or always falsy',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
-      alwaysFalsyFunc:
-        'This callback should return a conditional, but return is always falsy.',
-      alwaysNullish:
-        'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
-      alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
-      alwaysTruthyFunc:
-        'This callback should return a conditional, but return is always truthy.',
-      literalBooleanExpression:
-        'Unnecessary conditional, both sides of the expression are literal values.',
-      never: 'Unnecessary conditional, value is `never`.',
-      neverNullish:
-        'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
-      neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
-      noOverlapBooleanExpression:
-        'Unnecessary conditional, the types have no overlap.',
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowConstantLoopConditions: {
-            description:
-              'Whether to ignore constant loop conditions, such as `while (true)`.',
-            type: 'boolean',
-          },
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            description:
-              'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-condition',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index 7a5751430309..ac013f0a68a3 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -8,6 +8,20 @@ import { createRule, getStaticStringValue, nullThrows } from '../util';
 const UNNECESSARY_OPERATORS = new Set(['=', '&&=', '||=', '??=']);
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow unnecessary assignment of constructor property parameter',
+    },
+    messages: {
+      unnecessaryAssign:
+        'This assignment is unnecessary since it is already assigned by a parameter property.',
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-parameter-property-assignment',
   create(context) {
     const reportInfoStack: {
       assignedBeforeConstructor: Set<string>;
@@ -216,18 +230,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow unnecessary assignment of constructor property parameter',
-    },
-    messages: {
-      unnecessaryAssign:
-        'This assignment is unnecessary since it is already assigned by a parameter property.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-parameter-property-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index aebd62131a9f..028bd753a0c9 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -7,6 +7,21 @@ import * as ts from 'typescript';
 import { createRule, getParserServices } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unnecessary namespace qualifiers',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      unnecessaryQualifier:
+        "Qualifier is unnecessary since '{{ name }}' is in scope.",
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-qualifier',
   create(context) {
     const namespacesInScope: ts.Node[] = [];
     let currentFailedNamespaceExpression: TSESTree.Node | null = null;
@@ -174,19 +189,4 @@ export default createRule({
       'TSQualifiedName:exit': resetCurrentNamespaceExpression,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary namespace qualifiers',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      unnecessaryQualifier:
-        "Qualifier is unnecessary since '{{ name }}' is in scope.",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-qualifier',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index 0698a772a372..9a9712742038 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -26,6 +26,22 @@ function endsWithUnescapedDollarSign(str: string): boolean {
 }
 
 export default createRule<[], MessageId>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unnecessary template expressions',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      noUnnecessaryTemplateExpression:
+        'Template literal expression is unnecessary and can be simplified.',
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-template-expression',
   create(context) {
     const services = getParserServices(context);
 
@@ -253,20 +269,4 @@ export default createRule<[], MessageId>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary template expressions',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      noUnnecessaryTemplateExpression:
-        'Template literal expression is unnecessary and can be simplified.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-template-expression',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index cb50145babfb..794bb47ee62d 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -24,6 +24,22 @@ type ParameterCapableTSNode =
 type MessageIds = 'unnecessaryTypeParameter';
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow type arguments that are equal to the default',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      unnecessaryTypeParameter:
+        'This is the default value for this type parameter, so it can be omitted.',
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-type-arguments',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -103,22 +119,6 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow type arguments that are equal to the default',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      unnecessaryTypeParameter:
-        'This is the default value for this type parameter, so it can be omitted.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-type-arguments',
 });
 
 function getTypeParametersFromNode(
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index 6a91baf9336b..a1878d9d913d 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -26,6 +26,39 @@ type Options = [
 type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{}],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow type assertions that do not change the type of an expression',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      contextuallyUnnecessary:
+        'This assertion is unnecessary since the receiver accepts the original type of the expression.',
+      unnecessaryAssertion:
+        'This assertion is unnecessary since it does not change the type of the expression.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          typesToIgnore: {
+            type: 'array',
+            description: 'A list of type names to ignore.',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-unnecessary-type-assertion',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -352,37 +385,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{}],
-  meta: {
-    docs: {
-      description:
-        'Disallow type assertions that do not change the type of an expression',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      contextuallyUnnecessary:
-        'This assertion is unnecessary since the receiver accepts the original type of the expression.',
-      unnecessaryAssertion:
-        'This assertion is unnecessary since it does not change the type of the expression.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          typesToIgnore: {
-            description: 'A list of type names to ignore.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-type-assertion',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index 9c5b8ef6a7ef..1894bd644832 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -14,6 +14,23 @@ type TypeParameterWithConstraint = MakeRequired<
 >;
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unnecessary constraints on generic types',
+      recommended: 'recommended',
+    },
+    hasSuggestions: true,
+    messages: {
+      removeUnnecessaryConstraint:
+        'Remove the unnecessary `{{constraint}}` constraint.',
+      unnecessaryConstraint:
+        'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-type-constraint',
   create(context) {
     // In theory, we could use the type checker for more advanced constraint types...
     // ...but in practice, these types are rare, and likely not worth requiring type info.
@@ -98,21 +115,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary constraints on generic types',
-      recommended: 'recommended',
-    },
-    hasSuggestions: true,
-    messages: {
-      removeUnnecessaryConstraint:
-        'Remove the unnecessary `{{constraint}}` constraint.',
-      unnecessaryConstraint:
-        'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unnecessary-type-constraint',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index 809b263d3428..7c8294832ea5 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -15,6 +15,20 @@ type NodeWithTypeParameters = MakeRequired<
 >;
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Disallow type parameters that aren't used multiple times",
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
+    },
+    schema: [],
+  },
+  name: 'no-unnecessary-type-parameters',
   create(context) {
     const parserServices = getParserServices(context);
 
@@ -86,20 +100,6 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow type parameters that aren't used multiple times",
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unnecessary-type-parameters',
 });
 
 function isTypeParameterRepeatedInAST(
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index 57bc5984f96e..49645b0a3b7f 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -73,9 +73,9 @@ class FunctionSignature {
         // is a rest param
         if (checker.isArrayType(type)) {
           restType = {
+            type: checker.getTypeArguments(type)[0],
             index: i,
             kind: RestTypeKind.Array,
-            type: checker.getTypeArguments(type)[0],
           };
         } else if (checker.isTupleType(type)) {
           restType = {
@@ -85,9 +85,9 @@ class FunctionSignature {
           };
         } else {
           restType = {
+            type,
             index: i,
             kind: RestTypeKind.Other,
-            type,
           };
         }
         break;
@@ -141,6 +141,25 @@ class FunctionSignature {
 }
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow calling a function with a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeArgument:
+        'Unsafe argument of type `{{sender}}` assigned to a parameter of type `{{receiver}}`.',
+      unsafeArraySpread: 'Unsafe spread of an `any` array type.',
+      unsafeSpread: 'Unsafe spread of an `any` type.',
+      unsafeTupleSpread:
+        'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-argument',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -273,23 +292,4 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow calling a function with a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeArgument:
-        'Unsafe argument of type `{{sender}}` assigned to a parameter of type `{{receiver}}`.',
-      unsafeArraySpread: 'Unsafe spread of an `any` array type.',
-      unsafeSpread: 'Unsafe spread of an `any` type.',
-      unsafeTupleSpread:
-        'Unsafe spread of a tuple type. The argument is of type `{{sender}}` and is assigned to a parameter of type `{{receiver}}`.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-argument',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 3caa4c1cd4bf..323322e301a4 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -28,6 +28,32 @@ const enum ComparisonType {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow assigning a value with type `any` to variables and properties',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      anyAssignment: 'Unsafe assignment of an {{sender}} value.',
+      anyAssignmentThis: [
+        'Unsafe assignment of an {{sender}} value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+      unsafeArrayPattern:
+        'Unsafe array destructuring of an {{sender}} array value.',
+      unsafeArrayPatternFromTuple:
+        'Unsafe array destructuring of a tuple element with an {{sender}} value.',
+      unsafeArraySpread: 'Unsafe spread of an {{sender}} value in an array.',
+      unsafeAssignment:
+        'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-assignment',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -403,30 +429,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow assigning a value with type `any` to variables and properties',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      anyAssignment: 'Unsafe assignment of an {{sender}} value.',
-      anyAssignmentThis: [
-        'Unsafe assignment of an {{sender}} value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeArrayPattern:
-        'Unsafe array destructuring of an {{sender}} array value.',
-      unsafeArrayPatternFromTuple:
-        'Unsafe array destructuring of a tuple element with an {{sender}} value.',
-      unsafeArraySpread: 'Unsafe spread of an {{sender}} value in an array.',
-      unsafeAssignment:
-        'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-assignment',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index bf661c03d7d3..7eeda11863f9 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -17,6 +17,26 @@ type MessageIds =
   | 'unsafeTemplateTag';
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow calling a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeCall: 'Unsafe call of an {{type}} typed value.',
+      unsafeCallThis: [
+        'Unsafe call of an `any` typed value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+      unsafeNew: 'Unsafe construction of an any type value.',
+      unsafeTemplateTag: 'Unsafe any typed template tag.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-call',
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
@@ -72,24 +92,4 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow calling a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeCall: 'Unsafe call of an {{type}} typed value.',
-      unsafeCallThis: [
-        'Unsafe call of an `any` typed value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-      unsafeNew: 'Unsafe construction of an any type value.',
-      unsafeTemplateTag: 'Unsafe any typed template tag.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-call',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index 9b698b2ace71..b404d09f3293 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -6,6 +6,21 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow unsafe declaration merging',
+      recommended: 'recommended',
+      requiresTypeChecking: false,
+    },
+    messages: {
+      unsafeMerging:
+        'Unsafe declaration merging between classes and interfaces.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-declaration-merging',
   create(context) {
     function checkUnsafeDeclaration(
       scope: Scope,
@@ -56,19 +71,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow unsafe declaration merging',
-      recommended: 'recommended',
-      requiresTypeChecking: false,
-    },
-    messages: {
-      unsafeMerging:
-        'Unsafe declaration merging between classes and interfaces.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-declaration-merging',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index eb1045559fa0..775e533c84ff 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -56,6 +56,25 @@ function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow comparing an enum value with a non-enum value',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      mismatchedCase:
+        'The case statement does not have a shared enum type with the switch predicate.',
+      mismatchedCondition:
+        'The two values in this comparison do not have a shared enum type.',
+      replaceValueWithEnum: 'Replace with an enum value comparison.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-enum-comparison',
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
@@ -186,23 +205,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow comparing an enum value with a non-enum value',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      mismatchedCase:
-        'The case statement does not have a shared enum type with the switch predicate.',
-      mismatchedCondition:
-        'The two values in this comparison do not have a shared enum type.',
-      replaceValueWithEnum: 'Replace with an enum value comparison.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-unsafe-enum-comparison',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index 53ae131c1016..b42a685fb3ea 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -5,6 +5,23 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isReferenceToGlobalFunction } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow using the unsafe built-in Function type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      bannedFunctionType: [
+        'The `Function` type accepts any function-like value.',
+        'Prefer explicitly defining any function parameters and return type.',
+      ].join('\n'),
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-function-type',
   create(context) {
     function checkBannedTypes(node: TSESTree.Node): void {
       if (
@@ -31,21 +48,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow using the unsafe built-in Function type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      bannedFunctionType: [
-        'The `Function` type accepts any function-like value.',
-        'Prefer explicitly defining any function parameters and return type.',
-      ].join('\n'),
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 1d789d949925..18c2b844a08f 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -23,6 +23,27 @@ function createDataType(type: ts.Type): '`any`' | '`error` typed' {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow member access on a value with type `any`',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeComputedMemberAccess:
+        'Computed name {{property}} resolves to an {{type}} value.',
+      unsafeMemberExpression:
+        'Unsafe member access {{property}} on an {{type}} value.',
+      unsafeThisMemberExpression: [
+        'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-member-access',
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
@@ -75,8 +96,8 @@ export default createRule({
 
         context.report({
           data: {
-            property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
             type: createDataType(type),
+            property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
           },
           messageId,
           node: node.property,
@@ -111,8 +132,8 @@ export default createRule({
           const propertyName = context.sourceCode.getText(node);
           context.report({
             data: {
-              property: `[${propertyName}]`,
               type: createDataType(type),
+              property: `[${propertyName}]`,
             },
             messageId: 'unsafeComputedMemberAccess',
             node,
@@ -121,25 +142,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow member access on a value with type `any`',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeComputedMemberAccess:
-        'Computed name {{property}} resolves to an {{type}} value.',
-      unsafeMemberExpression:
-        'Unsafe member access {{property}} on an {{type}} value.',
-      unsafeThisMemberExpression: [
-        'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-member-access',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index 5bda8442c7c5..ac8ba136d531 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -20,6 +20,26 @@ import {
 } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow returning a value with type `any` from a function',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unsafeReturn: 'Unsafe return of a value of type {{type}}.',
+      unsafeReturnAssignment:
+        'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.',
+      unsafeReturnThis: [
+        'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.',
+        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+      ].join('\n'),
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-return',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -224,24 +244,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow returning a value with type `any` from a function',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unsafeReturn: 'Unsafe return of a value of type {{type}}.',
-      unsafeReturnAssignment:
-        'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.',
-      unsafeReturnThis: [
-        'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.',
-        'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
-      ].join('\n'),
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-return',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index 2619ea4ec52b..883636b52d68 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -7,6 +7,21 @@ type Options = [];
 type MessageIds = 'unaryMinus';
 
 export default util.createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require unary negation to take a number',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unaryMinus:
+        'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
+    },
+    schema: [],
+  },
+  name: 'no-unsafe-unary-minus',
   create(context) {
     return {
       UnaryExpression(node): void {
@@ -42,19 +57,4 @@ export default util.createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Require unary negation to take a number',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unaryMinus:
-        'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-unsafe-unary-minus',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-expressions.ts b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
index 8f832ca5a780..b812a792ebb4 100644
--- a/packages/eslint-plugin/src/rules/no-unused-expressions.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
@@ -14,6 +14,25 @@ type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 type Options = InferOptionsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowShortCircuit: false,
+      allowTaggedTemplates: false,
+      allowTernary: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unused expressions',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'no-unused-expressions',
   create(context, [{ allowShortCircuit = false, allowTernary = false }]) {
     const rules = baseRule.create(context);
 
@@ -60,23 +79,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowShortCircuit: false,
-      allowTaggedTemplates: false,
-      allowTernary: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow unused expressions',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'suggestion',
-  },
-  name: 'no-unused-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index 28feecb5f887..df65fa04ba92 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -59,6 +59,72 @@ type VariableType =
   | 'variable';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{}],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow unused variables',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+    },
+    messages: {
+      unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
+      usedIgnoredVar:
+        "'{{varName}}' is marked as ignored but is used{{additional}}.",
+      usedOnlyAsType:
+        "'{{varName}}' is {{action}} but only used as a type{{additional}}.",
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            type: 'string',
+            enum: ['all', 'local'],
+          },
+          {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              args: {
+                type: 'string',
+                enum: ['all', 'after-used', 'none'],
+              },
+              argsIgnorePattern: {
+                type: 'string',
+              },
+              caughtErrors: {
+                type: 'string',
+                enum: ['all', 'none'],
+              },
+              caughtErrorsIgnorePattern: {
+                type: 'string',
+              },
+              destructuredArrayIgnorePattern: {
+                type: 'string',
+              },
+              ignoreClassWithStaticInitBlock: {
+                type: 'boolean',
+              },
+              ignoreRestSiblings: {
+                type: 'boolean',
+              },
+              reportUsedIgnorePattern: {
+                type: 'boolean',
+              },
+              vars: {
+                type: 'string',
+                enum: ['all', 'local'],
+              },
+              varsIgnorePattern: {
+                type: 'string',
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+  name: 'no-unused-vars',
   create(context, [firstOption]) {
     const MODULE_DECL_CACHE = new Map<TSESTree.TSModuleDeclaration, boolean>();
 
@@ -682,72 +748,6 @@ export default createRule<Options, MessageIds>({
       visitor.visit(node);
     }
   },
-  defaultOptions: [{}],
-  meta: {
-    docs: {
-      description: 'Disallow unused variables',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-    },
-    messages: {
-      unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
-      usedIgnoredVar:
-        "'{{varName}}' is marked as ignored but is used{{additional}}.",
-      usedOnlyAsType:
-        "'{{varName}}' is {{action}} but only used as a type{{additional}}.",
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            enum: ['all', 'local'],
-            type: 'string',
-          },
-          {
-            additionalProperties: false,
-            properties: {
-              args: {
-                enum: ['all', 'after-used', 'none'],
-                type: 'string',
-              },
-              argsIgnorePattern: {
-                type: 'string',
-              },
-              caughtErrors: {
-                enum: ['all', 'none'],
-                type: 'string',
-              },
-              caughtErrorsIgnorePattern: {
-                type: 'string',
-              },
-              destructuredArrayIgnorePattern: {
-                type: 'string',
-              },
-              ignoreClassWithStaticInitBlock: {
-                type: 'boolean',
-              },
-              ignoreRestSiblings: {
-                type: 'boolean',
-              },
-              reportUsedIgnorePattern: {
-                type: 'boolean',
-              },
-              vars: {
-                enum: ['all', 'local'],
-                type: 'string',
-              },
-              varsIgnorePattern: {
-                type: 'string',
-              },
-            },
-            type: 'object',
-          },
-        ],
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-unused-vars',
 });
 
 /*
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index cd60bb1e708f..ef87fcf3b088 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -216,6 +216,51 @@ type Options = ['nofunc' | Config];
 type MessageIds = 'noUseBeforeDefine';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowNamedExports: false,
+      classes: true,
+      enums: true,
+      functions: true,
+      ignoreTypeReferences: true,
+      typedefs: true,
+      variables: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow the use of variables before they are defined',
+      extendsBaseRule: true,
+    },
+    messages: {
+      noUseBeforeDefine: "'{{name}}' was used before it was defined.",
+    },
+    schema: [
+      {
+        oneOf: [
+          {
+            type: 'string',
+            enum: ['nofunc'],
+          },
+          {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              allowNamedExports: { type: 'boolean' },
+              classes: { type: 'boolean' },
+              enums: { type: 'boolean' },
+              functions: { type: 'boolean' },
+              ignoreTypeReferences: { type: 'boolean' },
+              typedefs: { type: 'boolean' },
+              variables: { type: 'boolean' },
+            },
+          },
+        ],
+      },
+    ],
+  },
+  name: 'no-use-before-define',
   create(context, optionsWithDefault) {
     const options = parseOptions(optionsWithDefault[0]);
 
@@ -321,49 +366,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowNamedExports: false,
-      classes: true,
-      enums: true,
-      functions: true,
-      ignoreTypeReferences: true,
-      typedefs: true,
-      variables: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow the use of variables before they are defined',
-      extendsBaseRule: true,
-    },
-    messages: {
-      noUseBeforeDefine: "'{{name}}' was used before it was defined.",
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            enum: ['nofunc'],
-            type: 'string',
-          },
-          {
-            additionalProperties: false,
-            properties: {
-              allowNamedExports: { type: 'boolean' },
-              classes: { type: 'boolean' },
-              enums: { type: 'boolean' },
-              functions: { type: 'boolean' },
-              ignoreTypeReferences: { type: 'boolean' },
-              typedefs: { type: 'boolean' },
-              variables: { type: 'boolean' },
-            },
-            type: 'object',
-          },
-        ],
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-use-before-define',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index 39a28c1e8fa0..eb016a7f0e16 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -44,6 +44,19 @@ function checkParams(node: TSESTree.MethodDefinition): boolean {
 }
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow unnecessary constructors',
+      extendsBaseRule: true,
+      recommended: 'strict',
+    },
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema: baseRule.meta.schema,
+  },
+  name: 'no-useless-constructor',
   create(context) {
     const rules = baseRule.create(context);
     return {
@@ -58,17 +71,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow unnecessary constructors',
-      extendsBaseRule: true,
-      recommended: 'strict',
-    },
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema: baseRule.meta.schema,
-    type: 'problem',
-  },
-  name: 'no-useless-constructor',
 });
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index 32befd651a19..6ece19fe5865 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -25,6 +25,21 @@ const exportOrImportNodeTypes = new Set([
 ]);
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Disallow empty exports that don't change anything in a module file",
+    },
+    fixable: 'code',
+    hasSuggestions: false,
+    messages: {
+      uselessExport: 'Empty export does nothing and can be removed.',
+    },
+    schema: [],
+  },
+  name: 'no-useless-empty-export',
   create(context) {
     // In a definition file, export {} is necessary to make the module properly
     // encapsulated, even when there are other exports
@@ -66,19 +81,4 @@ export default createRule({
       TSModuleDeclaration: checkNode,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        "Disallow empty exports that don't change anything in a module file",
-    },
-    fixable: 'code',
-    hasSuggestions: false,
-    messages: {
-      uselessExport: 'Empty export does nothing and can be removed.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'no-useless-empty-export',
 });
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index c13c95350c1a..94aaa396a1ca 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -12,6 +12,32 @@ type Options = [
 type MessageIds = 'noVarReqs';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ allow: [] }],
+  meta: {
+    type: 'problem',
+    deprecated: true,
+    docs: {
+      description: 'Disallow `require` statements except in import statements',
+    },
+    messages: {
+      noVarReqs: 'Require statement not part of import statement.',
+    },
+    replacedBy: ['@typescript-eslint/no-require-imports'],
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allow: {
+            type: 'array',
+            description: 'Patterns of import paths to allow requiring from.',
+            items: { type: 'string' },
+          },
+        },
+      },
+    ],
+  },
+  name: 'no-var-requires',
   create(context, options) {
     const allowPatterns = options[0].allow.map(
       pattern => new RegExp(pattern, 'u'),
@@ -68,30 +94,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ allow: [] }],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: 'Disallow `require` statements except in import statements',
-    },
-    messages: {
-      noVarReqs: 'Require statement not part of import statement.',
-    },
-    replacedBy: ['@typescript-eslint/no-require-imports'],
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allow: {
-            description: 'Patterns of import paths to allow requiring from.',
-            items: { type: 'string' },
-            type: 'array',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'no-var-requires',
 });
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index 433684819dfc..d29dbb5b66fc 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -16,6 +16,21 @@ const classNames = new Set([
 ]);
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow using confusing built-in primitive class wrappers',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      bannedClassType:
+        'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
+    },
+    schema: [],
+  },
+  name: 'no-wrapper-object-types',
   create(context) {
     function checkBannedTypes(
       node: TSESTree.EntityName | TSESTree.Expression,
@@ -54,19 +69,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Disallow using confusing built-in primitive class wrappers',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      bannedClassType:
-        'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'no-wrapper-object-types',
 });
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index f63b3a9c78fa..1a8fb6074205 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -12,6 +12,22 @@ import {
 } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce non-null assertions over explicit type casts',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferNonNullAssertion:
+        'Use a ! assertion to more succinctly remove null and undefined from the type.',
+    },
+    schema: [],
+  },
+  name: 'non-nullable-type-assertion-style',
   create(context) {
     const services = getParserServices(context);
 
@@ -128,20 +144,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Enforce non-null assertions over explicit type casts',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferNonNullAssertion:
-        'Use a ! assertion to more succinctly remove null and undefined from the type.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'non-nullable-type-assertion-style',
 });
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index 2c48b9d2d3db..0b17104815e0 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -21,6 +21,40 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowThrowingAny: true,
+      allowThrowingUnknown: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow throwing non-`Error` values as exceptions',
+      extendsBaseRule: 'no-throw-literal',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      object: 'Expected an error object to be thrown.',
+      undef: 'Do not throw undefined.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowThrowingAny: {
+            type: 'boolean',
+          },
+          allowThrowingUnknown: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'only-throw-error',
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -62,38 +96,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowThrowingAny: true,
-      allowThrowingUnknown: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow throwing non-`Error` values as exceptions',
-      extendsBaseRule: 'no-throw-literal',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      object: 'Expected an error object to be thrown.',
-      undef: 'Do not throw undefined.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowThrowingAny: {
-            type: 'boolean',
-          },
-          allowThrowingUnknown: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'only-throw-error',
 });
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index 4ebdd23264b6..34486e292334 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -25,6 +25,58 @@ type Options = [
 type MessageIds = 'preferClassProperty' | 'preferParameterProperty';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allow: [],
+      prefer: 'class-property',
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require or disallow parameter properties in class constructors',
+    },
+    messages: {
+      preferClassProperty:
+        'Property {{parameter}} should be declared as a class property.',
+      preferParameterProperty:
+        'Property {{parameter}} should be declared as a parameter property.',
+    },
+    schema: [
+      {
+        type: 'object',
+        $defs: {
+          modifier: {
+            type: 'string',
+            enum: [
+              'readonly',
+              'private',
+              'protected',
+              'public',
+              'private readonly',
+              'protected readonly',
+              'public readonly',
+            ],
+          },
+        },
+        additionalProperties: false,
+        properties: {
+          allow: {
+            type: 'array',
+            items: {
+              $ref: '#/items/0/$defs/modifier',
+            },
+          },
+          prefer: {
+            type: 'string',
+            enum: ['class-property', 'parameter-property'],
+          },
+        },
+      },
+    ],
+  },
+  name: 'parameter-properties',
   create(context, [{ allow = [], prefer = 'class-property' }]) {
     /**
      * Gets the modifiers of `node`.
@@ -193,56 +245,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allow: [],
-      prefer: 'class-property',
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require or disallow parameter properties in class constructors',
-    },
-    messages: {
-      preferClassProperty:
-        'Property {{parameter}} should be declared as a class property.',
-      preferParameterProperty:
-        'Property {{parameter}} should be declared as a parameter property.',
-    },
-    schema: [
-      {
-        $defs: {
-          modifier: {
-            enum: [
-              'readonly',
-              'private',
-              'protected',
-              'public',
-              'private readonly',
-              'protected readonly',
-              'public readonly',
-            ],
-            type: 'string',
-          },
-        },
-        additionalProperties: false,
-        properties: {
-          allow: {
-            items: {
-              $ref: '#/items/0/$defs/modifier',
-            },
-            type: 'array',
-          },
-          prefer: {
-            enum: ['class-property', 'parameter-property'],
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'parameter-properties',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index 54841bf69c4f..70d0bb6b51d2 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -5,6 +5,25 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce the use of `as const` over literal type',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      preferConstAssertion:
+        'Expected a `const` instead of a literal type assertion.',
+      variableConstAssertion:
+        'Expected a `const` assertion instead of a literal type annotation.',
+      variableSuggest: 'You should use `as const` instead of type annotation.',
+    },
+    schema: [],
+  },
+  name: 'prefer-as-const',
   create(context) {
     function compareTypes(
       valueNode: TSESTree.Expression,
@@ -60,23 +79,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: 'Enforce the use of `as const` over literal type',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      preferConstAssertion:
-        'Expected a `const` instead of a literal type assertion.',
-      variableConstAssertion:
-        'Expected a `const` assertion instead of a literal type annotation.',
-      variableSuggest: 'You should use `as const` instead of type annotation.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-as-const',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index dcfa10eb8ab3..a5bfcbae48d5 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -24,6 +24,7 @@ type Options = [BaseOptions[0], EnforcementOptions];
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 const destructuringTypeConfig: JSONSchema4 = {
+  type: 'object',
   additionalProperties: false,
   properties: {
     array: {
@@ -33,24 +34,24 @@ const destructuringTypeConfig: JSONSchema4 = {
       type: 'boolean',
     },
   },
-  type: 'object',
 };
 
 const schema: readonly JSONSchema4[] = [
   {
     oneOf: [
       {
+        type: 'object',
         additionalProperties: false,
         properties: {
           AssignmentExpression: destructuringTypeConfig,
           VariableDeclarator: destructuringTypeConfig,
         },
-        type: 'object',
       },
       destructuringTypeConfig,
     ],
   },
   {
+    type: 'object',
     properties: {
       enforceForDeclarationWithTypeAnnotation: {
         type: 'boolean',
@@ -59,11 +60,36 @@ const schema: readonly JSONSchema4[] = [
         type: 'boolean',
       },
     },
-    type: 'object',
   },
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      AssignmentExpression: {
+        array: true,
+        object: true,
+      },
+      VariableDeclarator: {
+        array: true,
+        object: true,
+      },
+    },
+    {},
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require destructuring from arrays and/or objects',
+      extendsBaseRule: true,
+      requiresTypeChecking: true,
+    },
+    fixable: baseRule.meta.fixable,
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema,
+  },
+  name: 'prefer-destructuring',
   create(context, [enabledTypes, options]) {
     const {
       enforceForDeclarationWithTypeAnnotation = false,
@@ -155,32 +181,6 @@ export default createRule<Options, MessageIds>({
       return baseRulesWithoutFixCache;
     }
   },
-  defaultOptions: [
-    {
-      AssignmentExpression: {
-        array: true,
-        object: true,
-      },
-      VariableDeclarator: {
-        array: true,
-        object: true,
-      },
-    },
-    {},
-  ],
-  meta: {
-    docs: {
-      description: 'Require destructuring from arrays and/or objects',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    fixable: baseRule.meta.fixable,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema,
-    type: 'suggestion',
-  },
-  name: 'prefer-destructuring',
 });
 
 type Context = TSESLint.RuleContext<MessageIds, Options>;
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index 14fac17fa4a7..e308f5974cc2 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -5,6 +5,23 @@ import { createRule } from '../util';
 type MessageIds = 'defineInitializer' | 'defineInitializerSuggestion';
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require each enum member value to be explicitly initialized',
+    },
+    hasSuggestions: true,
+    messages: {
+      defineInitializer:
+        "The value of the member '{{ name }}' should be explicitly defined.",
+      defineInitializerSuggestion:
+        'Can be fixed to {{ name }} = {{ suggested }}',
+    },
+    schema: [],
+  },
+  name: 'prefer-enum-initializers',
   create(context) {
     function TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
       const { members } = node.body;
@@ -50,21 +67,4 @@ export default createRule<[], MessageIds>({
       TSEnumDeclaration,
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Require each enum member value to be explicitly initialized',
-    },
-    hasSuggestions: true,
-    messages: {
-      defineInitializer:
-        "The value of the member '{{ name }}' should be explicitly defined.",
-      defineInitializerSuggestion:
-        'Can be fixed to {{ name }} = {{ suggested }}',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-enum-initializers',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index 1795d966cda5..91eb0dc76a11 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -14,6 +14,24 @@ import {
 } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      preferFind: 'Prefer .find(...) instead of .filter(...)[0].',
+      preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
+    },
+    schema: [],
+  },
+
+  name: 'prefer-find',
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
@@ -302,24 +320,6 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-
-  meta: {
-    docs: {
-      description:
-        'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      preferFind: 'Prefer .find(...) instead of .filter(...)[0].',
-      preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-find',
 });
 
 /**
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index 2f76b4f09328..28a03756c514 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -5,6 +5,21 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isAssignee } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce the use of `for-of` loop over the standard `for` loop where possible',
+      recommended: 'stylistic',
+    },
+    messages: {
+      preferForOf:
+        'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
+    },
+    schema: [],
+  },
+  name: 'prefer-for-of',
   create(context) {
     function isSingleVariableDeclaration(
       node: TSESTree.Node | null,
@@ -147,19 +162,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Enforce the use of `for-of` loop over the standard `for` loop where possible',
-      recommended: 'stylistic',
-    },
-    messages: {
-      preferForOf:
-        'Expected a `for-of` loop instead of a `for` loop with this simple iteration.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-for-of',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index 04e1bd174db1..40e8c7356ae5 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -10,6 +10,24 @@ export const phrases = {
 } as const;
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce using function types instead of interfaces with call signatures',
+      recommended: 'stylistic',
+    },
+    fixable: 'code',
+    messages: {
+      functionTypeOverCallableType:
+        '{{ literalOrInterface }} only has a call signature, you should use a function type instead.',
+      unexpectedThisOnFunctionOnlyInterface:
+        "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
+    },
+    schema: [],
+  },
+  name: 'prefer-function-type',
   create(context) {
     /**
      * Checks if there the interface has exactly one supertype that isn't named 'Function'
@@ -204,22 +222,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Enforce using function types instead of interfaces with call signatures',
-      recommended: 'stylistic',
-    },
-    fixable: 'code',
-    messages: {
-      functionTypeOverCallableType:
-        '{{ literalOrInterface }} only has a call signature, you should use a function type instead.',
-      unexpectedThisOnFunctionOnlyInterface:
-        "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `<Self>(this: Self, ...) => Self` instead?",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-function-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index 3c905915bd19..b11f980786d3 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -12,6 +12,24 @@ import {
 } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce `includes` method over `indexOf` method',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferIncludes: "Use 'includes()' method instead.",
+      preferStringIncludes:
+        'Use `String#includes()` method with a string instead.',
+    },
+    schema: [],
+  },
+
+  name: 'prefer-includes',
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
@@ -247,22 +265,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-
-  meta: {
-    docs: {
-      description: 'Enforce `includes` method over `indexOf` method',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferIncludes: "Use 'includes()' method instead.",
-      preferStringIncludes:
-        'Use `String#includes()` method with a string instead.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-includes',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index e2ff6be8757c..b65ec116f107 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -5,6 +5,34 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, getStaticStringValue } from '../util';
 
 export default createRule({
+  defaultOptions: [
+    {
+      allowBitwiseExpressions: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require all enum members to be literal values',
+      recommended: 'strict',
+      requiresTypeChecking: false,
+    },
+    messages: {
+      notLiteral: `Explicit enum value must only be a literal value (string, number, boolean, etc).`,
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowBitwiseExpressions: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'prefer-literal-enum-member',
   create(context, [{ allowBitwiseExpressions }]) {
     function isIdentifierWithName(node: TSESTree.Node, name: string): boolean {
       return node.type === AST_NODE_TYPES.Identifier && node.name === name;
@@ -121,32 +149,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowBitwiseExpressions: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Require all enum members to be literal values',
-      recommended: 'strict',
-      requiresTypeChecking: false,
-    },
-    messages: {
-      notLiteral: `Explicit enum value must only be a literal value (string, number, boolean, etc).`,
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowBitwiseExpressions: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-literal-enum-member',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index 5d20247caf5b..88c3e179537b 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -3,6 +3,22 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
+      recommended: 'recommended',
+    },
+    fixable: 'code',
+    messages: {
+      useNamespace:
+        "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
+    },
+    schema: [],
+  },
+  name: 'prefer-namespace-keyword',
   create(context) {
     return {
       TSModuleDeclaration(node): void {
@@ -29,20 +45,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules',
-      recommended: 'recommended',
-    },
-    fixable: 'code',
-    messages: {
-      useNamespace:
-        "Use 'namespace' instead of 'module' to declare custom TypeScript modules.",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-namespace-keyword',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 360e09f3b7a7..71b99e0d5e87 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -42,6 +42,77 @@ export type MessageIds =
   | 'suggestNullish';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      ignoreConditionalTests: true,
+      ignoreMixedLogicalExpressions: false,
+      ignorePrimitives: {
+        bigint: false,
+        boolean: false,
+        number: false,
+        string: false,
+      },
+      ignoreTernaryTests: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+      preferNullishOverOr:
+        'Prefer using nullish coalescing operator (`??`) instead of a logical or (`||`), as it is a safer operator.',
+      preferNullishOverTernary:
+        'Prefer using nullish coalescing operator (`??`) instead of a ternary expression, as it is simpler to read.',
+      suggestNullish: 'Fix to nullish coalescing operator (`??`).',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+          },
+          ignoreConditionalTests: {
+            type: 'boolean',
+          },
+          ignoreMixedLogicalExpressions: {
+            type: 'boolean',
+          },
+          ignorePrimitives: {
+            oneOf: [
+              {
+                type: 'object',
+                properties: {
+                  bigint: { type: 'boolean' },
+                  boolean: { type: 'boolean' },
+                  number: { type: 'boolean' },
+                  string: { type: 'boolean' },
+                },
+              },
+              {
+                type: 'boolean',
+                enum: [true],
+              },
+            ],
+          },
+          ignoreTernaryTests: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'prefer-nullish-coalescing',
   create(
     context,
     [
@@ -317,77 +388,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-      ignoreConditionalTests: true,
-      ignoreMixedLogicalExpressions: false,
-      ignorePrimitives: {
-        bigint: false,
-        boolean: false,
-        number: false,
-        string: false,
-      },
-      ignoreTernaryTests: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Enforce using the nullish coalescing operator instead of logical assignments or chaining',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-      preferNullishOverOr:
-        'Prefer using nullish coalescing operator (`??`) instead of a logical or (`||`), as it is a safer operator.',
-      preferNullishOverTernary:
-        'Prefer using nullish coalescing operator (`??`) instead of a ternary expression, as it is simpler to read.',
-      suggestNullish: 'Fix to nullish coalescing operator (`??`).',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            type: 'boolean',
-          },
-          ignoreConditionalTests: {
-            type: 'boolean',
-          },
-          ignoreMixedLogicalExpressions: {
-            type: 'boolean',
-          },
-          ignorePrimitives: {
-            oneOf: [
-              {
-                properties: {
-                  bigint: { type: 'boolean' },
-                  boolean: { type: 'boolean' },
-                  number: { type: 'boolean' },
-                  string: { type: 'boolean' },
-                },
-                type: 'object',
-              },
-              {
-                enum: [true],
-                type: 'boolean',
-              },
-            ],
-          },
-          ignoreTernaryTests: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-nullish-coalescing',
 });
 
 function isConditionalTest(node: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 8bbae4fe808f..98ea9cc9fc03 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -27,6 +27,83 @@ export default createRule<
   [PreferOptionalChainOptions],
   PreferOptionalChainMessageIds
 >({
+  defaultOptions: [
+    {
+      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+      checkAny: true,
+      checkBigInt: true,
+      checkBoolean: true,
+      checkNumber: true,
+      checkString: true,
+      checkUnknown: true,
+      requireNullish: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      optionalChainSuggest: 'Change to an optional chain.',
+      preferOptionalChain:
+        "Prefer using an optional chain expression instead, as it's more concise and easier to read.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
+            type: 'boolean',
+            description:
+              'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
+          },
+          checkAny: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
+          },
+          checkBigInt: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
+          },
+          checkBoolean: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
+          },
+          checkNumber: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
+          },
+          checkString: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
+          },
+          checkUnknown: {
+            type: 'boolean',
+            description:
+              'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
+          },
+          requireNullish: {
+            type: 'boolean',
+            description:
+              'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'prefer-optional-chain',
   create(context, [options]) {
     const parserServices = getParserServices(context);
 
@@ -143,81 +220,4 @@ export default createRule<
       },
     };
   },
-  defaultOptions: [
-    {
-      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
-      checkAny: true,
-      checkBigInt: true,
-      checkBoolean: true,
-      checkNumber: true,
-      checkString: true,
-      checkUnknown: true,
-      requireNullish: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      optionalChainSuggest: 'Change to an optional chain.',
-      preferOptionalChain:
-        "Prefer using an optional chain expression instead, as it's more concise and easier to read.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: {
-            description:
-              'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.',
-            type: 'boolean',
-          },
-          checkAny: {
-            description:
-              'Check operands that are typed as `any` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          checkBigInt: {
-            description:
-              'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          checkBoolean: {
-            description:
-              'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          checkNumber: {
-            description:
-              'Check operands that are typed as `number` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          checkString: {
-            description:
-              'Check operands that are typed as `string` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          checkUnknown: {
-            description:
-              'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-          requireNullish: {
-            description:
-              'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-optional-chain',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index 6feb3eaea2f8..278ce840492c 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -22,6 +22,35 @@ export type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowEmptyReject: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require using Error objects as Promise rejection reasons',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      rejectAnError: 'Expected the Promise rejection reason to be an Error.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowEmptyReject: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'prefer-promise-reject-errors',
   create(context, [options]) {
     const services = getParserServices(context);
 
@@ -122,33 +151,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowEmptyReject: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Require using Error objects as Promise rejection reasons',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      rejectAnError: 'Expected the Promise rejection reason to be an Error.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowEmptyReject: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-promise-reject-errors',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index 8909a250d1b4..f024edfd41cc 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -23,6 +23,44 @@ type Options = [
 type MessageIds = 'shouldBeReadonly';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allow: readonlynessOptionsDefaults.allow,
+      checkParameterProperties: true,
+      ignoreInferredTypes: false,
+      treatMethodsAsReadonly:
+        readonlynessOptionsDefaults.treatMethodsAsReadonly,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      shouldBeReadonly: 'Parameter should be a read only type.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allow: readonlynessOptionsSchema.properties.allow,
+          checkParameterProperties: {
+            type: 'boolean',
+          },
+          ignoreInferredTypes: {
+            type: 'boolean',
+          },
+          treatMethodsAsReadonly:
+            readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
+        },
+      },
+    ],
+  },
+  name: 'prefer-readonly-parameter-types',
   create(
     context,
     [
@@ -92,42 +130,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allow: readonlynessOptionsDefaults.allow,
-      checkParameterProperties: true,
-      ignoreInferredTypes: false,
-      treatMethodsAsReadonly:
-        readonlynessOptionsDefaults.treatMethodsAsReadonly,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      shouldBeReadonly: 'Parameter should be a read only type.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allow: readonlynessOptionsSchema.properties.allow,
-          checkParameterProperties: {
-            type: 'boolean',
-          },
-          ignoreInferredTypes: {
-            type: 'boolean',
-          },
-          treatMethodsAsReadonly:
-            readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-readonly-parameter-types',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index b347e0563b4d..f2a07d80bbb2 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -30,6 +30,32 @@ const functionScopeBoundaries = [
 ].join(', ');
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ onlyInlineLambdas: false }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferReadonly:
+        "Member '{{name}}' is never reassigned; mark it as `readonly`.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          onlyInlineLambdas: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'prefer-readonly',
   create(context, [{ onlyInlineLambdas }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -240,32 +266,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ onlyInlineLambdas: false }],
-  meta: {
-    docs: {
-      description:
-        "Require private members to be marked as `readonly` if they're never modified outside of the constructor",
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferReadonly:
-        "Member '{{name}}' is never reassigned; mark it as `readonly`.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          onlyInlineLambdas: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-readonly',
 });
 
 type ParameterOrPropertyDeclaration =
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 58e2ec5e384c..6796d02bd412 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -33,6 +33,23 @@ const getMemberExpressionName = (
 };
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce using type parameter when calling `Array#reduce` instead of casting',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferTypeParameter:
+        'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
+    },
+    schema: [],
+  },
+  name: 'prefer-reduce-type-parameter',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -102,21 +119,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Enforce using type parameter when calling `Array#reduce` instead of casting',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferTypeParameter:
-        'Unnecessary cast: Array#reduce accepts a type parameter for the default value.',
-    },
-    schema: [],
-    type: 'problem',
-  },
-  name: 'prefer-reduce-type-parameter',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index 73c95321cd26..3370712ef23d 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -22,6 +22,23 @@ enum ArgumentType {
 }
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
+    },
+    schema: [],
+  },
+
+  name: 'prefer-regexp-exec',
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
@@ -162,21 +179,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-
-  meta: {
-    docs: {
-      description:
-        'Enforce `RegExp#exec` over `String#match` if no global flag is provided',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-regexp-exec',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 3d7b95137b6f..47b2e4028e60 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -14,6 +14,23 @@ type FunctionLike =
   | TSESTree.MethodDefinition['value'];
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce that `this` is used when only `this` type is returned',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      useThisType: 'Use `this` type instead.',
+    },
+    schema: [],
+  },
+
+  name: 'prefer-return-this-type',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -150,21 +167,4 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-
-  meta: {
-    docs: {
-      description:
-        'Enforce that `this` is used when only `this` type is returned',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      useThisType: 'Use `this` type instead.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'prefer-return-this-type',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index 7c6d6c131f93..e8646408b4eb 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -28,6 +28,37 @@ export type Options = [
 type MessageIds = 'preferEndsWith' | 'preferStartsWith';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [{ allowSingleElementEquality: 'never' }],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
+      recommended: 'stylistic',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      preferEndsWith: "Use the 'String#endsWith' method instead.",
+      preferStartsWith: "Use 'String#startsWith' method instead.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowSingleElementEquality: {
+            type: 'string',
+            description:
+              'Whether to allow equality checks against the first or last element of a string.',
+            enum: ['always', 'never'],
+          },
+        },
+      },
+    ],
+  },
+
+  name: 'prefer-string-starts-ends-with',
   create(context, [{ allowSingleElementEquality }]) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
 
@@ -695,35 +726,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [{ allowSingleElementEquality: 'never' }],
-
-  meta: {
-    docs: {
-      description:
-        'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings',
-      recommended: 'stylistic',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      preferEndsWith: "Use the 'String#endsWith' method instead.",
-      preferStartsWith: "Use 'String#startsWith' method instead.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowSingleElementEquality: {
-            description:
-              'Whether to allow equality checks against the first or last element of a string.',
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'prefer-string-starts-ends-with',
 });
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 836719a2b725..2b165c237d83 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -8,6 +8,22 @@ import { createRule } from '../util';
 type MessageIds = 'preferExpectErrorComment';
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'problem',
+    deprecated: true,
+    docs: {
+      description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
+    },
+    fixable: 'code',
+    messages: {
+      preferExpectErrorComment:
+        'Use "@ts-expect-error" to ensure an error is actually being suppressed.',
+    },
+    replacedBy: ['@typescript-eslint/ban-ts-comment'],
+    schema: [],
+  },
+  name: 'prefer-ts-expect-error',
   create(context) {
     const tsIgnoreRegExpSingleLine = /^\s*\/?\s*@ts-ignore/;
     const tsIgnoreRegExpMultiLine = /^\s*(?:\/|\*)*\s*@ts-ignore/;
@@ -65,20 +81,4 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    deprecated: true,
-    docs: {
-      description: 'Enforce using `@ts-expect-error` over `@ts-ignore`',
-    },
-    fixable: 'code',
-    messages: {
-      preferExpectErrorComment:
-        'Use "@ts-expect-error" to ensure an error is actually being suppressed.',
-    },
-    replacedBy: ['@typescript-eslint/ban-ts-comment'],
-    schema: [],
-    type: 'problem',
-  },
-  name: 'prefer-ts-expect-error',
 });
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index 8642d77063e7..4be4f2344f0d 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -26,6 +26,62 @@ type Options = [
 type MessageIds = 'missingAsync';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowedPromiseNames: [],
+      checkArrowFunctions: true,
+      checkFunctionDeclarations: true,
+      checkFunctionExpressions: true,
+      checkMethodDeclarations: true,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require any function or method that returns a Promise to be marked async',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      missingAsync: 'Functions that return promises must be async.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowAny: {
+            type: 'boolean',
+            description:
+              'Whether to consider `any` and `unknown` to be Promises.',
+          },
+          allowedPromiseNames: {
+            type: 'array',
+            description:
+              'Any extra names of classes or interfaces to be considered Promises.',
+            items: {
+              type: 'string',
+            },
+          },
+          checkArrowFunctions: {
+            type: 'boolean',
+          },
+          checkFunctionDeclarations: {
+            type: 'boolean',
+          },
+          checkFunctionExpressions: {
+            type: 'boolean',
+          },
+          checkMethodDeclarations: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  name: 'promise-function-async',
   create(
     context,
     [
@@ -193,60 +249,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowedPromiseNames: [],
-      checkArrowFunctions: true,
-      checkFunctionDeclarations: true,
-      checkFunctionExpressions: true,
-      checkMethodDeclarations: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require any function or method that returns a Promise to be marked async',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    messages: {
-      missingAsync: 'Functions that return promises must be async.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowAny: {
-            description:
-              'Whether to consider `any` and `unknown` to be Promises.',
-            type: 'boolean',
-          },
-          allowedPromiseNames: {
-            description:
-              'Any extra names of classes or interfaces to be considered Promises.',
-            items: {
-              type: 'string',
-            },
-            type: 'array',
-          },
-          checkArrowFunctions: {
-            type: 'boolean',
-          },
-          checkFunctionDeclarations: {
-            type: 'boolean',
-          },
-          checkFunctionExpressions: {
-            type: 'boolean',
-          },
-          checkMethodDeclarations: {
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'promise-function-async',
 });
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index 2c8803525731..60a628a17437 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -16,6 +16,37 @@ export type Options = [
 export type MessageIds = 'requireCompare';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoreStringArrays: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      requireCompare: "Require 'compare' argument.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreStringArrays: {
+            type: 'boolean',
+            description:
+              'Whether to ignore arrays in which all elements are strings.',
+          },
+        },
+      },
+    ],
+  },
+
+  name: 'require-array-sort-compare',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -55,35 +86,4 @@ export default createRule<Options, MessageIds>({
         checkSortArgument,
     };
   },
-  defaultOptions: [
-    {
-      ignoreStringArrays: true,
-    },
-  ],
-
-  meta: {
-    docs: {
-      description:
-        'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      requireCompare: "Require 'compare' argument.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreStringArrays: {
-            description:
-              'Whether to ignore arrays in which all elements are strings.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'require-array-sort-compare',
 });
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index 33af3017a3a4..11ed06d43f33 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -29,6 +29,24 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow async functions which do not return promises and have no `await` expression',
+      extendsBaseRule: true,
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      missingAwait: "{{name}} has no 'await' expression.",
+      removeAsync: "Remove 'async'.",
+    },
+    schema: [],
+  },
+  name: 'require-await',
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -289,24 +307,6 @@ export default createRule({
       },
     };
   },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description:
-        'Disallow async functions which do not return promises and have no `await` expression',
-      extendsBaseRule: true,
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      missingAwait: "{{name}} has no 'await' expression.",
-      removeAsync: "Remove 'async'.",
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'require-await',
 });
 
 function isEmptyFunction(node: FunctionNode): boolean {
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index f60ebde2fce6..e595e15c7d98 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -26,6 +26,79 @@ type Options = [
 type MessageIds = 'bigintAndNumber' | 'invalid' | 'mismatched';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumberAndString: true,
+      allowRegExp: true,
+      skipCompoundAssignments: false,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
+      recommended: {
+        recommended: true,
+        strict: [
+          {
+            allowAny: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumberAndString: false,
+            allowRegExp: false,
+          },
+        ],
+      },
+      requiresTypeChecking: true,
+    },
+    messages: {
+      bigintAndNumber:
+        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
+      invalid:
+        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
+      mismatched:
+        "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowAny: {
+            type: 'boolean',
+            description: 'Whether to allow `any` typed values.',
+          },
+          allowBoolean: {
+            type: 'boolean',
+            description: 'Whether to allow `boolean` typed values.',
+          },
+          allowNullish: {
+            type: 'boolean',
+            description:
+              'Whether to allow potentially `null` or `undefined` typed values.',
+          },
+          allowNumberAndString: {
+            type: 'boolean',
+            description:
+              'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
+          },
+          allowRegExp: {
+            type: 'boolean',
+            description: 'Whether to allow `regexp` typed values.',
+          },
+          skipCompoundAssignments: {
+            type: 'boolean',
+            description: 'Whether to skip compound assignments such as `+=`.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'restrict-plus-operands',
   create(
     context,
     [
@@ -100,8 +173,8 @@ export default createRule<Options, MessageIds>({
         ) {
           context.report({
             data: {
-              stringLike,
               type: typeChecker.typeToString(baseType),
+              stringLike,
             },
             messageId: 'invalid',
             node: baseNode,
@@ -122,8 +195,8 @@ export default createRule<Options, MessageIds>({
           ) {
             context.report({
               data: {
-                stringLike,
                 type: typeChecker.typeToString(subBaseType),
+                stringLike,
               },
               messageId: 'invalid',
               node: baseNode,
@@ -183,79 +256,6 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumberAndString: true,
-      allowRegExp: true,
-      skipCompoundAssignments: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`',
-      recommended: {
-        recommended: true,
-        strict: [
-          {
-            allowAny: false,
-            allowBoolean: false,
-            allowNullish: false,
-            allowNumberAndString: false,
-            allowRegExp: false,
-          },
-        ],
-      },
-      requiresTypeChecking: true,
-    },
-    messages: {
-      bigintAndNumber:
-        "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.",
-      invalid:
-        "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.",
-      mismatched:
-        "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.",
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowAny: {
-            description: 'Whether to allow `any` typed values.',
-            type: 'boolean',
-          },
-          allowBoolean: {
-            description: 'Whether to allow `boolean` typed values.',
-            type: 'boolean',
-          },
-          allowNullish: {
-            description:
-              'Whether to allow potentially `null` or `undefined` typed values.',
-            type: 'boolean',
-          },
-          allowNumberAndString: {
-            description:
-              'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.',
-            type: 'boolean',
-          },
-          allowRegExp: {
-            description: 'Whether to allow `regexp` typed values.',
-            type: 'boolean',
-          },
-          skipCompoundAssignments: {
-            description: 'Whether to skip compound assignments such as `+=`.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'restrict-plus-operands',
 });
 
 function isDeeplyObjectType(type: ts.Type): boolean {
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index c733d4f5b9fc..44a8fd5383e1 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -46,9 +46,9 @@ const optionTesters = (
     ['Never', isTypeNeverType],
   ] satisfies [string, OptionTester][]
 ).map(([type, tester]) => ({
+  type,
   option: `allow${type}` as const,
   tester,
-  type,
 }));
 type Options = [
   { [Type in (typeof optionTesters)[number]['option']]?: boolean },
@@ -57,6 +57,55 @@ type Options = [
 type MessageId = 'invalidType';
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumber: true,
+      allowRegExp: true,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce template literal expressions to be of `string` type',
+      recommended: {
+        recommended: true,
+        strict: [
+          {
+            allowAny: false,
+            allowBoolean: false,
+            allowNever: false,
+            allowNullish: false,
+            allowNumber: false,
+            allowRegExp: false,
+          },
+        ],
+      },
+      requiresTypeChecking: true,
+    },
+    messages: {
+      invalidType: 'Invalid type "{{type}}" of template literal expression.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: Object.fromEntries(
+          optionTesters.map(({ type, option }) => [
+            option,
+            {
+              type: 'boolean',
+              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
+            },
+          ]),
+        ),
+      },
+    ],
+  },
+  name: 'restrict-template-expressions',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -105,53 +154,4 @@ export default createRule<Options, MessageId>({
       );
     }
   },
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumber: true,
-      allowRegExp: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Enforce template literal expressions to be of `string` type',
-      recommended: {
-        recommended: true,
-        strict: [
-          {
-            allowAny: false,
-            allowBoolean: false,
-            allowNever: false,
-            allowNullish: false,
-            allowNumber: false,
-            allowRegExp: false,
-          },
-        ],
-      },
-      requiresTypeChecking: true,
-    },
-    messages: {
-      invalidType: 'Invalid type "{{type}}" of template literal expression.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: Object.fromEntries(
-          optionTesters.map(({ option, type }) => [
-            option,
-            {
-              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
-              type: 'boolean',
-            },
-          ]),
-        ),
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'restrict-template-expressions',
 });
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index e1e8b94fc2f4..b3ec1d5cd8a3 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -32,6 +32,44 @@ type Option =
   | 'never';
 
 export default createRule({
+  defaultOptions: ['in-try-catch'],
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce consistent awaiting of returned promises',
+      extendsBaseRule: 'no-return-await',
+      recommended: {
+        strict: ['error-handling-correctness-only'],
+      },
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      disallowedPromiseAwait:
+        'Returning an awaited promise is not allowed in this context.',
+      disallowedPromiseAwaitSuggestion:
+        'Remove `await` before the expression. Use caution as this may impact control flow.',
+      nonPromiseAwait:
+        'Returning an awaited value that is not a promise is not allowed.',
+      requiredPromiseAwait:
+        'Returning an awaited promise is required in this context.',
+      requiredPromiseAwaitSuggestion:
+        'Add `await` before the expression. Use caution as this may impact control flow.',
+    },
+    schema: [
+      {
+        type: 'string',
+        enum: [
+          'in-try-catch',
+          'always',
+          'never',
+          'error-handling-correctness-only',
+        ] satisfies Option[],
+      },
+    ],
+  },
+  name: 'return-await',
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -358,44 +396,6 @@ export default createRule({
       },
     };
   },
-  defaultOptions: ['in-try-catch'],
-  meta: {
-    docs: {
-      description: 'Enforce consistent awaiting of returned promises',
-      extendsBaseRule: 'no-return-await',
-      recommended: {
-        strict: ['error-handling-correctness-only'],
-      },
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      disallowedPromiseAwait:
-        'Returning an awaited promise is not allowed in this context.',
-      disallowedPromiseAwaitSuggestion:
-        'Remove `await` before the expression. Use caution as this may impact control flow.',
-      nonPromiseAwait:
-        'Returning an awaited value that is not a promise is not allowed.',
-      requiredPromiseAwait:
-        'Returning an awaited promise is required in this context.',
-      requiredPromiseAwaitSuggestion:
-        'Add `await` before the expression. Use caution as this may impact control flow.',
-    },
-    schema: [
-      {
-        enum: [
-          'in-try-catch',
-          'always',
-          'never',
-          'error-handling-correctness-only',
-        ] satisfies Option[],
-        type: 'string',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'return-await',
 });
 
 type WhetherToAwait = "don't-care" | 'await' | 'no-await';
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index d73887909d6d..bc533345c55a 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -116,6 +116,75 @@ export type Options = [
 export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      caseSensitive: false,
+      checkIntersections: true,
+      checkUnions: true,
+      groupOrder: [
+        Group.named,
+        Group.keyword,
+        Group.operator,
+        Group.literal,
+        Group.function,
+        Group.import,
+        Group.conditional,
+        Group.object,
+        Group.tuple,
+        Group.intersection,
+        Group.union,
+        Group.nullish,
+      ],
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    deprecated: true,
+    docs: {
+      description:
+        'Enforce constituents of a type union/intersection to be sorted alphabetically',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      notSorted: '{{type}} type constituents must be sorted.',
+      notSortedNamed: '{{type}} type {{name}} constituents must be sorted.',
+      suggestFix: 'Sort constituents of type (removes all comments).',
+    },
+    replacedBy: [
+      'perfectionist/sort-intersection-types',
+      'perfectionist/sort-union-types',
+    ],
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          caseSensitive: {
+            type: 'boolean',
+            description: 'Whether to sort using case sensitive sorting.',
+          },
+          checkIntersections: {
+            type: 'boolean',
+            description: 'Whether to check intersection types.',
+          },
+          checkUnions: {
+            type: 'boolean',
+            description: 'Whether to check union types.',
+          },
+          groupOrder: {
+            type: 'array',
+            description: 'Ordering of the groups.',
+            items: {
+              type: 'string',
+              enum: getEnumNames(Group),
+            },
+          },
+        },
+      },
+    ],
+  },
+  name: 'sort-type-constituents',
   create(
     context,
     [{ caseSensitive, checkIntersections, checkUnions, groupOrder }],
@@ -222,73 +291,4 @@ export default createRule<Options, MessageIds>({
       }),
     };
   },
-  defaultOptions: [
-    {
-      caseSensitive: false,
-      checkIntersections: true,
-      checkUnions: true,
-      groupOrder: [
-        Group.named,
-        Group.keyword,
-        Group.operator,
-        Group.literal,
-        Group.function,
-        Group.import,
-        Group.conditional,
-        Group.object,
-        Group.tuple,
-        Group.intersection,
-        Group.union,
-        Group.nullish,
-      ],
-    },
-  ],
-  meta: {
-    deprecated: true,
-    docs: {
-      description:
-        'Enforce constituents of a type union/intersection to be sorted alphabetically',
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      notSorted: '{{type}} type constituents must be sorted.',
-      notSortedNamed: '{{type}} type {{name}} constituents must be sorted.',
-      suggestFix: 'Sort constituents of type (removes all comments).',
-    },
-    replacedBy: [
-      'perfectionist/sort-intersection-types',
-      'perfectionist/sort-union-types',
-    ],
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          caseSensitive: {
-            description: 'Whether to sort using case sensitive sorting.',
-            type: 'boolean',
-          },
-          checkIntersections: {
-            description: 'Whether to check intersection types.',
-            type: 'boolean',
-          },
-          checkUnions: {
-            description: 'Whether to check union types.',
-            type: 'boolean',
-          },
-          groupOrder: {
-            description: 'Ordering of the groups.',
-            items: {
-              enum: getEnumNames(Group),
-              type: 'string',
-            },
-            type: 'array',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'sort-type-constituents',
 });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index 630925365333..ba65ecc35d01 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -55,6 +55,108 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
+  defaultOptions: [
+    {
+      allowAny: false,
+      allowNullableBoolean: false,
+      allowNullableEnum: false,
+      allowNullableNumber: false,
+      allowNullableObject: true,
+      allowNullableString: false,
+      allowNumber: true,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      allowString: true,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow certain types in boolean expressions',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      conditionErrorAny:
+        'Unexpected any value in conditional. ' +
+        'An explicit comparison or type cast is required.',
+      conditionErrorNullableBoolean:
+        'Unexpected nullable boolean value in conditional. ' +
+        'Please handle the nullish case explicitly.',
+      conditionErrorNullableEnum:
+        'Unexpected nullable enum value in conditional. ' +
+        'Please handle the nullish/zero/NaN cases explicitly.',
+      conditionErrorNullableNumber:
+        'Unexpected nullable number value in conditional. ' +
+        'Please handle the nullish/zero/NaN cases explicitly.',
+      conditionErrorNullableObject:
+        'Unexpected nullable object value in conditional. ' +
+        'An explicit null check is required.',
+      conditionErrorNullableString:
+        'Unexpected nullable string value in conditional. ' +
+        'Please handle the nullish/empty cases explicitly.',
+      conditionErrorNullish:
+        'Unexpected nullish value in conditional. ' +
+        'The condition is always false.',
+      conditionErrorNumber:
+        'Unexpected number value in conditional. ' +
+        'An explicit zero/NaN check is required.',
+      conditionErrorObject:
+        'Unexpected object value in conditional. ' +
+        'The condition is always true.',
+      conditionErrorOther:
+        'Unexpected value in conditional. ' +
+        'A boolean expression is required.',
+      conditionErrorString:
+        'Unexpected string value in conditional. ' +
+        'An explicit empty string check is required.',
+      conditionFixCastBoolean:
+        'Explicitly cast value to a boolean (`Boolean(value)`)',
+
+      conditionFixCompareEmptyString:
+        'Change condition to check for empty string (`value !== ""`)',
+      conditionFixCompareFalse:
+        'Change condition to check if false (`value === false`)',
+      conditionFixCompareNaN:
+        'Change condition to check for NaN (`!Number.isNaN(value)`)',
+      conditionFixCompareNullish:
+        'Change condition to check for null/undefined (`value != null`)',
+      conditionFixCompareStringLength:
+        "Change condition to check string's length (`value.length !== 0`)",
+      conditionFixCompareTrue:
+        'Change condition to check if true (`value === true`)',
+      conditionFixCompareZero:
+        'Change condition to check for 0 (`value !== 0`)',
+      conditionFixDefaultEmptyString:
+        'Explicitly treat nullish value the same as an empty string (`value ?? ""`)',
+      conditionFixDefaultFalse:
+        'Explicitly treat nullish value the same as false (`value ?? false`)',
+      conditionFixDefaultZero:
+        'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowAny: { type: 'boolean' },
+          allowNullableBoolean: { type: 'boolean' },
+          allowNullableEnum: { type: 'boolean' },
+          allowNullableNumber: { type: 'boolean' },
+          allowNullableObject: { type: 'boolean' },
+          allowNullableString: { type: 'boolean' },
+          allowNumber: { type: 'boolean' },
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+          },
+          allowString: { type: 'boolean' },
+        },
+      },
+    ],
+  },
+  name: 'strict-boolean-expressions',
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
@@ -961,108 +1063,6 @@ export default createRule<Options, MessageId>({
       return variantTypes;
     }
   },
-  defaultOptions: [
-    {
-      allowAny: false,
-      allowNullableBoolean: false,
-      allowNullableEnum: false,
-      allowNullableNumber: false,
-      allowNullableObject: true,
-      allowNullableString: false,
-      allowNumber: true,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-      allowString: true,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Disallow certain types in boolean expressions',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      conditionErrorAny:
-        'Unexpected any value in conditional. ' +
-        'An explicit comparison or type cast is required.',
-      conditionErrorNullableBoolean:
-        'Unexpected nullable boolean value in conditional. ' +
-        'Please handle the nullish case explicitly.',
-      conditionErrorNullableEnum:
-        'Unexpected nullable enum value in conditional. ' +
-        'Please handle the nullish/zero/NaN cases explicitly.',
-      conditionErrorNullableNumber:
-        'Unexpected nullable number value in conditional. ' +
-        'Please handle the nullish/zero/NaN cases explicitly.',
-      conditionErrorNullableObject:
-        'Unexpected nullable object value in conditional. ' +
-        'An explicit null check is required.',
-      conditionErrorNullableString:
-        'Unexpected nullable string value in conditional. ' +
-        'Please handle the nullish/empty cases explicitly.',
-      conditionErrorNullish:
-        'Unexpected nullish value in conditional. ' +
-        'The condition is always false.',
-      conditionErrorNumber:
-        'Unexpected number value in conditional. ' +
-        'An explicit zero/NaN check is required.',
-      conditionErrorObject:
-        'Unexpected object value in conditional. ' +
-        'The condition is always true.',
-      conditionErrorOther:
-        'Unexpected value in conditional. ' +
-        'A boolean expression is required.',
-      conditionErrorString:
-        'Unexpected string value in conditional. ' +
-        'An explicit empty string check is required.',
-      conditionFixCastBoolean:
-        'Explicitly cast value to a boolean (`Boolean(value)`)',
-
-      conditionFixCompareEmptyString:
-        'Change condition to check for empty string (`value !== ""`)',
-      conditionFixCompareFalse:
-        'Change condition to check if false (`value === false`)',
-      conditionFixCompareNaN:
-        'Change condition to check for NaN (`!Number.isNaN(value)`)',
-      conditionFixCompareNullish:
-        'Change condition to check for null/undefined (`value != null`)',
-      conditionFixCompareStringLength:
-        "Change condition to check string's length (`value.length !== 0`)",
-      conditionFixCompareTrue:
-        'Change condition to check if true (`value === true`)',
-      conditionFixCompareZero:
-        'Change condition to check for 0 (`value !== 0`)',
-      conditionFixDefaultEmptyString:
-        'Explicitly treat nullish value the same as an empty string (`value ?? ""`)',
-      conditionFixDefaultFalse:
-        'Explicitly treat nullish value the same as false (`value ?? false`)',
-      conditionFixDefaultZero:
-        'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
-      noStrictNullCheck:
-        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowAny: { type: 'boolean' },
-          allowNullableBoolean: { type: 'boolean' },
-          allowNullableEnum: { type: 'boolean' },
-          allowNullableNumber: { type: 'boolean' },
-          allowNullableObject: { type: 'boolean' },
-          allowNullableString: { type: 'boolean' },
-          allowNumber: { type: 'boolean' },
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
-            type: 'boolean',
-          },
-          allowString: { type: 'boolean' },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'strict-boolean-expressions',
 });
 
 function isLogicalNegationExpression(
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index abce22923154..c47004745e88 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -46,6 +46,44 @@ type MessageIds =
   | 'switchIsNotExhaustive';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      allowDefaultCaseForExhaustiveSwitch: true,
+      requireDefaultForNonUnion: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require switch-case statements to be exhaustive',
+      requiresTypeChecking: true,
+    },
+    hasSuggestions: true,
+    messages: {
+      addMissingCases: 'Add branches for missing cases.',
+      dangerousDefaultCase:
+        'The switch statement is exhaustive, so the default case is unnecessary.',
+      switchIsNotExhaustive:
+        'Switch is not exhaustive. Cases not matched: {{missingBranches}}',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          allowDefaultCaseForExhaustiveSwitch: {
+            type: 'boolean',
+            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
+          },
+          requireDefaultForNonUnion: {
+            type: 'boolean',
+            description: `If 'true', require a 'default' clause for switches on non-union types.`,
+          },
+        },
+      },
+    ],
+  },
+  name: 'switch-exhaustiveness-check',
   create(
     context,
     [{ allowDefaultCaseForExhaustiveSwitch, requireDefaultForNonUnion }],
@@ -290,44 +328,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      allowDefaultCaseForExhaustiveSwitch: true,
-      requireDefaultForNonUnion: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Require switch-case statements to be exhaustive',
-      requiresTypeChecking: true,
-    },
-    hasSuggestions: true,
-    messages: {
-      addMissingCases: 'Add branches for missing cases.',
-      dangerousDefaultCase:
-        'The switch statement is exhaustive, so the default case is unnecessary.',
-      switchIsNotExhaustive:
-        'Switch is not exhaustive. Cases not matched: {{missingBranches}}',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowDefaultCaseForExhaustiveSwitch: {
-            description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`,
-            type: 'boolean',
-          },
-          requireDefaultForNonUnion: {
-            description: `If 'true', require a 'default' clause for switches on non-union types.`,
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'switch-exhaustiveness-check',
 });
 
 function isTypeLiteralLikeType(type: ts.Type): boolean {
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index 371ce0f38545..db24201c48ca 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -14,6 +14,46 @@ type Options = [
 type MessageIds = 'tripleSlashReference';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      lib: 'always',
+      path: 'never',
+      types: 'prefer-import',
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow certain triple slash directives in favor of ES6-style import declarations',
+      recommended: 'recommended',
+    },
+    messages: {
+      tripleSlashReference:
+        'Do not use a triple slash reference for {{module}}, use `import` style instead.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          lib: {
+            type: 'string',
+            enum: ['always', 'never'],
+          },
+          path: {
+            type: 'string',
+            enum: ['always', 'never'],
+          },
+          types: {
+            type: 'string',
+            enum: ['always', 'never', 'prefer-import'],
+          },
+        },
+      },
+    ],
+  },
+  name: 'triple-slash-reference',
   create(context, [{ lib, path, types }]) {
     let programNode: TSESTree.Node | undefined;
 
@@ -89,44 +129,4 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      lib: 'always',
-      path: 'never',
-      types: 'prefer-import',
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow certain triple slash directives in favor of ES6-style import declarations',
-      recommended: 'recommended',
-    },
-    messages: {
-      tripleSlashReference:
-        'Do not use a triple slash reference for {{module}}, use `import` style instead.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          lib: {
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-          path: {
-            enum: ['always', 'never'],
-            type: 'string',
-          },
-          types: {
-            enum: ['always', 'never', 'prefer-import'],
-            type: 'string',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'triple-slash-reference',
 });
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index 91e0259fb25c..309fe486a131 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -20,6 +20,45 @@ type Options = { [k in OptionKeys]?: boolean };
 type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed';
 
 export default createRule<[Options], MessageIds>({
+  defaultOptions: [
+    {
+      [OptionKeys.ArrayDestructuring]: false,
+      [OptionKeys.ArrowParameter]: false,
+      [OptionKeys.MemberVariableDeclaration]: false,
+      [OptionKeys.ObjectDestructuring]: false,
+      [OptionKeys.Parameter]: false,
+      [OptionKeys.PropertyDeclaration]: false,
+      [OptionKeys.VariableDeclaration]: false,
+      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require type annotations in certain places',
+    },
+    messages: {
+      expectedTypedef: 'Expected a type annotation.',
+      expectedTypedefNamed: 'Expected {{name}} to have a type annotation.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
+          [OptionKeys.ArrowParameter]: { type: 'boolean' },
+          [OptionKeys.MemberVariableDeclaration]: { type: 'boolean' },
+          [OptionKeys.ObjectDestructuring]: { type: 'boolean' },
+          [OptionKeys.Parameter]: { type: 'boolean' },
+          [OptionKeys.PropertyDeclaration]: { type: 'boolean' },
+          [OptionKeys.VariableDeclaration]: { type: 'boolean' },
+          [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
+        },
+      },
+    ],
+  },
+  name: 'typedef',
   create(
     context,
     [
@@ -237,43 +276,4 @@ export default createRule<[Options], MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      [OptionKeys.ArrayDestructuring]: false,
-      [OptionKeys.ArrowParameter]: false,
-      [OptionKeys.MemberVariableDeclaration]: false,
-      [OptionKeys.ObjectDestructuring]: false,
-      [OptionKeys.Parameter]: false,
-      [OptionKeys.PropertyDeclaration]: false,
-      [OptionKeys.VariableDeclaration]: false,
-      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description: 'Require type annotations in certain places',
-    },
-    messages: {
-      expectedTypedef: 'Expected a type annotation.',
-      expectedTypedefNamed: 'Expected {{name}} to have a type annotation.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          [OptionKeys.ArrayDestructuring]: { type: 'boolean' },
-          [OptionKeys.ArrowParameter]: { type: 'boolean' },
-          [OptionKeys.MemberVariableDeclaration]: { type: 'boolean' },
-          [OptionKeys.ObjectDestructuring]: { type: 'boolean' },
-          [OptionKeys.Parameter]: { type: 'boolean' },
-          [OptionKeys.PropertyDeclaration]: { type: 'boolean' },
-          [OptionKeys.VariableDeclaration]: { type: 'boolean' },
-          [OptionKeys.VariableDeclarationIgnoreFunction]: { type: 'boolean' },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'typedef',
 });
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 33b984972b62..a1ee86a2aa18 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -104,6 +104,38 @@ const BASE_MESSAGE =
   'Avoid referencing unbound methods which may cause unintentional scoping of `this`.';
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoreStatic: false,
+    },
+  ],
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce unbound methods are called with their expected scope',
+      recommended: 'recommended',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      unbound: BASE_MESSAGE,
+      unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreStatic: {
+            type: 'boolean',
+            description:
+              'Whether to skip checking whether `static` methods are correctly bound.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'unbound-method',
   create(context, [{ ignoreStatic }]) {
     const services = getParserServices(context);
     const currentSourceFile = services.program.getSourceFile(context.filename);
@@ -241,38 +273,6 @@ export default createRule<Options, MessageIds>({
       },
     };
   },
-  defaultOptions: [
-    {
-      ignoreStatic: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Enforce unbound methods are called with their expected scope',
-      recommended: 'recommended',
-      requiresTypeChecking: true,
-    },
-    messages: {
-      unbound: BASE_MESSAGE,
-      unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf your function does not access \`this\`, you can annotate it with \`this: void\`, or consider using an arrow function instead.`,
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreStatic: {
-            description:
-              'Whether to skip checking whether `static` methods are correctly bound.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'problem',
-  },
-  name: 'unbound-method',
 });
 
 function isNodeInsideTypeDeclaration(node: TSESTree.Node): boolean {
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 80f983a727d5..5e7994e4c683 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -65,6 +65,41 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
+  defaultOptions: [
+    {
+      ignoreDifferentlyNamedParameters: false,
+    },
+  ],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
+      // too opinionated to be recommended
+      recommended: 'strict',
+    },
+    messages: {
+      omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
+      omittingSingleParameter:
+        '{{failureStringStart}} with an optional parameter.',
+      singleParameterDifference:
+        '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ignoreDifferentlyNamedParameters: {
+            type: 'boolean',
+            description:
+              'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
+          },
+        },
+      },
+    ],
+  },
+  name: 'unified-signatures',
   create(context, [{ ignoreDifferentlyNamedParameters }]) {
     //----------------------------------------------------------------------
     // Helpers
@@ -550,41 +585,6 @@ export default createRule<Options, MessageIds>({
       'TSTypeLiteral:exit': checkScope,
     };
   },
-  defaultOptions: [
-    {
-      ignoreDifferentlyNamedParameters: false,
-    },
-  ],
-  meta: {
-    docs: {
-      description:
-        'Disallow two overloads that could be unified into one with a union or an optional/rest parameter',
-      // too opinionated to be recommended
-      recommended: 'strict',
-    },
-    messages: {
-      omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
-      omittingSingleParameter:
-        '{{failureStringStart}} with an optional parameter.',
-      singleParameterDifference:
-        '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          ignoreDifferentlyNamedParameters: {
-            description:
-              'Whether two parameters with different names at the same index should be considered different even if their types are the same.',
-            type: 'boolean',
-          },
-        },
-        type: 'object',
-      },
-    ],
-    type: 'suggestion',
-  },
-  name: 'unified-signatures',
 });
 
 function getExportingNode(
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index dd55fb4fbaa1..a7515130c6ba 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -41,6 +41,36 @@ const getStaticMemberAccessKey = (
   computed ? getStaticValue(property, scope) : { value: property.name };
 
 export default createRule<[], MessageIds>({
+  defaultOptions: [],
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Enforce typing arguments in Promise rejection callbacks as `unknown`',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      addUnknownRestTypeAnnotationSuggestion:
+        'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',
+      addUnknownTypeAnnotationSuggestion:
+        'Add an explicit `: unknown` type annotation to the rejection callback variable.',
+      useUnknown: useUnknownMessageBase,
+      useUnknownArrayDestructuringPattern: `${useUnknownMessageBase} The thrown error may not be iterable.`,
+      useUnknownObjectDestructuringPattern: `${
+        useUnknownMessageBase
+      } The thrown error may be nullable, or may not have the expected shape.`,
+      wrongRestTypeAnnotationSuggestion:
+        'Change existing type annotation to `: [unknown]`.',
+      wrongTypeAnnotationSuggestion:
+        'Change existing type annotation to `: unknown`.',
+    },
+    schema: [],
+  },
+
+  name: 'use-unknown-in-catch-callback-variable',
   create(context) {
     const { esTreeNodeToTSNodeMap, program } = getParserServices(context);
     const checker = program.getTypeChecker();
@@ -278,34 +308,4 @@ export default createRule<[], MessageIds>({
       },
     };
   },
-  defaultOptions: [],
-
-  meta: {
-    docs: {
-      description:
-        'Enforce typing arguments in Promise rejection callbacks as `unknown`',
-      recommended: 'strict',
-      requiresTypeChecking: true,
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    messages: {
-      addUnknownRestTypeAnnotationSuggestion:
-        'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',
-      addUnknownTypeAnnotationSuggestion:
-        'Add an explicit `: unknown` type annotation to the rejection callback variable.',
-      useUnknown: useUnknownMessageBase,
-      useUnknownArrayDestructuringPattern: `${useUnknownMessageBase} The thrown error may not be iterable.`,
-      useUnknownObjectDestructuringPattern: `${
-        useUnknownMessageBase
-      } The thrown error may be nullable, or may not have the expected shape.`,
-      wrongRestTypeAnnotationSuggestion:
-        'Change existing type annotation to `: [unknown]`.',
-      wrongTypeAnnotationSuggestion:
-        'Change existing type annotation to `: unknown`.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  name: 'use-unknown-in-catch-callback-variable',
 });

From 388cab9258e740d4fb1274638d00046c29f792bd Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Mon, 16 Sep 2024 13:09:59 -0400
Subject: [PATCH 06/13] re-order rules, correctly this time this time

---
 eslint.config.mjs                             |  8 +++-
 .../src/rules/adjacent-overload-signatures.ts |  4 +-
 .../eslint-plugin/src/rules/array-type.ts     | 12 ++---
 .../eslint-plugin/src/rules/await-thenable.ts |  4 +-
 .../eslint-plugin/src/rules/ban-ts-comment.ts | 20 ++++-----
 .../src/rules/ban-tslint-comment.ts           |  4 +-
 .../src/rules/class-literal-property-style.ts |  4 +-
 .../src/rules/class-methods-use-this.ts       | 18 ++++----
 .../rules/consistent-generic-constructors.ts  |  4 +-
 .../rules/consistent-indexed-object-style.ts  |  4 +-
 .../src/rules/consistent-return.ts            |  4 +-
 .../src/rules/consistent-type-assertions.ts   | 14 +++---
 .../src/rules/consistent-type-definitions.ts  |  4 +-
 .../src/rules/consistent-type-exports.ts      | 12 ++---
 .../src/rules/consistent-type-imports.ts      | 16 +++----
 .../src/rules/default-param-last.ts           |  4 +-
 .../eslint-plugin/src/rules/dot-notation.ts   | 20 ++++-----
 .../rules/explicit-function-return-type.ts    | 26 +++++------
 .../rules/explicit-member-accessibility.ts    |  4 +-
 .../rules/explicit-module-boundary-types.ts   | 20 ++++-----
 .../src/rules/init-declarations.ts            |  4 +-
 .../eslint-plugin/src/rules/max-params.ts     |  4 +-
 .../src/rules/member-ordering.ts              | 16 +++----
 .../src/rules/method-signature-style.ts       |  4 +-
 .../src/rules/naming-convention.ts            |  4 +-
 .../src/rules/no-array-constructor.ts         |  4 +-
 .../src/rules/no-array-delete.ts              |  4 +-
 .../src/rules/no-base-to-string.ts            | 12 ++---
 .../rules/no-confusing-non-null-assertion.ts  |  4 +-
 .../src/rules/no-confusing-void-expression.ts |  4 +-
 .../src/rules/no-dupe-class-members.ts        |  4 +-
 .../src/rules/no-duplicate-enum-values.ts     |  4 +-
 .../rules/no-duplicate-type-constituents.ts   | 14 +++---
 .../src/rules/no-dynamic-delete.ts            |  4 +-
 .../src/rules/no-empty-function.ts            | 12 ++---
 .../src/rules/no-empty-interface.ts           | 12 ++---
 .../src/rules/no-empty-object-type.ts         | 14 +++---
 .../src/rules/no-explicit-any.ts              | 14 +++---
 .../src/rules/no-extra-non-null-assertion.ts  |  4 +-
 .../src/rules/no-extraneous-class.ts          | 18 ++++----
 .../src/rules/no-floating-promises.ts         | 20 ++++-----
 .../src/rules/no-for-in-array.ts              |  4 +-
 .../src/rules/no-implied-eval.ts              |  4 +-
 .../src/rules/no-import-type-side-effects.ts  |  4 +-
 .../src/rules/no-inferrable-types.ts          | 14 +++---
 .../src/rules/no-invalid-this.ts              |  4 +-
 .../src/rules/no-invalid-void-type.ts         |  8 ++--
 .../eslint-plugin/src/rules/no-loop-func.ts   |  4 +-
 .../src/rules/no-loss-of-precision.ts         |  4 +-
 .../src/rules/no-magic-numbers.ts             | 20 ++++-----
 .../src/rules/no-meaningless-void-operator.ts |  4 +-
 .../eslint-plugin/src/rules/no-misused-new.ts |  4 +-
 .../src/rules/no-misused-promises.ts          | 16 +++----
 .../eslint-plugin/src/rules/no-mixed-enums.ts |  4 +-
 .../eslint-plugin/src/rules/no-namespace.ts   | 14 +++---
 ...no-non-null-asserted-nullish-coalescing.ts |  4 +-
 .../no-non-null-asserted-optional-chain.ts    |  4 +-
 .../src/rules/no-non-null-assertion.ts        |  4 +-
 .../eslint-plugin/src/rules/no-redeclare.ts   | 14 +++---
 .../rules/no-redundant-type-constituents.ts   |  4 +-
 .../src/rules/no-require-imports.ts           |  4 +-
 .../src/rules/no-restricted-imports.ts        |  4 +-
 .../src/rules/no-restricted-types.ts          |  4 +-
 packages/eslint-plugin/src/rules/no-shadow.ts | 22 +++++-----
 .../eslint-plugin/src/rules/no-this-alias.ts  | 14 +++---
 .../eslint-plugin/src/rules/no-type-alias.ts  | 26 +++++------
 .../no-unnecessary-boolean-literal-compare.ts | 14 +++---
 .../src/rules/no-unnecessary-condition.ts     | 14 +++---
 ...necessary-parameter-property-assignment.ts |  4 +-
 .../src/rules/no-unnecessary-qualifier.ts     |  4 +-
 .../no-unnecessary-template-expression.ts     |  4 +-
 .../rules/no-unnecessary-type-arguments.ts    |  4 +-
 .../rules/no-unnecessary-type-assertion.ts    |  4 +-
 .../rules/no-unnecessary-type-constraint.ts   |  4 +-
 .../rules/no-unnecessary-type-parameters.ts   |  4 +-
 .../src/rules/no-unsafe-argument.ts           |  4 +-
 .../src/rules/no-unsafe-assignment.ts         |  4 +-
 .../eslint-plugin/src/rules/no-unsafe-call.ts |  4 +-
 .../rules/no-unsafe-declaration-merging.ts    |  4 +-
 .../src/rules/no-unsafe-enum-comparison.ts    |  4 +-
 .../src/rules/no-unsafe-function-type.ts      |  4 +-
 .../src/rules/no-unsafe-member-access.ts      |  4 +-
 .../src/rules/no-unsafe-return.ts             |  4 +-
 .../src/rules/no-unsafe-unary-minus.ts        |  4 +-
 .../src/rules/no-unused-expressions.ts        | 16 +++----
 .../eslint-plugin/src/rules/no-unused-vars.ts |  4 +-
 .../src/rules/no-use-before-define.ts         | 24 +++++-----
 .../src/rules/no-useless-constructor.ts       |  4 +-
 .../src/rules/no-useless-empty-export.ts      |  4 +-
 .../src/rules/no-var-requires.ts              |  4 +-
 .../src/rules/no-wrapper-object-types.ts      |  4 +-
 .../non-nullable-type-assertion-style.ts      |  4 +-
 .../src/rules/only-throw-error.ts             | 14 +++---
 .../src/rules/parameter-properties.ts         | 14 +++---
 .../src/rules/prefer-as-const.ts              |  4 +-
 .../src/rules/prefer-destructuring.ts         | 26 +++++------
 .../src/rules/prefer-enum-initializers.ts     |  4 +-
 .../eslint-plugin/src/rules/prefer-find.ts    |  4 +-
 .../eslint-plugin/src/rules/prefer-for-of.ts  |  4 +-
 .../src/rules/prefer-function-type.ts         |  4 +-
 .../src/rules/prefer-includes.ts              |  4 +-
 .../src/rules/prefer-literal-enum-member.ts   | 12 ++---
 .../src/rules/prefer-namespace-keyword.ts     |  4 +-
 .../src/rules/prefer-nullish-coalescing.ts    | 30 ++++++-------
 .../src/rules/prefer-optional-chain.ts        | 26 +++++------
 .../src/rules/prefer-promise-reject-errors.ts | 12 ++---
 .../rules/prefer-readonly-parameter-types.ts  | 20 ++++-----
 .../src/rules/prefer-readonly.ts              |  4 +-
 .../src/rules/prefer-reduce-type-parameter.ts |  4 +-
 .../src/rules/prefer-regexp-exec.ts           |  4 +-
 .../src/rules/prefer-return-this-type.ts      |  4 +-
 .../rules/prefer-string-starts-ends-with.ts   |  4 +-
 .../src/rules/prefer-ts-expect-error.ts       |  4 +-
 .../src/rules/promise-function-async.ts       | 22 +++++-----
 .../src/rules/require-array-sort-compare.ts   | 12 ++---
 .../eslint-plugin/src/rules/require-await.ts  |  4 +-
 .../src/rules/restrict-plus-operands.ts       | 22 +++++-----
 .../rules/restrict-template-expressions.ts    | 20 ++++-----
 .../eslint-plugin/src/rules/return-await.ts   |  4 +-
 .../src/rules/sort-type-constituents.ts       | 44 +++++++++----------
 .../src/rules/strict-boolean-expressions.ts   | 28 ++++++------
 .../src/rules/switch-exhaustiveness-check.ts  | 14 +++---
 .../src/rules/triple-slash-reference.ts       | 16 +++----
 packages/eslint-plugin/src/rules/typedef.ts   | 26 +++++------
 .../eslint-plugin/src/rules/unbound-method.ts | 12 ++---
 .../src/rules/unified-signatures.ts           | 12 ++---
 .../use-unknown-in-catch-callback-variable.ts |  4 +-
 127 files changed, 602 insertions(+), 598 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 07ba62bce173..6596d07bb2a2 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -609,8 +609,12 @@ export default tseslint.config(
       'perfectionist/sort-objects': [
         'error',
         {
-          customGroups: { top: ['type', 'name', 'meta', 'defaultOptions'] },
-          groups: ['top', 'unknown'],
+          customGroups: {
+            primary: ['type', 'name'],
+            secondary: ['meta'],
+            tertiary: ['defaultOptions'],
+          },
+          groups: ['primary', 'secondary', 'tertiary', 'unknown'],
         },
       ],
     },
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index 4f09e8b687bd..e51ce81515b4 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -22,7 +22,7 @@ type MemberDeclaration =
   | TSESTree.NamedExportDeclarations;
 
 export default createRule({
-  defaultOptions: [],
+  name: 'adjacent-overload-signatures',
   meta: {
     type: 'suggestion',
     docs: {
@@ -34,7 +34,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'adjacent-overload-signatures',
+  defaultOptions: [],
   create(context) {
     interface Method {
       callSignature: boolean;
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 3b8ff8a728ac..23b12c187237 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -88,11 +88,7 @@ type MessageIds =
   | 'errorStringGenericSimple';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      default: 'array',
-    },
-  ],
+  name: 'array-type',
   meta: {
     type: 'suggestion',
     docs: {
@@ -139,7 +135,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'array-type',
+  defaultOptions: [
+    {
+      default: 'array',
+    },
+  ],
   create(context, [options]) {
     const defaultOption = options.default;
     const readonlyOption = options.readonly ?? defaultOption;
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index cb925f3d5f2f..636c673b8401 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -13,7 +13,7 @@ import {
 } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'await-thenable',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'await-thenable',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index 9e475f552b81..ce19ad727a2f 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -32,15 +32,7 @@ interface MatchedTSDirective {
 }
 
 export default createRule<[Options], MessageIds>({
-  defaultOptions: [
-    {
-      minimumDescriptionLength: defaultMinimumDescriptionLength,
-      'ts-check': false,
-      'ts-expect-error': 'allow-with-description',
-      'ts-ignore': true,
-      'ts-nocheck': true,
-    },
-  ],
+  name: 'ban-ts-comment',
   meta: {
     type: 'problem',
     docs: {
@@ -102,7 +94,15 @@ export default createRule<[Options], MessageIds>({
       },
     ],
   },
-  name: 'ban-ts-comment',
+  defaultOptions: [
+    {
+      minimumDescriptionLength: defaultMinimumDescriptionLength,
+      'ts-check': false,
+      'ts-expect-error': 'allow-with-description',
+      'ts-ignore': true,
+      'ts-nocheck': true,
+    },
+  ],
   create(context, [options]) {
     // https://github.com/microsoft/TypeScript/blob/6f1ad5ad8bec5671f7e951a3524b62d82ec4be68/src/compiler/parser.ts#L10591
     const singleLinePragmaRegEx =
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 8f3f05fb9446..6304e6d9d0f6 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -16,7 +16,7 @@ const toText = (
     : ['/*', text.trim(), '*/'].join(' ');
 
 export default createRule({
-  defaultOptions: [],
+  name: 'ban-tslint-comment',
   meta: {
     type: 'suggestion',
     docs: {
@@ -29,7 +29,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'ban-tslint-comment',
+  defaultOptions: [],
   create: context => {
     return {
       Program(): void {
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index ab53cbaefbc3..3f5f1a2c58e5 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -54,7 +54,7 @@ const isSupportedLiteral = (
 };
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: ['fields'],
+  name: 'class-literal-property-style',
   meta: {
     type: 'problem',
     docs: {
@@ -76,7 +76,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'class-literal-property-style',
+  defaultOptions: ['fields'],
   create(context, [style]) {
     const propertiesInfoStack: PropertiesInfo[] = [];
 
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index f1f9c3e3f824..cccf79d1f1bc 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -20,14 +20,7 @@ type Options = [
 type MessageIds = 'missingThis';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      enforceForClassFields: true,
-      exceptMethods: [],
-      ignoreClassesThatImplementAnInterface: false,
-      ignoreOverrideMethods: false,
-    },
-  ],
+  name: 'class-methods-use-this',
   meta: {
     type: 'suggestion',
     docs: {
@@ -81,7 +74,14 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'class-methods-use-this',
+  defaultOptions: [
+    {
+      enforceForClassFields: true,
+      exceptMethods: [],
+      ignoreClassesThatImplementAnInterface: false,
+      ignoreOverrideMethods: false,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index 04838d228af6..280736b33178 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -8,7 +8,7 @@ type MessageIds = 'preferConstructor' | 'preferTypeAnnotation';
 type Options = ['constructor' | 'type-annotation'];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: ['constructor'],
+  name: 'consistent-generic-constructors',
   meta: {
     type: 'suggestion',
     docs: {
@@ -30,7 +30,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'consistent-generic-constructors',
+  defaultOptions: ['constructor'],
   create(context, [mode]) {
     return {
       'VariableDeclarator,PropertyDefinition,:matches(FunctionDeclaration,FunctionExpression) > AssignmentPattern'(
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index a2d32d7718bc..5419f813a857 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -8,7 +8,7 @@ type MessageIds = 'preferIndexSignature' | 'preferRecord';
 type Options = ['index-signature' | 'record'];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: ['record'],
+  name: 'consistent-indexed-object-style',
   meta: {
     type: 'suggestion',
     docs: {
@@ -27,7 +27,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'consistent-indexed-object-style',
+  defaultOptions: ['record'],
   create(context, [mode]) {
     function checkMembers(
       members: TSESTree.TypeElement[],
diff --git a/packages/eslint-plugin/src/rules/consistent-return.ts b/packages/eslint-plugin/src/rules/consistent-return.ts
index 1ebf7a08c90e..44bd653a56e0 100644
--- a/packages/eslint-plugin/src/rules/consistent-return.ts
+++ b/packages/eslint-plugin/src/rules/consistent-return.ts
@@ -22,7 +22,7 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
+  name: 'consistent-return',
   meta: {
     type: 'suggestion',
     docs: {
@@ -35,7 +35,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'consistent-return',
+  defaultOptions: [{ treatUndefinedAsUnspecified: false }],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index dc234014750e..fd9f14f1ce3b 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -32,12 +32,7 @@ type OptUnion =
 export type Options = readonly [OptUnion];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      assertionStyle: 'as',
-      objectLiteralTypeAssertions: 'allow',
-    },
-  ],
+  name: 'consistent-type-assertions',
   meta: {
     type: 'suggestion',
     docs: {
@@ -89,7 +84,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'consistent-type-assertions',
+  defaultOptions: [
+    {
+      assertionStyle: 'as',
+      objectLiteralTypeAssertions: 'allow',
+    },
+  ],
   create(context, [options]) {
     const parserServices = getParserServices(context, true);
 
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 21f657850c01..8cc6c96430bf 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: ['interface'],
+  name: 'consistent-type-definitions',
   meta: {
     type: 'suggestion',
     docs: {
@@ -25,7 +25,7 @@ export default createRule({
       },
     ],
   },
-  name: 'consistent-type-definitions',
+  defaultOptions: ['interface'],
   create(context, [option]) {
     /**
      * Iterates from the highest parent to the currently traversed node
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index d90a99fc1103..21f6cd982347 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -39,11 +39,7 @@ type MessageIds =
   | 'typeOverValue';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      fixMixedExportsWithInlineTypeSpecifier: false,
-    },
-  ],
+  name: 'consistent-type-exports',
   meta: {
     type: 'suggestion',
     docs: {
@@ -72,7 +68,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'consistent-type-exports',
+  defaultOptions: [
+    {
+      fixMixedExportsWithInlineTypeSpecifier: false,
+    },
+  ],
   create(context, [{ fixMixedExportsWithInlineTypeSpecifier }]) {
     const sourceExportsMap: Record<string, SourceExports> = {};
     const services = getParserServices(context);
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index 20a97ce870c2..f15de1dd62ae 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -51,13 +51,7 @@ type MessageIds =
   | 'someImportsAreOnlyTypes'
   | 'typeOverValue';
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      disallowTypeAnnotations: true,
-      fixStyle: 'separate-type-imports',
-      prefer: 'type-imports',
-    },
-  ],
+  name: 'consistent-type-imports',
   meta: {
     type: 'suggestion',
     docs: {
@@ -93,7 +87,13 @@ export default createRule<Options, MessageIds>({
     ],
   },
 
-  name: 'consistent-type-imports',
+  defaultOptions: [
+    {
+      disallowTypeAnnotations: true,
+      fixStyle: 'separate-type-imports',
+      prefer: 'type-imports',
+    },
+  ],
   create(context, [option]) {
     const prefer = option.prefer ?? 'type-imports';
     const disallowTypeAnnotations = option.disallowTypeAnnotations !== false;
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index 0e0b7aa8f640..bd688bbe3ecd 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'default-param-last',
   meta: {
     type: 'suggestion',
     docs: {
@@ -17,7 +17,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'default-param-last',
+  defaultOptions: [],
   create(context) {
     /**
      * checks if node is optional parameter
diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
index c7dd52c72f8d..6358608d2699 100644
--- a/packages/eslint-plugin/src/rules/dot-notation.ts
+++ b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -18,15 +18,7 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowIndexSignaturePropertyAccess: false,
-      allowKeywords: true,
-      allowPattern: '',
-      allowPrivateClassPropertyAccess: false,
-      allowProtectedClassPropertyAccess: false,
-    },
-  ],
+  name: 'dot-notation',
   meta: {
     type: 'suggestion',
     docs: {
@@ -67,7 +59,15 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'dot-notation',
+  defaultOptions: [
+    {
+      allowIndexSignaturePropertyAccess: false,
+      allowKeywords: true,
+      allowPattern: '',
+      allowPrivateClassPropertyAccess: false,
+      allowProtectedClassPropertyAccess: false,
+    },
+  ],
   create(context, [options]) {
     const rules = baseRule.create(context);
     const services = getParserServices(context);
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index 1205fd4cc727..68787c31f635 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -31,18 +31,7 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowedNames: [],
-      allowExpressions: false,
-      allowFunctionsWithoutTypeParameters: false,
-      allowHigherOrderFunctions: true,
-      allowIIFEs: false,
-      allowTypedFunctionExpressions: true,
-    },
-  ],
+  name: 'explicit-function-return-type',
   meta: {
     type: 'problem',
     docs: {
@@ -104,7 +93,18 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'explicit-function-return-type',
+  defaultOptions: [
+    {
+      allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowExpressions: false,
+      allowFunctionsWithoutTypeParameters: false,
+      allowHigherOrderFunctions: true,
+      allowIIFEs: false,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
   create(context, [options]) {
     const functionInfoStack: FunctionInfo<FunctionNode>[] = [];
 
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 5ecb2ab4927e..1a17e40f8581 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -38,7 +38,7 @@ type MessageIds =
   | 'unwantedPublicAccessibility';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ accessibility: 'explicit' }],
+  name: 'explicit-member-accessibility',
   meta: {
     type: 'problem',
     docs: {
@@ -106,7 +106,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'explicit-member-accessibility',
+  defaultOptions: [{ accessibility: 'explicit' }],
   create(context, [option]) {
     const baseCheck: AccessibilityLevel = option.accessibility ?? 'explicit';
     const overrides = option.overrides ?? {};
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index c956abe8efd3..e4bfa29cc05c 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -35,15 +35,7 @@ type MessageIds =
   | 'missingReturnType';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowArgumentsExplicitlyTypedAsAny: false,
-      allowDirectConstAssertionInArrowFunctions: true,
-      allowedNames: [],
-      allowHigherOrderFunctions: true,
-      allowTypedFunctionExpressions: true,
-    },
-  ],
+  name: 'explicit-module-boundary-types',
   meta: {
     type: 'problem',
     docs: {
@@ -99,7 +91,15 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'explicit-module-boundary-types',
+  defaultOptions: [
+    {
+      allowArgumentsExplicitlyTypedAsAny: false,
+      allowDirectConstAssertionInArrowFunctions: true,
+      allowedNames: [],
+      allowHigherOrderFunctions: true,
+      allowTypedFunctionExpressions: true,
+    },
+  ],
   create(context, [options]) {
     // tracks all of the functions we've already checked
     const checkedFunctions = new Set<FunctionNode>();
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 33c43dc48a18..0f5b6f03c785 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -16,7 +16,7 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: ['always'],
+  name: 'init-declarations',
   meta: {
     type: 'suggestion',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'init-declarations',
+  defaultOptions: ['always'],
   create(context, [mode]) {
     // Make a custom context to adjust the loc of reports where the base
     // rule's behavior is a bit too aggressive with TS-specific syntax (namely,
diff --git a/packages/eslint-plugin/src/rules/max-params.ts b/packages/eslint-plugin/src/rules/max-params.ts
index 0e12ca2c7d7d..34327394290b 100644
--- a/packages/eslint-plugin/src/rules/max-params.ts
+++ b/packages/eslint-plugin/src/rules/max-params.ts
@@ -23,7 +23,7 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ countVoidThis: false, max: 3 }],
+  name: 'max-params',
   meta: {
     type: 'suggestion',
     docs: {
@@ -52,7 +52,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'max-params',
+  defaultOptions: [{ countVoidThis: false, max: 3 }],
   create(context, [{ countVoidThis }]) {
     const baseRules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index b9439eb5ae73..f67183eb4c73 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -718,13 +718,7 @@ function getLowestRank(
 }
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      default: {
-        memberTypes: defaultOrder,
-      },
-    },
-  ],
+  name: 'member-ordering',
   meta: {
     type: 'suggestion',
     docs: {
@@ -808,7 +802,13 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'member-ordering',
+  defaultOptions: [
+    {
+      default: {
+        memberTypes: defaultOrder,
+      },
+    },
+  ],
   create(context, [options]) {
     /**
      * Checks if the member groups are correctly sorted.
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index c51bdd6685b7..7d87957d0b8a 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -15,7 +15,7 @@ export type Options = [('method' | 'property')?];
 export type MessageIds = 'errorMethod' | 'errorProperty';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: ['property'],
+  name: 'method-signature-style',
   meta: {
     type: 'suggestion',
     docs: {
@@ -35,7 +35,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'method-signature-style',
+  defaultOptions: ['property'],
   create(context, [mode]) {
     function getMethodKey(
       node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature,
diff --git a/packages/eslint-plugin/src/rules/naming-convention.ts b/packages/eslint-plugin/src/rules/naming-convention.ts
index 174263b4e527..0c414cc4c243 100644
--- a/packages/eslint-plugin/src/rules/naming-convention.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention.ts
@@ -63,7 +63,7 @@ const defaultCamelCaseAllTheThingsConfig: Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: defaultCamelCaseAllTheThingsConfig,
+  name: 'naming-convention',
   meta: {
     type: 'suggestion',
     docs: {
@@ -88,7 +88,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: SCHEMA,
   },
-  name: 'naming-convention',
+  defaultOptions: defaultCamelCaseAllTheThingsConfig,
   create(contextWithoutDefaults) {
     const context =
       contextWithoutDefaults.options.length > 0
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index 96b7a446bb3a..882360e8ad14 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isOptionalCallExpression } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-array-constructor',
   meta: {
     type: 'suggestion',
     docs: {
@@ -19,7 +19,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-array-constructor',
+  defaultOptions: [],
   create(context) {
     /**
      * Disallow construction of dense arrays using the Array constructor
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index 0b955d946fae..d132bd76e47e 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -12,7 +12,7 @@ import {
 type MessageId = 'noArrayDelete' | 'useSplice';
 
 export default createRule<[], MessageId>({
-  defaultOptions: [],
+  name: 'no-array-delete',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<[], MessageId>({
     },
     schema: [],
   },
-  name: 'no-array-delete',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index 3e3bb03a9322..22646c9c706b 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -19,11 +19,7 @@ type Options = [
 type MessageIds = 'baseToString';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
-    },
-  ],
+  name: 'no-base-to-string',
   meta: {
     type: 'suggestion',
     docs: {
@@ -51,7 +47,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-base-to-string',
+  defaultOptions: [
+    {
+      ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'],
+    },
+  ],
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index 9901c199fadf..77073274220d 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-confusing-non-null-assertion',
   meta: {
     type: 'problem',
     docs: {
@@ -27,7 +27,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-confusing-non-null-assertion',
+  defaultOptions: [],
   create(context) {
     return {
       'BinaryExpression, AssignmentExpression'(
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 9ee8c384e9f7..79fde557516a 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -35,7 +35,7 @@ export type MessageId =
   | 'voidExprWrapVoid';
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
+  name: 'no-confusing-void-expression',
   meta: {
     type: 'problem',
     docs: {
@@ -82,7 +82,7 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'no-confusing-void-expression',
+  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],
   create(context, [options]) {
     return {
       'AwaitExpression, CallExpression, TaggedTemplateExpression'(
diff --git a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
index 3d6746cf336e..60f51d317ae8 100644
--- a/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
+++ b/packages/eslint-plugin/src/rules/no-dupe-class-members.ts
@@ -16,7 +16,7 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-dupe-class-members',
   meta: {
     type: 'problem',
     docs: {
@@ -27,7 +27,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'no-dupe-class-members',
+  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index 65ae2c7680d5..91d77e451548 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-duplicate-enum-values',
   meta: {
     type: 'problem',
     docs: {
@@ -18,7 +18,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-duplicate-enum-values',
+  defaultOptions: [],
   create(context) {
     function isStringLiteral(
       node: TSESTree.Expression,
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index 6ef7ecce3d34..14aa70bdc7a0 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -68,12 +68,7 @@ const isSameAstNode = (actualNode: unknown, expectedNode: unknown): boolean => {
 };
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoreIntersections: false,
-      ignoreUnions: false,
-    },
-  ],
+  name: 'no-duplicate-type-constituents',
   meta: {
     type: 'suggestion',
     docs: {
@@ -101,7 +96,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-duplicate-type-constituents',
+  defaultOptions: [
+    {
+      ignoreIntersections: false,
+      ignoreUnions: false,
+    },
+  ],
   create(context, [{ ignoreIntersections, ignoreUnions }]) {
     const parserServices = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index c614082d450c..edcaeea83095 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, nullThrows, NullThrowsReasons } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-dynamic-delete',
   meta: {
     type: 'suggestion',
     docs: {
@@ -19,7 +19,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-dynamic-delete',
+  defaultOptions: [],
   create(context) {
     function createFixer(
       member: TSESTree.MemberExpression,
diff --git a/packages/eslint-plugin/src/rules/no-empty-function.ts b/packages/eslint-plugin/src/rules/no-empty-function.ts
index 5c461960b040..36c9be7c4b03 100644
--- a/packages/eslint-plugin/src/rules/no-empty-function.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-function.ts
@@ -49,11 +49,7 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allow: [],
-    },
-  ],
+  name: 'no-empty-function',
   meta: {
     type: 'suggestion',
     docs: {
@@ -65,7 +61,11 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [schema],
   },
-  name: 'no-empty-function',
+  defaultOptions: [
+    {
+      allow: [],
+    },
+  ],
   create(context, [{ allow = [] }]) {
     const rules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index 9fcfbb36a4d5..2b54944bac43 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -13,11 +13,7 @@ type Options = [
 type MessageIds = 'noEmpty' | 'noEmptyWithSuper';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowSingleExtends: false,
-    },
-  ],
+  name: 'no-empty-interface',
   meta: {
     type: 'suggestion',
     deprecated: true,
@@ -44,7 +40,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-empty-interface',
+  defaultOptions: [
+    {
+      allowSingleExtends: false,
+    },
+  ],
   create(context, [{ allowSingleExtends }]) {
     return {
       TSInterfaceDeclaration(node): void {
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index 8cc92e098af2..f6a2cf5fac1c 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -33,12 +33,7 @@ const noEmptyMessage = (emptyType: string): string =>
   ].join('\n');
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowInterfaces: 'never',
-      allowObjectTypes: 'never',
-    },
-  ],
+  name: 'no-empty-object-type',
   meta: {
     type: 'suggestion',
     docs: {
@@ -76,7 +71,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-empty-object-type',
+  defaultOptions: [
+    {
+      allowInterfaces: 'never',
+      allowObjectTypes: 'never',
+    },
+  ],
   create(context, [{ allowInterfaces, allowObjectTypes, allowWithName }]) {
     const allowWithNameTester = allowWithName
       ? new RegExp(allowWithName, 'u')
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index 1b8c064d1cd2..5b297b7357a8 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -13,12 +13,7 @@ export type Options = [
 export type MessageIds = 'suggestNever' | 'suggestUnknown' | 'unexpectedAny';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      fixToUnknown: false,
-      ignoreRestArgs: false,
-    },
-  ],
+  name: 'no-explicit-any',
   meta: {
     type: 'suggestion',
     docs: {
@@ -52,7 +47,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-explicit-any',
+  defaultOptions: [
+    {
+      fixToUnknown: false,
+      ignoreRestArgs: false,
+    },
+  ],
   create(context, [{ fixToUnknown, ignoreRestArgs }]) {
     /**
      * Checks if the node is an arrow function, function/constructor declaration or function expression
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index 23257d5ca28b..d30f51feca5b 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -3,7 +3,7 @@ import type { TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-extra-non-null-assertion',
   meta: {
     type: 'problem',
     docs: {
@@ -16,7 +16,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-extra-non-null-assertion',
+  defaultOptions: [],
   create(context) {
     function checkExtraNonNullAssertion(
       node: TSESTree.TSNonNullExpression,
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 3e0e1c7de486..75641910c775 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -15,14 +15,7 @@ type Options = [
 type MessageIds = 'empty' | 'onlyConstructor' | 'onlyStatic';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowConstructorOnly: false,
-      allowEmpty: false,
-      allowStaticOnly: false,
-      allowWithDecorator: false,
-    },
-  ],
+  name: 'no-extraneous-class',
   meta: {
     type: 'suggestion',
     docs: {
@@ -63,7 +56,14 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-extraneous-class',
+  defaultOptions: [
+    {
+      allowConstructorOnly: false,
+      allowEmpty: false,
+      allowStaticOnly: false,
+      allowWithDecorator: false,
+    },
+  ],
   create(
     context,
     [{ allowConstructorOnly, allowEmpty, allowStaticOnly, allowWithDecorator }],
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 72faa95d685d..7f76e822caff 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -55,15 +55,7 @@ const messagePromiseArrayVoid =
   ' or explicitly marking the expression as ignored with the `void` operator.';
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [
-    {
-      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
-      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
-      checkThenables: false,
-      ignoreIIFE: false,
-      ignoreVoid: true,
-    },
-  ],
+  name: 'no-floating-promises',
   meta: {
     type: 'problem',
     docs: {
@@ -108,7 +100,15 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'no-floating-promises',
+  defaultOptions: [
+    {
+      allowForKnownSafeCalls: readonlynessOptionsDefaults.allow,
+      allowForKnownSafePromises: readonlynessOptionsDefaults.allow,
+      checkThenables: false,
+      ignoreIIFE: false,
+      ignoreVoid: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index 310c7eea6491..ec8ebe9125fb 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -9,7 +9,7 @@ import {
 import { getForStatementHeadLoc } from '../util/getForStatementHeadLoc';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-for-in-array',
   meta: {
     type: 'problem',
     docs: {
@@ -23,7 +23,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-for-in-array',
+  defaultOptions: [],
   create(context) {
     return {
       ForInStatement(node): void {
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index 85e15162a4e1..be621a228927 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -21,7 +21,7 @@ const EVAL_LIKE_METHODS = new Set([
 ]);
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-implied-eval',
   meta: {
     type: 'suggestion',
     docs: {
@@ -37,7 +37,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-implied-eval',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index 8353fc26ef99..41af8d6d4c85 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -14,7 +14,7 @@ type Options = [];
 type MessageIds = 'useTopLevelQualifier';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-import-type-side-effects',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<Options, MessageIds>({
     },
     schema: [],
   },
-  name: 'no-import-type-side-effects',
+  defaultOptions: [],
   create(context) {
     return {
       'ImportDeclaration[importKind!="type"]'(
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index 11e50fe49e46..900bab859dc0 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -14,12 +14,7 @@ type Options = [
 type MessageIds = 'noInferrableType';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoreParameters: false,
-      ignoreProperties: false,
-    },
-  ],
+  name: 'no-inferrable-types',
   meta: {
     type: 'suggestion',
     docs: {
@@ -47,7 +42,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-inferrable-types',
+  defaultOptions: [
+    {
+      ignoreParameters: false,
+      ignoreProperties: false,
+    },
+  ],
   create(context, [{ ignoreParameters, ignoreProperties }]) {
     function isFunctionCall(
       init: TSESTree.Expression,
diff --git a/packages/eslint-plugin/src/rules/no-invalid-this.ts b/packages/eslint-plugin/src/rules/no-invalid-this.ts
index 2919cc426f90..db6b9489d98c 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-this.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-this.ts
@@ -16,7 +16,7 @@ export type Options = InferOptionsTypeFromRule<typeof baseRule>;
 export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ capIsConstructor: true }],
+  name: 'no-invalid-this',
   meta: {
     type: 'suggestion',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'no-invalid-this',
+  defaultOptions: [{ capIsConstructor: true }],
   create(context) {
     const rules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index 25ec23ae8951..4c8dbd5937f7 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -18,9 +18,7 @@ type MessageIds =
   | 'invalidVoidUnionConstituent';
 
 export default createRule<[Options], MessageIds>({
-  defaultOptions: [
-    { allowAsThisParameter: false, allowInGenericTypeArguments: true },
-  ],
+  name: 'no-invalid-void-type',
   meta: {
     type: 'problem',
     docs: {
@@ -62,7 +60,9 @@ export default createRule<[Options], MessageIds>({
       },
     ],
   },
-  name: 'no-invalid-void-type',
+  defaultOptions: [
+    { allowAsThisParameter: false, allowInGenericTypeArguments: true },
+  ],
   create(context, [{ allowAsThisParameter, allowInGenericTypeArguments }]) {
     const validParents: AST_NODE_TYPES[] = [
       AST_NODE_TYPES.TSTypeAnnotation, //
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index 9fc340f999e8..dc30494ff22e 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -16,7 +16,7 @@ type Options = InferOptionsTypeFromRule<typeof baseRule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-loop-func',
   meta: {
     type: 'suggestion',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [],
   },
-  name: 'no-loop-func',
+  defaultOptions: [],
   create(context) {
     /**
      * Reports functions which match the following condition:
diff --git a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
index 3c2bf0e572ad..b3659ddd68bd 100644
--- a/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
+++ b/packages/eslint-plugin/src/rules/no-loss-of-precision.ts
@@ -12,7 +12,7 @@ type Options = InferOptionsTypeFromRule<NonNullable<typeof baseRule>>;
 type MessageIds = InferMessageIdsTypeFromRule<NonNullable<typeof baseRule>>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-loss-of-precision',
   meta: {
     type: 'problem',
     deprecated: true,
@@ -24,7 +24,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: [],
   },
-  name: 'no-loss-of-precision',
+  defaultOptions: [],
   create(context) {
     return baseRule.create(context);
   },
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index 7f015b424186..c06c89010e35 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -41,6 +41,16 @@ const schema = deepMerge(
 ) as unknown as JSONSchema4;
 
 export default createRule<Options, MessageIds>({
+  name: 'no-magic-numbers',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow magic numbers',
+      extendsBaseRule: true,
+    },
+    messages: baseRule.meta.messages,
+    schema: [schema],
+  },
   defaultOptions: [
     {
       detectObjects: false,
@@ -53,16 +63,6 @@ export default createRule<Options, MessageIds>({
       ignoreTypeIndexes: false,
     },
   ],
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Disallow magic numbers',
-      extendsBaseRule: true,
-    },
-    messages: baseRule.meta.messages,
-    schema: [schema],
-  },
-  name: 'no-magic-numbers',
   create(context, [options]) {
     const rules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index 6463bb89aa1f..a703d3ce3281 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -13,7 +13,7 @@ type Options = [
 ];
 
 export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
-  defaultOptions: [{ checkNever: false }],
+  name: 'no-meaningless-void-operator',
   meta: {
     type: 'suggestion',
     docs: {
@@ -42,7 +42,7 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
       },
     ],
   },
-  name: 'no-meaningless-void-operator',
+  defaultOptions: [{ checkNever: false }],
   create(context, [{ checkNever }]) {
     const services = ESLintUtils.getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index cbdbe9b6f661..16af769f1b48 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-misused-new',
   meta: {
     type: 'problem',
     docs: {
@@ -18,7 +18,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-misused-new',
+  defaultOptions: [],
   create(context) {
     /**
      * @param node type to be inspected.
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index c917d5a13ab2..f49469b2e80e 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -71,13 +71,7 @@ function parseChecksVoidReturn(
 }
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [
-    {
-      checksConditionals: true,
-      checksSpreads: true,
-      checksVoidReturn: true,
-    },
-  ],
+  name: 'no-misused-promises',
   meta: {
     type: 'problem',
     docs: {
@@ -133,7 +127,13 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'no-misused-promises',
+  defaultOptions: [
+    {
+      checksConditionals: true,
+      checksSpreads: true,
+      checksVoidReturn: true,
+    },
+  ],
   create(context, [{ checksConditionals, checksSpreads, checksVoidReturn }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index 911f70bf9a87..663fa3ce77de 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -15,7 +15,7 @@ enum AllowedType {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-mixed-enums',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-mixed-enums',
+  defaultOptions: [],
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index 821b9a1e7075..069de48d38c9 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -13,12 +13,7 @@ type Options = [
 type MessageIds = 'moduleSyntaxIsPreferred';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowDeclarations: false,
-      allowDefinitionFiles: true,
-    },
-  ],
+  name: 'no-namespace',
   meta: {
     type: 'suggestion',
     docs: {
@@ -48,7 +43,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-namespace',
+  defaultOptions: [
+    {
+      allowDeclarations: false,
+      allowDefinitionFiles: true,
+    },
+  ],
   create(context, [{ allowDeclarations, allowDefinitionFiles }]) {
     function isDeclaration(node: TSESTree.Node): boolean {
       if (node.type === AST_NODE_TYPES.TSModuleDeclaration && node.declare) {
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index 9c387f3b2f9d..6b100c4ef77d 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -31,7 +31,7 @@ function isDefinitionWithAssignment(definition: Definition): boolean {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-non-null-asserted-nullish-coalescing',
   meta: {
     type: 'problem',
     docs: {
@@ -47,7 +47,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-non-null-asserted-nullish-coalescing',
+  defaultOptions: [],
   create(context) {
     return {
       'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index 8eb850f779ae..96732d1b76b1 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -3,7 +3,7 @@ import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-non-null-asserted-optional-chain',
   meta: {
     type: 'problem',
     docs: {
@@ -19,7 +19,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-non-null-asserted-optional-chain',
+  defaultOptions: [],
   create(context) {
     return {
       // non-nulling a wrapped chain will scrub all nulls introduced by the chain
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 1729b31a1a6a..b8aebaef4eec 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -12,7 +12,7 @@ import {
 type MessageIds = 'noNonNull' | 'suggestOptionalChain';
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'no-non-null-assertion',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule<[], MessageIds>({
     },
     schema: [],
   },
-  name: 'no-non-null-assertion',
+  defaultOptions: [],
   create(context) {
     return {
       TSNonNullExpression(node): void {
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index e5e072abedfe..e3eba802d03a 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -14,12 +14,7 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      builtinGlobals: true,
-      ignoreDeclarationMerge: true,
-    },
-  ],
+  name: 'no-redeclare',
   meta: {
     type: 'suggestion',
     docs: {
@@ -48,7 +43,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-redeclare',
+  defaultOptions: [
+    {
+      builtinGlobals: true,
+      ignoreDeclarationMerge: true,
+    },
+  ],
   create(context, [options]) {
     const CLASS_DECLARATION_MERGE_NODES = new Set<AST_NODE_TYPES>([
       AST_NODE_TYPES.TSInterfaceDeclaration,
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index c76589d5d53b..ccdb7adde84e 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -192,7 +192,7 @@ function unionTypePartsUnlessBoolean(type: ts.Type): ts.Type[] {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-redundant-type-constituents',
   meta: {
     type: 'suggestion',
     docs: {
@@ -210,7 +210,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-redundant-type-constituents',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const typesCache = new Map<TSESTree.TypeNode, TypeFlagsWithName[]>();
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 2873bf2d6e45..3cfe4193b338 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -13,7 +13,7 @@ type Options = [
 type MessageIds = 'noRequireImports';
 
 export default util.createRule<Options, MessageIds>({
-  defaultOptions: [{ allow: [], allowAsImport: false }],
+  name: 'no-require-imports',
   meta: {
     type: 'problem',
     docs: {
@@ -41,7 +41,7 @@ export default util.createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-require-imports',
+  defaultOptions: [{ allow: [], allowAsImport: false }],
   create(context, options) {
     const allowAsImport = options[0].allowAsImport;
     const allowPatterns = options[0].allow?.map(
diff --git a/packages/eslint-plugin/src/rules/no-restricted-imports.ts b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
index 71dfdc1931de..d407a5f66df5 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-imports.ts
@@ -230,7 +230,7 @@ function shouldCreateRule(
 }
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-restricted-imports',
   meta: {
     type: 'suggestion',
     docs: {
@@ -241,7 +241,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema,
   },
-  name: 'no-restricted-imports',
+  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
     const { options } = context;
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index 97c36ef23a4d..ffddaf22d15c 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -69,7 +69,7 @@ const TYPE_KEYWORDS = {
 };
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{}],
+  name: 'no-restricted-types',
   meta: {
     type: 'suggestion',
     docs: {
@@ -132,7 +132,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-restricted-types',
+  defaultOptions: [{}],
   create(context, [{ types = {} }]) {
     const bannedTypes = new Map(
       Object.entries(types).map(([type, data]) => [removeSpaces(type), data]),
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 62e92e43554f..e7ed3f9b2f8a 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -25,16 +25,7 @@ const allowedFunctionVariableDefTypes = new Set([
 ]);
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allow: [],
-      builtinGlobals: false,
-      hoist: 'functions',
-      ignoreFunctionTypeParameterNameValueShadow: true,
-      ignoreOnInitialization: false,
-      ignoreTypeValueShadow: true,
-    },
-  ],
+  name: 'no-shadow',
   meta: {
     type: 'suggestion',
     docs: {
@@ -78,7 +69,16 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-shadow',
+  defaultOptions: [
+    {
+      allow: [],
+      builtinGlobals: false,
+      hoist: 'functions',
+      ignoreFunctionTypeParameterNameValueShadow: true,
+      ignoreOnInitialization: false,
+      ignoreTypeValueShadow: true,
+    },
+  ],
   create(context, [options]) {
     /**
      * Check if a scope is a TypeScript module augmenting the global namespace.
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 82851be9ade7..0f5c71f88692 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -13,12 +13,7 @@ type Options = [
 type MessageIds = 'thisAssignment' | 'thisDestructure';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowDestructuring: true,
-      allowedNames: [],
-    },
-  ],
+  name: 'no-this-alias',
   meta: {
     type: 'suggestion',
     docs: {
@@ -52,7 +47,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-this-alias',
+  defaultOptions: [
+    {
+      allowDestructuring: true,
+      allowedNames: [],
+    },
+  ],
   create(context, [{ allowDestructuring, allowedNames }]) {
     return {
       "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index bd6ff3bebf86..fcb332c1ba64 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -34,18 +34,7 @@ interface TypeWithLabel {
 }
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowAliases: 'never',
-      allowCallbacks: 'never',
-      allowConditionalTypes: 'never',
-      allowConstructors: 'never',
-      allowGenerics: 'never',
-      allowLiterals: 'never',
-      allowMappedTypes: 'never',
-      allowTupleTypes: 'never',
-    },
-  ],
+  name: 'no-type-alias',
   meta: {
     type: 'suggestion',
     deprecated: true,
@@ -116,7 +105,18 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-type-alias',
+  defaultOptions: [
+    {
+      allowAliases: 'never',
+      allowCallbacks: 'never',
+      allowConditionalTypes: 'never',
+      allowConstructors: 'never',
+      allowGenerics: 'never',
+      allowLiterals: 'never',
+      allowMappedTypes: 'never',
+      allowTupleTypes: 'never',
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 57d9294303e5..8e4c51570180 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -31,12 +31,7 @@ interface BooleanComparisonWithTypeInformation extends BooleanComparison {
 }
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowComparingNullableBooleansToFalse: true,
-      allowComparingNullableBooleansToTrue: true,
-    },
-  ],
+  name: 'no-unnecessary-boolean-literal-compare',
   meta: {
     type: 'suggestion',
     docs: {
@@ -77,7 +72,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-unnecessary-boolean-literal-compare',
+  defaultOptions: [
+    {
+      allowComparingNullableBooleansToFalse: true,
+      allowComparingNullableBooleansToTrue: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 093c180243d8..79b03cfb93f6 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -88,12 +88,7 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [
-    {
-      allowConstantLoopConditions: false,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-    },
-  ],
+  name: 'no-unnecessary-condition',
   meta: {
     type: 'suggestion',
     docs: {
@@ -142,7 +137,12 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'no-unnecessary-condition',
+  defaultOptions: [
+    {
+      allowConstantLoopConditions: false,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index ac013f0a68a3..413e6cecadd5 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -8,7 +8,7 @@ import { createRule, getStaticStringValue, nullThrows } from '../util';
 const UNNECESSARY_OPERATORS = new Set(['=', '&&=', '||=', '??=']);
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unnecessary-parameter-property-assignment',
   meta: {
     type: 'suggestion',
     docs: {
@@ -21,7 +21,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unnecessary-parameter-property-assignment',
+  defaultOptions: [],
   create(context) {
     const reportInfoStack: {
       assignedBeforeConstructor: Set<string>;
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index 028bd753a0c9..bdbb73897e50 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -7,7 +7,7 @@ import * as ts from 'typescript';
 import { createRule, getParserServices } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unnecessary-qualifier',
   meta: {
     type: 'suggestion',
     docs: {
@@ -21,7 +21,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unnecessary-qualifier',
+  defaultOptions: [],
   create(context) {
     const namespacesInScope: ts.Node[] = [];
     let currentFailedNamespaceExpression: TSESTree.Node | null = null;
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index 9a9712742038..d0e7fad7508a 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -26,7 +26,7 @@ function endsWithUnescapedDollarSign(str: string): boolean {
 }
 
 export default createRule<[], MessageId>({
-  defaultOptions: [],
+  name: 'no-unnecessary-template-expression',
   meta: {
     type: 'suggestion',
     docs: {
@@ -41,7 +41,7 @@ export default createRule<[], MessageId>({
     },
     schema: [],
   },
-  name: 'no-unnecessary-template-expression',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index 794bb47ee62d..3fc30c1ec231 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -24,7 +24,7 @@ type ParameterCapableTSNode =
 type MessageIds = 'unnecessaryTypeParameter';
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'no-unnecessary-type-arguments',
   meta: {
     type: 'suggestion',
     docs: {
@@ -39,7 +39,7 @@ export default createRule<[], MessageIds>({
     },
     schema: [],
   },
-  name: 'no-unnecessary-type-arguments',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index a1878d9d913d..a43a842d7193 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -26,7 +26,7 @@ type Options = [
 type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{}],
+  name: 'no-unnecessary-type-assertion',
   meta: {
     type: 'suggestion',
     docs: {
@@ -58,7 +58,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-unnecessary-type-assertion',
+  defaultOptions: [{}],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index 1894bd644832..1590efad34da 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -14,7 +14,7 @@ type TypeParameterWithConstraint = MakeRequired<
 >;
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unnecessary-type-constraint',
   meta: {
     type: 'suggestion',
     docs: {
@@ -30,7 +30,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unnecessary-type-constraint',
+  defaultOptions: [],
   create(context) {
     // In theory, we could use the type checker for more advanced constraint types...
     // ...but in practice, these types are rare, and likely not worth requiring type info.
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index 7c8294832ea5..d5351ec137aa 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -15,7 +15,7 @@ type NodeWithTypeParameters = MakeRequired<
 >;
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unnecessary-type-parameters',
   meta: {
     type: 'problem',
     docs: {
@@ -28,7 +28,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unnecessary-type-parameters',
+  defaultOptions: [],
   create(context) {
     const parserServices = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index 49645b0a3b7f..82c56eb7d58a 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -141,7 +141,7 @@ class FunctionSignature {
 }
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'no-unsafe-argument',
   meta: {
     type: 'problem',
     docs: {
@@ -159,7 +159,7 @@ export default createRule<[], MessageIds>({
     },
     schema: [],
   },
-  name: 'no-unsafe-argument',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 323322e301a4..3169a0e3ac37 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -28,7 +28,7 @@ const enum ComparisonType {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-assignment',
   meta: {
     type: 'problem',
     docs: {
@@ -53,7 +53,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-assignment',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 7eeda11863f9..4ce0b6ff4fa3 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -17,7 +17,7 @@ type MessageIds =
   | 'unsafeTemplateTag';
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'no-unsafe-call',
   meta: {
     type: 'problem',
     docs: {
@@ -36,7 +36,7 @@ export default createRule<[], MessageIds>({
     },
     schema: [],
   },
-  name: 'no-unsafe-call',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index b404d09f3293..28eb665a544c 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -6,7 +6,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-declaration-merging',
   meta: {
     type: 'problem',
     docs: {
@@ -20,7 +20,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-declaration-merging',
+  defaultOptions: [],
   create(context) {
     function checkUnsafeDeclaration(
       scope: Scope,
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index 775e533c84ff..524951f98b38 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -56,7 +56,7 @@ function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-enum-comparison',
   meta: {
     type: 'suggestion',
     docs: {
@@ -74,7 +74,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-enum-comparison',
+  defaultOptions: [],
   create(context) {
     const parserServices = getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index b42a685fb3ea..fb00dbe70d84 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isReferenceToGlobalFunction } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-function-type',
   meta: {
     type: 'problem',
     docs: {
@@ -21,7 +21,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-function-type',
+  defaultOptions: [],
   create(context) {
     function checkBannedTypes(node: TSESTree.Node): void {
       if (
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 18c2b844a08f..595ce11f30ab 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -23,7 +23,7 @@ function createDataType(type: ts.Type): '`any`' | '`error` typed' {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-member-access',
   meta: {
     type: 'problem',
     docs: {
@@ -43,7 +43,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-member-access',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const compilerOptions = services.program.getCompilerOptions();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index ac8ba136d531..e866830e9a02 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -20,7 +20,7 @@ import {
 } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-unsafe-return',
   meta: {
     type: 'problem',
     docs: {
@@ -39,7 +39,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-unsafe-return',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index 883636b52d68..9bad9d881670 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -7,7 +7,7 @@ type Options = [];
 type MessageIds = 'unaryMinus';
 
 export default util.createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-unsafe-unary-minus',
   meta: {
     type: 'problem',
     docs: {
@@ -21,7 +21,7 @@ export default util.createRule<Options, MessageIds>({
     },
     schema: [],
   },
-  name: 'no-unsafe-unary-minus',
+  defaultOptions: [],
   create(context) {
     return {
       UnaryExpression(node): void {
diff --git a/packages/eslint-plugin/src/rules/no-unused-expressions.ts b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
index b812a792ebb4..894e1e435033 100644
--- a/packages/eslint-plugin/src/rules/no-unused-expressions.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-expressions.ts
@@ -14,13 +14,7 @@ type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
 type Options = InferOptionsTypeFromRule<typeof baseRule>;
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowShortCircuit: false,
-      allowTaggedTemplates: false,
-      allowTernary: false,
-    },
-  ],
+  name: 'no-unused-expressions',
   meta: {
     type: 'suggestion',
     docs: {
@@ -32,7 +26,13 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'no-unused-expressions',
+  defaultOptions: [
+    {
+      allowShortCircuit: false,
+      allowTaggedTemplates: false,
+      allowTernary: false,
+    },
+  ],
   create(context, [{ allowShortCircuit = false, allowTernary = false }]) {
     const rules = baseRule.create(context);
 
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index df65fa04ba92..3467ce20656e 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -59,7 +59,7 @@ type VariableType =
   | 'variable';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{}],
+  name: 'no-unused-vars',
   meta: {
     type: 'problem',
     docs: {
@@ -124,7 +124,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-unused-vars',
+  defaultOptions: [{}],
   create(context, [firstOption]) {
     const MODULE_DECL_CACHE = new Map<TSESTree.TSModuleDeclaration, boolean>();
 
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index ef87fcf3b088..90b209753054 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -216,17 +216,7 @@ type Options = ['nofunc' | Config];
 type MessageIds = 'noUseBeforeDefine';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowNamedExports: false,
-      classes: true,
-      enums: true,
-      functions: true,
-      ignoreTypeReferences: true,
-      typedefs: true,
-      variables: true,
-    },
-  ],
+  name: 'no-use-before-define',
   meta: {
     type: 'problem',
     docs: {
@@ -260,7 +250,17 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-use-before-define',
+  defaultOptions: [
+    {
+      allowNamedExports: false,
+      classes: true,
+      enums: true,
+      functions: true,
+      ignoreTypeReferences: true,
+      typedefs: true,
+      variables: true,
+    },
+  ],
   create(context, optionsWithDefault) {
     const options = parseOptions(optionsWithDefault[0]);
 
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index eb016a7f0e16..9c45ec6534b0 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -44,7 +44,7 @@ function checkParams(node: TSESTree.MethodDefinition): boolean {
 }
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [],
+  name: 'no-useless-constructor',
   meta: {
     type: 'problem',
     docs: {
@@ -56,7 +56,7 @@ export default createRule<Options, MessageIds>({
     messages: baseRule.meta.messages,
     schema: baseRule.meta.schema,
   },
-  name: 'no-useless-constructor',
+  defaultOptions: [],
   create(context) {
     const rules = baseRule.create(context);
     return {
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index 6ece19fe5865..afc8d7cf3f54 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -25,7 +25,7 @@ const exportOrImportNodeTypes = new Set([
 ]);
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-useless-empty-export',
   meta: {
     type: 'suggestion',
     docs: {
@@ -39,7 +39,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-useless-empty-export',
+  defaultOptions: [],
   create(context) {
     // In a definition file, export {} is necessary to make the module properly
     // encapsulated, even when there are other exports
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index 94aaa396a1ca..0010e41b77a1 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -12,7 +12,7 @@ type Options = [
 type MessageIds = 'noVarReqs';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ allow: [] }],
+  name: 'no-var-requires',
   meta: {
     type: 'problem',
     deprecated: true,
@@ -37,7 +37,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'no-var-requires',
+  defaultOptions: [{ allow: [] }],
   create(context, options) {
     const allowPatterns = options[0].allow.map(
       pattern => new RegExp(pattern, 'u'),
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index d29dbb5b66fc..6172ccc7d472 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -16,7 +16,7 @@ const classNames = new Set([
 ]);
 
 export default createRule({
-  defaultOptions: [],
+  name: 'no-wrapper-object-types',
   meta: {
     type: 'problem',
     docs: {
@@ -30,7 +30,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'no-wrapper-object-types',
+  defaultOptions: [],
   create(context) {
     function checkBannedTypes(
       node: TSESTree.EntityName | TSESTree.Expression,
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index 1a8fb6074205..31bf981787a2 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -12,7 +12,7 @@ import {
 } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'non-nullable-type-assertion-style',
   meta: {
     type: 'suggestion',
     docs: {
@@ -27,7 +27,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'non-nullable-type-assertion-style',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index 0b17104815e0..fe3b4d96b5a6 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -21,12 +21,7 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowThrowingAny: true,
-      allowThrowingUnknown: true,
-    },
-  ],
+  name: 'only-throw-error',
   meta: {
     type: 'problem',
     docs: {
@@ -54,7 +49,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'only-throw-error',
+  defaultOptions: [
+    {
+      allowThrowingAny: true,
+      allowThrowingUnknown: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index 34486e292334..a999dce781d7 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -25,12 +25,7 @@ type Options = [
 type MessageIds = 'preferClassProperty' | 'preferParameterProperty';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allow: [],
-      prefer: 'class-property',
-    },
-  ],
+  name: 'parameter-properties',
   meta: {
     type: 'problem',
     docs: {
@@ -76,7 +71,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'parameter-properties',
+  defaultOptions: [
+    {
+      allow: [],
+      prefer: 'class-property',
+    },
+  ],
   create(context, [{ allow = [], prefer = 'class-property' }]) {
     /**
      * Gets the modifiers of `node`.
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index 70d0bb6b51d2..4d1cdb2e5796 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-as-const',
   meta: {
     type: 'suggestion',
     docs: {
@@ -23,7 +23,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'prefer-as-const',
+  defaultOptions: [],
   create(context) {
     function compareTypes(
       valueNode: TSESTree.Expression,
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index a5bfcbae48d5..9917e5cf1d52 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -64,6 +64,19 @@ const schema: readonly JSONSchema4[] = [
 ];
 
 export default createRule<Options, MessageIds>({
+  name: 'prefer-destructuring',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require destructuring from arrays and/or objects',
+      extendsBaseRule: true,
+      requiresTypeChecking: true,
+    },
+    fixable: baseRule.meta.fixable,
+    hasSuggestions: baseRule.meta.hasSuggestions,
+    messages: baseRule.meta.messages,
+    schema,
+  },
   defaultOptions: [
     {
       AssignmentExpression: {
@@ -77,19 +90,6 @@ export default createRule<Options, MessageIds>({
     },
     {},
   ],
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Require destructuring from arrays and/or objects',
-      extendsBaseRule: true,
-      requiresTypeChecking: true,
-    },
-    fixable: baseRule.meta.fixable,
-    hasSuggestions: baseRule.meta.hasSuggestions,
-    messages: baseRule.meta.messages,
-    schema,
-  },
-  name: 'prefer-destructuring',
   create(context, [enabledTypes, options]) {
     const {
       enforceForDeclarationWithTypeAnnotation = false,
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index e308f5974cc2..f4b7e2f843f9 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -5,7 +5,7 @@ import { createRule } from '../util';
 type MessageIds = 'defineInitializer' | 'defineInitializerSuggestion';
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'prefer-enum-initializers',
   meta: {
     type: 'suggestion',
     docs: {
@@ -21,7 +21,7 @@ export default createRule<[], MessageIds>({
     },
     schema: [],
   },
-  name: 'prefer-enum-initializers',
+  defaultOptions: [],
   create(context) {
     function TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
       const { members } = node.body;
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index 91eb0dc76a11..b19f46d2355a 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -14,7 +14,7 @@ import {
 } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-find',
   meta: {
     type: 'suggestion',
     docs: {
@@ -31,7 +31,7 @@ export default createRule({
     schema: [],
   },
 
-  name: 'prefer-find',
+  defaultOptions: [],
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index 28a03756c514..b6b399dcf3de 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -5,7 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, isAssignee } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-for-of',
   meta: {
     type: 'suggestion',
     docs: {
@@ -19,7 +19,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'prefer-for-of',
+  defaultOptions: [],
   create(context) {
     function isSingleVariableDeclaration(
       node: TSESTree.Node | null,
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index 40e8c7356ae5..3454088da54a 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -10,7 +10,7 @@ export const phrases = {
 } as const;
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-function-type',
   meta: {
     type: 'suggestion',
     docs: {
@@ -27,7 +27,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'prefer-function-type',
+  defaultOptions: [],
   create(context) {
     /**
      * Checks if there the interface has exactly one supertype that isn't named 'Function'
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index b11f980786d3..5082eb9e88ef 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -12,7 +12,7 @@ import {
 } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-includes',
   meta: {
     type: 'suggestion',
     docs: {
@@ -29,7 +29,7 @@ export default createRule({
     schema: [],
   },
 
-  name: 'prefer-includes',
+  defaultOptions: [],
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index b65ec116f107..6f980defce9a 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -5,11 +5,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { createRule, getStaticStringValue } from '../util';
 
 export default createRule({
-  defaultOptions: [
-    {
-      allowBitwiseExpressions: false,
-    },
-  ],
+  name: 'prefer-literal-enum-member',
   meta: {
     type: 'suggestion',
     docs: {
@@ -32,7 +28,11 @@ export default createRule({
       },
     ],
   },
-  name: 'prefer-literal-enum-member',
+  defaultOptions: [
+    {
+      allowBitwiseExpressions: false,
+    },
+  ],
   create(context, [{ allowBitwiseExpressions }]) {
     function isIdentifierWithName(node: TSESTree.Node, name: string): boolean {
       return node.type === AST_NODE_TYPES.Identifier && node.name === name;
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index 88c3e179537b..a138b9d9064d 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -3,7 +3,7 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRule } from '../util';
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-namespace-keyword',
   meta: {
     type: 'suggestion',
     docs: {
@@ -18,7 +18,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'prefer-namespace-keyword',
+  defaultOptions: [],
   create(context) {
     return {
       TSModuleDeclaration(node): void {
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 71b99e0d5e87..7b2a17b9c170 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -42,20 +42,7 @@ export type MessageIds =
   | 'suggestNullish';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-      ignoreConditionalTests: true,
-      ignoreMixedLogicalExpressions: false,
-      ignorePrimitives: {
-        bigint: false,
-        boolean: false,
-        number: false,
-        string: false,
-      },
-      ignoreTernaryTests: false,
-    },
-  ],
+  name: 'prefer-nullish-coalescing',
   meta: {
     type: 'suggestion',
     docs: {
@@ -112,7 +99,20 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'prefer-nullish-coalescing',
+  defaultOptions: [
+    {
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      ignoreConditionalTests: true,
+      ignoreMixedLogicalExpressions: false,
+      ignorePrimitives: {
+        bigint: false,
+        boolean: false,
+        number: false,
+        string: false,
+      },
+      ignoreTernaryTests: false,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 98ea9cc9fc03..42079069dafc 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -27,18 +27,7 @@ export default createRule<
   [PreferOptionalChainOptions],
   PreferOptionalChainMessageIds
 >({
-  defaultOptions: [
-    {
-      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
-      checkAny: true,
-      checkBigInt: true,
-      checkBoolean: true,
-      checkNumber: true,
-      checkString: true,
-      checkUnknown: true,
-      requireNullish: false,
-    },
-  ],
+  name: 'prefer-optional-chain',
   meta: {
     type: 'suggestion',
     docs: {
@@ -103,7 +92,18 @@ export default createRule<
       },
     ],
   },
-  name: 'prefer-optional-chain',
+  defaultOptions: [
+    {
+      allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false,
+      checkAny: true,
+      checkBigInt: true,
+      checkBoolean: true,
+      checkNumber: true,
+      checkString: true,
+      checkUnknown: true,
+      requireNullish: false,
+    },
+  ],
   create(context, [options]) {
     const parserServices = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index 278ce840492c..eb7b0040f884 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -22,11 +22,7 @@ export type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowEmptyReject: false,
-    },
-  ],
+  name: 'prefer-promise-reject-errors',
   meta: {
     type: 'suggestion',
     docs: {
@@ -50,7 +46,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'prefer-promise-reject-errors',
+  defaultOptions: [
+    {
+      allowEmptyReject: false,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
 
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index f024edfd41cc..96a294b82b7c 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -23,15 +23,7 @@ type Options = [
 type MessageIds = 'shouldBeReadonly';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allow: readonlynessOptionsDefaults.allow,
-      checkParameterProperties: true,
-      ignoreInferredTypes: false,
-      treatMethodsAsReadonly:
-        readonlynessOptionsDefaults.treatMethodsAsReadonly,
-    },
-  ],
+  name: 'prefer-readonly-parameter-types',
   meta: {
     type: 'suggestion',
     docs: {
@@ -60,7 +52,15 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'prefer-readonly-parameter-types',
+  defaultOptions: [
+    {
+      allow: readonlynessOptionsDefaults.allow,
+      checkParameterProperties: true,
+      ignoreInferredTypes: false,
+      treatMethodsAsReadonly:
+        readonlynessOptionsDefaults.treatMethodsAsReadonly,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index f2a07d80bbb2..8fd23a7bea50 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -30,7 +30,7 @@ const functionScopeBoundaries = [
 ].join(', ');
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ onlyInlineLambdas: false }],
+  name: 'prefer-readonly',
   meta: {
     type: 'suggestion',
     docs: {
@@ -55,7 +55,7 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'prefer-readonly',
+  defaultOptions: [{ onlyInlineLambdas: false }],
   create(context, [{ onlyInlineLambdas }]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 6796d02bd412..8da4992ed537 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -33,7 +33,7 @@ const getMemberExpressionName = (
 };
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-reduce-type-parameter',
   meta: {
     type: 'problem',
     docs: {
@@ -49,7 +49,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'prefer-reduce-type-parameter',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index 3370712ef23d..c51ed2dd438e 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -22,7 +22,7 @@ enum ArgumentType {
 }
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-regexp-exec',
   meta: {
     type: 'suggestion',
     docs: {
@@ -38,7 +38,7 @@ export default createRule({
     schema: [],
   },
 
-  name: 'prefer-regexp-exec',
+  defaultOptions: [],
   create(context) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
     const services = getParserServices(context);
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 47b2e4028e60..8e7412b29ee4 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -14,7 +14,7 @@ type FunctionLike =
   | TSESTree.MethodDefinition['value'];
 
 export default createRule({
-  defaultOptions: [],
+  name: 'prefer-return-this-type',
   meta: {
     type: 'suggestion',
     docs: {
@@ -30,7 +30,7 @@ export default createRule({
     schema: [],
   },
 
-  name: 'prefer-return-this-type',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index e8646408b4eb..6aaebc20a98c 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -28,7 +28,7 @@ export type Options = [
 type MessageIds = 'preferEndsWith' | 'preferStartsWith';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [{ allowSingleElementEquality: 'never' }],
+  name: 'prefer-string-starts-ends-with',
   meta: {
     type: 'suggestion',
     docs: {
@@ -58,7 +58,7 @@ export default createRule<Options, MessageIds>({
     ],
   },
 
-  name: 'prefer-string-starts-ends-with',
+  defaultOptions: [{ allowSingleElementEquality: 'never' }],
   create(context, [{ allowSingleElementEquality }]) {
     const globalScope = context.sourceCode.getScope(context.sourceCode.ast);
 
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 2b165c237d83..7b21d55378aa 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -8,7 +8,7 @@ import { createRule } from '../util';
 type MessageIds = 'preferExpectErrorComment';
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'prefer-ts-expect-error',
   meta: {
     type: 'problem',
     deprecated: true,
@@ -23,7 +23,7 @@ export default createRule<[], MessageIds>({
     replacedBy: ['@typescript-eslint/ban-ts-comment'],
     schema: [],
   },
-  name: 'prefer-ts-expect-error',
+  defaultOptions: [],
   create(context) {
     const tsIgnoreRegExpSingleLine = /^\s*\/?\s*@ts-ignore/;
     const tsIgnoreRegExpMultiLine = /^\s*(?:\/|\*)*\s*@ts-ignore/;
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index 4be4f2344f0d..bc92232846e8 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -26,16 +26,7 @@ type Options = [
 type MessageIds = 'missingAsync';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowedPromiseNames: [],
-      checkArrowFunctions: true,
-      checkFunctionDeclarations: true,
-      checkFunctionExpressions: true,
-      checkMethodDeclarations: true,
-    },
-  ],
+  name: 'promise-function-async',
   meta: {
     type: 'suggestion',
     docs: {
@@ -81,7 +72,16 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'promise-function-async',
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowedPromiseNames: [],
+      checkArrowFunctions: true,
+      checkFunctionDeclarations: true,
+      checkFunctionExpressions: true,
+      checkMethodDeclarations: true,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index 60a628a17437..c2c69cbcf1d4 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -16,11 +16,7 @@ export type Options = [
 export type MessageIds = 'requireCompare';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoreStringArrays: true,
-    },
-  ],
+  name: 'require-array-sort-compare',
   meta: {
     type: 'problem',
     docs: {
@@ -46,7 +42,11 @@ export default createRule<Options, MessageIds>({
     ],
   },
 
-  name: 'require-array-sort-compare',
+  defaultOptions: [
+    {
+      ignoreStringArrays: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index 11ed06d43f33..f6018d5e846a 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -29,7 +29,7 @@ type FunctionNode =
   | TSESTree.FunctionExpression;
 
 export default createRule({
-  defaultOptions: [],
+  name: 'require-await',
   meta: {
     type: 'suggestion',
     docs: {
@@ -46,7 +46,7 @@ export default createRule({
     },
     schema: [],
   },
-  name: 'require-await',
+  defaultOptions: [],
   create(context) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index e595e15c7d98..80ad7ea4b151 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -26,16 +26,7 @@ type Options = [
 type MessageIds = 'bigintAndNumber' | 'invalid' | 'mismatched';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumberAndString: true,
-      allowRegExp: true,
-      skipCompoundAssignments: false,
-    },
-  ],
+  name: 'restrict-plus-operands',
   meta: {
     type: 'problem',
     docs: {
@@ -98,7 +89,16 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'restrict-plus-operands',
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumberAndString: true,
+      allowRegExp: true,
+      skipCompoundAssignments: false,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index 44a8fd5383e1..bc9784ed8564 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -57,15 +57,7 @@ type Options = [
 type MessageId = 'invalidType';
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [
-    {
-      allowAny: true,
-      allowBoolean: true,
-      allowNullish: true,
-      allowNumber: true,
-      allowRegExp: true,
-    },
-  ],
+  name: 'restrict-template-expressions',
   meta: {
     type: 'problem',
     docs: {
@@ -105,7 +97,15 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'restrict-template-expressions',
+  defaultOptions: [
+    {
+      allowAny: true,
+      allowBoolean: true,
+      allowNullish: true,
+      allowNumber: true,
+      allowRegExp: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index b3ec1d5cd8a3..579172859f22 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -32,7 +32,7 @@ type Option =
   | 'never';
 
 export default createRule({
-  defaultOptions: ['in-try-catch'],
+  name: 'return-await',
   meta: {
     type: 'problem',
     docs: {
@@ -69,7 +69,7 @@ export default createRule({
       },
     ],
   },
-  name: 'return-await',
+  defaultOptions: ['in-try-catch'],
   create(context, [option]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index bc533345c55a..3f8b8e60a958 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -116,27 +116,7 @@ export type Options = [
 export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      caseSensitive: false,
-      checkIntersections: true,
-      checkUnions: true,
-      groupOrder: [
-        Group.named,
-        Group.keyword,
-        Group.operator,
-        Group.literal,
-        Group.function,
-        Group.import,
-        Group.conditional,
-        Group.object,
-        Group.tuple,
-        Group.intersection,
-        Group.union,
-        Group.nullish,
-      ],
-    },
-  ],
+  name: 'sort-type-constituents',
   meta: {
     type: 'suggestion',
     deprecated: true,
@@ -184,7 +164,27 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'sort-type-constituents',
+  defaultOptions: [
+    {
+      caseSensitive: false,
+      checkIntersections: true,
+      checkUnions: true,
+      groupOrder: [
+        Group.named,
+        Group.keyword,
+        Group.operator,
+        Group.literal,
+        Group.function,
+        Group.import,
+        Group.conditional,
+        Group.object,
+        Group.tuple,
+        Group.intersection,
+        Group.union,
+        Group.nullish,
+      ],
+    },
+  ],
   create(
     context,
     [{ caseSensitive, checkIntersections, checkUnions, groupOrder }],
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index ba65ecc35d01..dbdfacb03d4a 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -55,19 +55,7 @@ export type MessageId =
   | 'noStrictNullCheck';
 
 export default createRule<Options, MessageId>({
-  defaultOptions: [
-    {
-      allowAny: false,
-      allowNullableBoolean: false,
-      allowNullableEnum: false,
-      allowNullableNumber: false,
-      allowNullableObject: true,
-      allowNullableString: false,
-      allowNumber: true,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-      allowString: true,
-    },
-  ],
+  name: 'strict-boolean-expressions',
   meta: {
     type: 'suggestion',
     docs: {
@@ -156,7 +144,19 @@ export default createRule<Options, MessageId>({
       },
     ],
   },
-  name: 'strict-boolean-expressions',
+  defaultOptions: [
+    {
+      allowAny: false,
+      allowNullableBoolean: false,
+      allowNullableEnum: false,
+      allowNullableNumber: false,
+      allowNullableObject: true,
+      allowNullableString: false,
+      allowNumber: true,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      allowString: true,
+    },
+  ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index c47004745e88..b376784d0331 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -46,12 +46,7 @@ type MessageIds =
   | 'switchIsNotExhaustive';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      allowDefaultCaseForExhaustiveSwitch: true,
-      requireDefaultForNonUnion: false,
-    },
-  ],
+  name: 'switch-exhaustiveness-check',
   meta: {
     type: 'suggestion',
     docs: {
@@ -83,7 +78,12 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'switch-exhaustiveness-check',
+  defaultOptions: [
+    {
+      allowDefaultCaseForExhaustiveSwitch: true,
+      requireDefaultForNonUnion: false,
+    },
+  ],
   create(
     context,
     [{ allowDefaultCaseForExhaustiveSwitch, requireDefaultForNonUnion }],
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index db24201c48ca..c2999060415e 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -14,13 +14,7 @@ type Options = [
 type MessageIds = 'tripleSlashReference';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      lib: 'always',
-      path: 'never',
-      types: 'prefer-import',
-    },
-  ],
+  name: 'triple-slash-reference',
   meta: {
     type: 'suggestion',
     docs: {
@@ -53,7 +47,13 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'triple-slash-reference',
+  defaultOptions: [
+    {
+      lib: 'always',
+      path: 'never',
+      types: 'prefer-import',
+    },
+  ],
   create(context, [{ lib, path, types }]) {
     let programNode: TSESTree.Node | undefined;
 
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index 309fe486a131..c46b4810451a 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -20,18 +20,7 @@ type Options = { [k in OptionKeys]?: boolean };
 type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed';
 
 export default createRule<[Options], MessageIds>({
-  defaultOptions: [
-    {
-      [OptionKeys.ArrayDestructuring]: false,
-      [OptionKeys.ArrowParameter]: false,
-      [OptionKeys.MemberVariableDeclaration]: false,
-      [OptionKeys.ObjectDestructuring]: false,
-      [OptionKeys.Parameter]: false,
-      [OptionKeys.PropertyDeclaration]: false,
-      [OptionKeys.VariableDeclaration]: false,
-      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
-    },
-  ],
+  name: 'typedef',
   meta: {
     type: 'suggestion',
     docs: {
@@ -58,7 +47,18 @@ export default createRule<[Options], MessageIds>({
       },
     ],
   },
-  name: 'typedef',
+  defaultOptions: [
+    {
+      [OptionKeys.ArrayDestructuring]: false,
+      [OptionKeys.ArrowParameter]: false,
+      [OptionKeys.MemberVariableDeclaration]: false,
+      [OptionKeys.ObjectDestructuring]: false,
+      [OptionKeys.Parameter]: false,
+      [OptionKeys.PropertyDeclaration]: false,
+      [OptionKeys.VariableDeclaration]: false,
+      [OptionKeys.VariableDeclarationIgnoreFunction]: false,
+    },
+  ],
   create(
     context,
     [
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index a1ee86a2aa18..69eeb5b31a7b 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -104,11 +104,7 @@ const BASE_MESSAGE =
   'Avoid referencing unbound methods which may cause unintentional scoping of `this`.';
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoreStatic: false,
-    },
-  ],
+  name: 'unbound-method',
   meta: {
     type: 'problem',
     docs: {
@@ -135,7 +131,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'unbound-method',
+  defaultOptions: [
+    {
+      ignoreStatic: false,
+    },
+  ],
   create(context, [{ ignoreStatic }]) {
     const services = getParserServices(context);
     const currentSourceFile = services.program.getSourceFile(context.filename);
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 5e7994e4c683..20561350163e 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -65,11 +65,7 @@ type Options = [
 ];
 
 export default createRule<Options, MessageIds>({
-  defaultOptions: [
-    {
-      ignoreDifferentlyNamedParameters: false,
-    },
-  ],
+  name: 'unified-signatures',
   meta: {
     type: 'suggestion',
     docs: {
@@ -99,7 +95,11 @@ export default createRule<Options, MessageIds>({
       },
     ],
   },
-  name: 'unified-signatures',
+  defaultOptions: [
+    {
+      ignoreDifferentlyNamedParameters: false,
+    },
+  ],
   create(context, [{ ignoreDifferentlyNamedParameters }]) {
     //----------------------------------------------------------------------
     // Helpers
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index a7515130c6ba..31e05dfc494a 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -41,7 +41,7 @@ const getStaticMemberAccessKey = (
   computed ? getStaticValue(property, scope) : { value: property.name };
 
 export default createRule<[], MessageIds>({
-  defaultOptions: [],
+  name: 'use-unknown-in-catch-callback-variable',
   meta: {
     type: 'suggestion',
     docs: {
@@ -70,7 +70,7 @@ export default createRule<[], MessageIds>({
     schema: [],
   },
 
-  name: 'use-unknown-in-catch-callback-variable',
+  defaultOptions: [],
   create(context) {
     const { esTreeNodeToTSNodeMap, program } = getParserServices(context);
     const checker = program.getTypeChecker();

From 91707d53f68be70a27195ca1b9b957e3350462d0 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Mon, 16 Sep 2024 16:05:56 -0400
Subject: [PATCH 07/13] Preferences around reports and valid/invalid

---
 eslint.config.mjs                             |   11 +-
 .../src/rules/adjacent-overload-signatures.ts |    4 +-
 .../eslint-plugin/src/rules/array-type.ts     |   12 +-
 .../eslint-plugin/src/rules/await-thenable.ts |    4 +-
 .../eslint-plugin/src/rules/ban-ts-comment.ts |   16 +-
 .../src/rules/ban-tslint-comment.ts           |    4 +-
 .../src/rules/class-literal-property-style.ts |    8 +-
 .../src/rules/class-methods-use-this.ts       |    6 +-
 .../rules/consistent-generic-constructors.ts  |    8 +-
 .../rules/consistent-indexed-object-style.ts  |    8 +-
 .../src/rules/consistent-type-assertions.ts   |   10 +-
 .../src/rules/consistent-type-definitions.ts  |    6 +-
 .../src/rules/consistent-type-exports.ts      |   16 +-
 .../src/rules/consistent-type-imports.ts      |   20 +-
 .../src/rules/default-param-last.ts           |    2 +-
 .../rules/explicit-function-return-type.ts    |    4 +-
 .../rules/explicit-member-accessibility.ts    |   34 +-
 .../rules/explicit-module-boundary-types.ts   |   26 +-
 .../src/rules/member-ordering.ts              |   12 +-
 .../src/rules/method-signature-style.ts       |   16 +-
 .../src/rules/no-array-constructor.ts         |    4 +-
 .../src/rules/no-array-delete.ts              |    4 +-
 .../src/rules/no-base-to-string.ts            |    4 +-
 .../rules/no-confusing-non-null-assertion.ts  |   12 +-
 .../src/rules/no-confusing-void-expression.ts |   26 +-
 .../src/rules/no-duplicate-enum-values.ts     |    4 +-
 .../rules/no-duplicate-type-constituents.ts   |    6 +-
 .../src/rules/no-dynamic-delete.ts            |    4 +-
 .../src/rules/no-empty-interface.ts           |    6 +-
 .../src/rules/no-empty-object-type.ts         |   16 +-
 .../src/rules/no-explicit-any.ts              |    6 +-
 .../src/rules/no-extra-non-null-assertion.ts  |    4 +-
 .../src/rules/no-extraneous-class.ts          |    6 +-
 .../src/rules/no-floating-promises.ts         |   12 +-
 .../src/rules/no-implied-eval.ts              |    6 +-
 .../src/rules/no-import-type-side-effects.ts  |    4 +-
 .../src/rules/no-inferrable-types.ts          |    4 +-
 .../src/rules/no-invalid-void-type.ts         |   10 +-
 .../eslint-plugin/src/rules/no-loop-func.ts   |    4 +-
 .../src/rules/no-magic-numbers.ts             |    4 +-
 .../src/rules/no-meaningless-void-operator.ts |   10 +-
 .../eslint-plugin/src/rules/no-misused-new.ts |    6 +-
 .../src/rules/no-misused-promises.ts          |   24 +-
 .../eslint-plugin/src/rules/no-mixed-enums.ts |    2 +-
 .../eslint-plugin/src/rules/no-namespace.ts   |    2 +-
 ...no-non-null-asserted-nullish-coalescing.ts |    4 +-
 .../no-non-null-asserted-optional-chain.ts    |    8 +-
 .../src/rules/no-non-null-assertion.ts        |   14 +-
 .../eslint-plugin/src/rules/no-redeclare.ts   |   16 +-
 .../rules/no-redundant-type-constituents.ts   |   36 +-
 .../src/rules/no-require-imports.ts           |    4 +-
 .../src/rules/no-restricted-types.ts          |    6 +-
 packages/eslint-plugin/src/rules/no-shadow.ts |    4 +-
 .../eslint-plugin/src/rules/no-this-alias.ts  |    2 +-
 .../eslint-plugin/src/rules/no-type-alias.ts  |   10 +-
 .../no-unnecessary-boolean-literal-compare.ts |   20 +-
 .../src/rules/no-unnecessary-condition.ts     |   18 +-
 ...necessary-parameter-property-assignment.ts |    2 +-
 .../src/rules/no-unnecessary-qualifier.ts     |    4 +-
 .../no-unnecessary-template-expression.ts     |    8 +-
 .../rules/no-unnecessary-type-arguments.ts    |    4 +-
 .../rules/no-unnecessary-type-assertion.ts    |   16 +-
 .../rules/no-unnecessary-type-constraint.ts   |    6 +-
 .../rules/no-unnecessary-type-parameters.ts   |    4 +-
 .../src/rules/no-unsafe-argument.ts           |   12 +-
 .../src/rules/no-unsafe-assignment.ts         |   24 +-
 .../eslint-plugin/src/rules/no-unsafe-call.ts |    4 +-
 .../rules/no-unsafe-declaration-merging.ts    |    2 +-
 .../src/rules/no-unsafe-enum-comparison.ts    |    6 +-
 .../src/rules/no-unsafe-function-type.ts      |    2 +-
 .../src/rules/no-unsafe-member-access.ts      |    8 +-
 .../src/rules/no-unsafe-return.ts             |    8 +-
 .../src/rules/no-unsafe-unary-minus.ts        |    4 +-
 .../eslint-plugin/src/rules/no-unused-vars.ts |   24 +-
 .../src/rules/no-use-before-define.ts         |    4 +-
 .../src/rules/no-useless-empty-export.ts      |    4 +-
 .../src/rules/no-var-requires.ts              |    2 +-
 .../src/rules/no-wrapper-object-types.ts      |    4 +-
 .../non-nullable-type-assertion-style.ts      |    4 +-
 .../src/rules/only-throw-error.ts             |    4 +-
 .../src/rules/parameter-properties.ts         |    8 +-
 .../src/rules/prefer-as-const.ts              |    8 +-
 .../src/rules/prefer-destructuring.ts         |    4 +-
 .../src/rules/prefer-enum-initializers.ts     |   10 +-
 .../eslint-plugin/src/rules/prefer-find.ts    |    8 +-
 .../eslint-plugin/src/rules/prefer-for-of.ts  |    2 +-
 .../src/rules/prefer-function-type.ts         |    8 +-
 .../src/rules/prefer-includes.ts              |    6 +-
 .../src/rules/prefer-literal-enum-member.ts   |    2 +-
 .../src/rules/prefer-namespace-keyword.ts     |    4 +-
 .../src/rules/prefer-nullish-coalescing.ts    |    8 +-
 .../src/rules/prefer-optional-chain.ts        |    4 +-
 .../src/rules/prefer-promise-reject-errors.ts |    2 +-
 .../rules/prefer-readonly-parameter-types.ts  |    2 +-
 .../src/rules/prefer-readonly.ts              |    2 +-
 .../src/rules/prefer-reduce-type-parameter.ts |    4 +-
 .../src/rules/prefer-regexp-exec.ts           |   18 +-
 .../src/rules/prefer-return-this-type.ts      |    4 +-
 .../rules/prefer-string-starts-ends-with.ts   |   24 +-
 .../src/rules/prefer-ts-expect-error.ts       |    4 +-
 .../src/rules/promise-function-async.ts       |    8 +-
 .../src/rules/require-array-sort-compare.ts   |    2 +-
 .../eslint-plugin/src/rules/require-await.ts  |    8 +-
 .../src/rules/restrict-plus-operands.ts       |   16 +-
 .../rules/restrict-template-expressions.ts    |    4 +-
 .../eslint-plugin/src/rules/return-await.ts   |   12 +-
 .../src/rules/sort-type-constituents.ts       |    8 +-
 .../src/rules/strict-boolean-expressions.ts   |  138 +-
 .../src/rules/switch-exhaustiveness-check.ts  |   14 +-
 .../src/rules/triple-slash-reference.ts       |    8 +-
 packages/eslint-plugin/src/rules/typedef.ts   |    4 +-
 .../eslint-plugin/src/rules/unbound-method.ts |    2 +-
 .../src/rules/unified-signatures.ts           |   14 +-
 .../use-unknown-in-catch-callback-variable.ts |   16 +-
 .../adjacent-overload-signatures.test.ts      | 1192 +--
 .../tests/rules/array-type.test.ts            | 2628 +++----
 .../tests/rules/await-thenable.test.ts        |  359 +-
 .../tests/rules/ban-ts-comment.test.ts        |  436 +-
 .../tests/rules/ban-tslint-comment.test.ts    |   28 +-
 .../class-literal-property-style.test.ts      |  506 +-
 .../consistent-generic-constructors.test.ts   |  258 +-
 .../consistent-indexed-object-style.test.ts   |  274 +-
 .../tests/rules/consistent-return.test.ts     |  390 +-
 .../rules/consistent-type-assertions.test.ts  |  124 +-
 .../rules/consistent-type-definitions.test.ts |  108 +-
 .../rules/consistent-type-exports.test.ts     |   78 +-
 .../rules/consistent-type-imports.test.ts     | 1306 +--
 .../tests/rules/default-param-last.test.ts    |  212 +-
 .../tests/rules/dot-notation.test.ts          |  256 +-
 .../explicit-function-return-type.test.ts     | 2333 +++---
 .../explicit-member-accessibility.test.ts     | 2462 +++---
 .../explicit-module-boundary-types.test.ts    | 2664 +++----
 .../tests/rules/init-declarations.test.ts     | 1130 +--
 .../tests/rules/max-params.test.ts            |   82 +-
 .../tests/rules/member-ordering.test.ts       | 6368 +++++++--------
 .../rules/method-signature-style.test.ts      |  258 +-
 .../tests/rules/no-array-constructor.test.ts  |   57 +-
 .../tests/rules/no-array-delete.test.ts       |   83 +-
 .../tests/rules/no-base-to-string.test.ts     |  160 +-
 .../no-confusing-non-null-assertion.test.ts   |   18 +-
 .../no-confusing-void-expression.test.ts      |  215 +-
 .../tests/rules/no-dupe-class-members.test.ts |  150 +-
 .../rules/no-duplicate-enum-values.test.ts    |  116 +-
 .../no-duplicate-type-constituents.test.ts    |  292 +-
 .../tests/rules/no-dynamic-delete.test.ts     |   92 +-
 .../tests/rules/no-empty-function.test.ts     |  151 +-
 .../tests/rules/no-empty-interface.test.ts    |   82 +-
 .../tests/rules/no-empty-object-type.test.ts  |  138 +-
 .../tests/rules/no-explicit-any.test.ts       | 1986 ++---
 .../rules/no-extra-non-null-assertion.test.ts |   74 +-
 .../tests/rules/no-extraneous-class.test.ts   |  167 +-
 .../tests/rules/no-floating-promises.test.ts  | 6999 ++++++++---------
 .../tests/rules/no-for-in-array.test.ts       |   25 +-
 .../tests/rules/no-implied-eval.test.ts       | 1421 ++--
 .../rules/no-import-type-side-effects.test.ts |   28 +-
 .../tests/rules/no-inferrable-types.test.ts   |  128 +-
 .../tests/rules/no-invalid-this.test.ts       | 1179 ++-
 .../tests/rules/no-invalid-void-type.test.ts  |  196 +-
 .../tests/rules/no-loop-func.test.ts          |  442 +-
 .../tests/rules/no-loss-of-precision.test.ts  |   16 +-
 .../tests/rules/no-magic-numbers.test.ts      |  461 +-
 .../no-meaningless-void-operator.test.ts      |   38 +-
 .../tests/rules/no-misused-new.test.ts        |  136 +-
 .../tests/rules/no-misused-promises.test.ts   | 2771 ++++---
 .../tests/rules/no-mixed-enums.test.ts        |  480 +-
 .../tests/rules/no-namespace.test.ts          |  136 +-
 ...n-null-asserted-nullish-coalescing.test.ts |  110 +-
 ...o-non-null-asserted-optional-chain.test.ts |   30 +-
 .../tests/rules/no-non-null-assertion.test.ts |   18 +-
 .../tests/rules/no-redeclare.test.ts          |  260 +-
 .../no-redundant-type-constituents.test.ts    |  305 +-
 .../tests/rules/no-require-imports.test.ts    |  208 +-
 .../tests/rules/no-restricted-imports.test.ts |  572 +-
 .../tests/rules/no-restricted-types.test.ts   |   56 +-
 .../tests/rules/no-this-alias.test.ts         |   63 +-
 .../tests/rules/no-type-alias.test.ts         | 4252 +++++-----
 ...nnecessary-boolean-literal-compare.test.ts |  125 +-
 .../rules/no-unnecessary-condition.test.ts    | 3634 ++++-----
 ...sary-parameter-property-assignment.test.ts |  324 +-
 .../rules/no-unnecessary-qualifier.test.ts    |  133 +-
 ...no-unnecessary-template-expression.test.ts |  234 +-
 .../no-unnecessary-type-arguments.test.ts     |  282 +-
 .../no-unnecessary-type-assertion.test.ts     | 1100 +--
 .../no-unnecessary-type-constraint.test.ts    |   34 +-
 .../no-unnecessary-type-parameters.test.ts    | 1179 ++-
 .../tests/rules/no-unsafe-argument.test.ts    |  212 +-
 .../tests/rules/no-unsafe-assignment.test.ts  |  196 +-
 .../tests/rules/no-unsafe-call.test.ts        |   62 +-
 .../no-unsafe-declaration-merging.test.ts     |   92 +-
 .../rules/no-unsafe-enum-comparison.test.ts   | 2036 ++---
 .../rules/no-unsafe-function-type.test.ts     |   16 +-
 .../rules/no-unsafe-member-access.test.ts     |  108 +-
 .../tests/rules/no-unsafe-return.test.ts      |  294 +-
 .../tests/rules/no-unsafe-unary-minus.test.ts |   28 +-
 .../tests/rules/no-unused-expressions.test.ts |  124 +-
 .../tests/rules/no-use-before-define.test.ts  | 1910 ++---
 .../rules/no-useless-constructor.test.ts      |  176 +-
 .../rules/no-useless-empty-export.test.ts     |   96 +-
 .../tests/rules/no-var-requires.test.ts       |   68 +-
 .../rules/no-wrapper-object-types.test.ts     |  110 +-
 .../non-nullable-type-assertion-style.test.ts |  141 +-
 .../tests/rules/only-throw-error.test.ts      |  244 +-
 .../tests/rules/parameter-properties.test.ts  | 1146 +--
 .../tests/rules/prefer-as-const.test.ts       |  166 +-
 .../tests/rules/prefer-destructuring.test.ts  | 1362 ++--
 .../tests/rules/prefer-find.test.ts           |  127 +-
 .../tests/rules/prefer-for-of.test.ts         |  370 +-
 .../tests/rules/prefer-function-type.test.ts  |   71 +-
 .../tests/rules/prefer-includes.test.ts       |  166 +-
 .../rules/prefer-literal-enum-member.test.ts  |  220 +-
 .../rules/prefer-namespace-keyword.test.ts    |   14 +-
 .../rules/prefer-nullish-coalescing.test.ts   | 1828 ++---
 .../prefer-promise-reject-errors.test.ts      |  504 +-
 .../prefer-readonly-parameter-types.test.ts   | 1268 +--
 .../tests/rules/prefer-readonly.test.ts       | 3246 ++++----
 .../prefer-reduce-type-parameter.test.ts      |   86 +-
 .../tests/rules/prefer-regexp-exec.test.ts    |  182 +-
 .../rules/prefer-return-this-type.test.ts     |  134 +-
 .../prefer-string-starts-ends-with.test.ts    | 1768 ++---
 .../rules/prefer-ts-expect-error.test.ts      |   56 +-
 .../rules/promise-function-async.test.ts      |  334 +-
 .../rules/require-array-sort-compare.test.ts  |  240 +-
 .../tests/rules/require-await.test.ts         |  651 +-
 .../rules/restrict-plus-operands.test.ts      | 1698 ++--
 .../restrict-template-expressions.test.ts     |  673 +-
 .../tests/rules/return-await.test.ts          | 2098 ++---
 .../rules/sort-type-constituents.test.ts      |  132 +-
 .../rules/strict-boolean-expressions.test.ts  | 4356 +++++-----
 .../rules/switch-exhaustiveness-check.test.ts | 2978 +++----
 .../rules/triple-slash-reference.test.ts      |  126 +-
 .../eslint-plugin/tests/rules/typedef.test.ts | 1146 +--
 .../tests/rules/unbound-method.test.ts        | 2024 ++---
 .../tests/rules/unified-signatures.test.ts    |  424 +-
 ...unknown-in-catch-callback-variable.test.ts |  299 +-
 234 files changed, 45748 insertions(+), 45771 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 6596d07bb2a2..48f042c9fd87 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -610,11 +610,12 @@ export default tseslint.config(
         'error',
         {
           customGroups: {
-            primary: ['type', 'name'],
-            secondary: ['meta'],
-            tertiary: ['defaultOptions'],
+            primary: ['loc', 'name', 'node', 'type'],
+            secondary: ['meta', 'messageId'],
+            tertiary: ['defaultOptions', 'data'],
+            quaternary: ['fix'],
           },
-          groups: ['primary', 'secondary', 'tertiary', 'unknown'],
+          groups: ['primary', 'secondary', 'tertiary', 'quaternary', 'unknown'],
         },
       ],
     },
@@ -625,7 +626,7 @@ export default tseslint.config(
       'perfectionist/sort-objects': [
         'error',
         {
-          customGroups: { top: ['invalid'] },
+          customGroups: { top: ['valid'] },
           groups: ['top', 'unknown'],
         },
       ],
diff --git a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
index e51ce81515b4..9922f43a6d1b 100644
--- a/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
+++ b/packages/eslint-plugin/src/rules/adjacent-overload-signatures.ts
@@ -145,11 +145,11 @@ export default createRule({
         );
         if (index > -1 && !isSameMethod(method, lastMethod)) {
           context.report({
+            node: member,
+            messageId: 'adjacentSignature',
             data: {
               name: `${method.static ? 'static ' : ''}${method.name}`,
             },
-            messageId: 'adjacentSignature',
-            node: member,
           });
         } else if (index === -1) {
           seenMethods.push(method);
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 23b12c187237..08330497cb82 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -176,6 +176,8 @@ export default createRule<Options, MessageIds>({
         const errorNode = isReadonly ? node.parent : node;
 
         context.report({
+          node: errorNode,
+          messageId,
           data: {
             type: getMessageType(node.elementType),
             className: isReadonly ? 'ReadonlyArray' : 'Array',
@@ -196,8 +198,6 @@ export default createRule<Options, MessageIds>({
               ),
             ];
           },
-          messageId,
-          node: errorNode,
         });
       },
 
@@ -244,6 +244,8 @@ export default createRule<Options, MessageIds>({
         if (!typeParams || typeParams.length === 0) {
           // Create an 'any' array
           context.report({
+            node,
+            messageId,
             data: {
               type: 'any',
               className: isReadonlyArrayType ? 'ReadonlyArray' : 'Array',
@@ -252,8 +254,6 @@ export default createRule<Options, MessageIds>({
             fix(fixer) {
               return fixer.replaceText(node, `${readonlyPrefix}any[]`);
             },
-            messageId,
-            node,
           });
 
           return;
@@ -278,6 +278,8 @@ export default createRule<Options, MessageIds>({
         }`;
         const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`;
         context.report({
+          node,
+          messageId,
           data: {
             type: getMessageType(type),
             className: isReadonlyArrayType ? node.typeName.name : 'Array',
@@ -289,8 +291,6 @@ export default createRule<Options, MessageIds>({
               fixer.replaceTextRange([type.range[1], node.range[1]], end),
             ];
           },
-          messageId,
-          node,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
index 636c673b8401..e629b268a9c3 100644
--- a/packages/eslint-plugin/src/rules/await-thenable.ts
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -44,10 +44,11 @@ export default createRule({
 
         if (!tsutils.isThenableType(checker, originalNode.expression, type)) {
           context.report({
-            messageId: 'await',
             node,
+            messageId: 'await',
             suggest: [
               {
+                messageId: 'removeAwait',
                 fix(fixer): TSESLint.RuleFix {
                   const awaitKeyword = nullThrows(
                     context.sourceCode.getFirstToken(node, isAwaitKeyword),
@@ -56,7 +57,6 @@ export default createRule({
 
                   return fixer.remove(awaitKeyword);
                 },
-                messageId: 'removeAwait',
               },
             ],
           });
diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
index ce19ad727a2f..47f6e02215b8 100644
--- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts
@@ -198,10 +198,11 @@ export default createRule<[Options], MessageIds>({
             if (directive === 'ignore') {
               // Special case to suggest @ts-expect-error instead of @ts-ignore
               context.report({
-                messageId: 'tsIgnoreInsteadOfExpectError',
                 node: comment,
+                messageId: 'tsIgnoreInsteadOfExpectError',
                 suggest: [
                   {
+                    messageId: 'replaceTsIgnoreWithTsExpectError',
                     fix(fixer): TSESLint.RuleFix {
                       const commentText = comment.value.replace(
                         /@ts-ignore/,
@@ -214,15 +215,14 @@ export default createRule<[Options], MessageIds>({
                           : `/*${commentText}*/`,
                       );
                     },
-                    messageId: 'replaceTsIgnoreWithTsExpectError',
                   },
                 ],
               });
             } else {
               context.report({
-                data: { directive },
-                messageId: 'tsDirectiveComment',
                 node: comment,
+                messageId: 'tsDirectiveComment',
+                data: { directive },
               });
             }
           }
@@ -241,15 +241,15 @@ export default createRule<[Options], MessageIds>({
               )
             ) {
               context.report({
-                data: { directive, minimumDescriptionLength },
-                messageId: 'tsDirectiveCommentRequiresDescription',
                 node: comment,
+                messageId: 'tsDirectiveCommentRequiresDescription',
+                data: { directive, minimumDescriptionLength },
               });
             } else if (format && !format.test(description)) {
               context.report({
-                data: { directive, format: format.source },
-                messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
                 node: comment,
+                messageId: 'tsDirectiveCommentDescriptionNotMatchPattern',
+                data: { directive, format: format.source },
               });
             }
           }
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 6304e6d9d0f6..48be960677ca 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -37,6 +37,8 @@ export default createRule({
         comments.forEach(c => {
           if (ENABLE_DISABLE_REGEX.test(c.value)) {
             context.report({
+              node: c,
+              messageId: 'commentDetected',
               data: { text: toText(c.value, c.type) },
               fix(fixer) {
                 const rangeStart = context.sourceCode.getIndexFromLoc({
@@ -49,8 +51,6 @@ export default createRule({
                 });
                 return fixer.removeRange([rangeStart, rangeEnd + 1]);
               },
-              messageId: 'commentDetected',
-              node: c,
             });
           }
         });
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
index 3f5f1a2c58e5..b2cb2c9ff6c4 100644
--- a/packages/eslint-plugin/src/rules/class-literal-property-style.ts
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -109,10 +109,11 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          messageId: 'preferGetterStyle',
           node: node.key,
+          messageId: 'preferGetterStyle',
           suggest: [
             {
+              messageId: 'preferGetterStyleSuggestion',
               fix(fixer): TSESLint.RuleFix {
                 const name = context.sourceCode.getText(node.key);
 
@@ -123,7 +124,6 @@ export default createRule<Options, MessageIds>({
 
                 return fixer.replaceText(node, text);
               },
-              messageId: 'preferGetterStyleSuggestion',
             },
           ],
         });
@@ -182,10 +182,11 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            messageId: 'preferFieldStyle',
             node: node.key,
+            messageId: 'preferFieldStyle',
             suggest: [
               {
+                messageId: 'preferFieldStyleSuggestion',
                 fix(fixer): TSESLint.RuleFix {
                   const name = context.sourceCode.getText(node.key);
 
@@ -197,7 +198,6 @@ export default createRule<Options, MessageIds>({
 
                   return fixer.replaceText(node, text);
                 },
-                messageId: 'preferFieldStyleSuggestion',
               },
             ],
           });
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
index cccf79d1f1bc..5802b12e16f3 100644
--- a/packages/eslint-plugin/src/rules/class-methods-use-this.ts
+++ b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
@@ -215,12 +215,12 @@ export default createRule<Options, MessageIds>({
 
       if (isIncludedInstanceMethod(stackContext.member)) {
         context.report({
+          loc: getFunctionHeadLoc(node, context.sourceCode),
+          node,
+          messageId: 'missingThis',
           data: {
             name: getFunctionNameWithKind(node),
           },
-          loc: getFunctionHeadLoc(node, context.sourceCode),
-          messageId: 'missingThis',
-          node,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
index 280736b33178..f3033536b653 100644
--- a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
+++ b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -81,6 +81,8 @@ export default createRule<Options, MessageIds>({
               context.sourceCode.getText(callee) +
               context.sourceCode.getText(typeArguments);
             context.report({
+              node,
+              messageId: 'preferTypeAnnotation',
               fix(fixer) {
                 function getIDToAttachAnnotation():
                   | TSESTree.Node
@@ -106,8 +108,6 @@ export default createRule<Options, MessageIds>({
                   ),
                 ];
               },
-              messageId: 'preferTypeAnnotation',
-              node,
             });
           }
           return;
@@ -123,6 +123,8 @@ export default createRule<Options, MessageIds>({
             .getCommentsInside(lhs.typeArguments)
             .forEach(c => extraComments.delete(c));
           context.report({
+            node,
+            messageId: 'preferConstructor',
             *fix(fixer) {
               yield fixer.remove(lhs.parent);
               for (const comment of extraComments) {
@@ -139,8 +141,6 @@ export default createRule<Options, MessageIds>({
                 yield fixer.insertTextAfter(rhs.callee, '()');
               }
             },
-            messageId: 'preferConstructor',
-            node,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
index 5419f813a857..1908d274f0ff 100644
--- a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
+++ b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -78,6 +78,8 @@ export default createRule<Options, MessageIds>({
       }
 
       context.report({
+        node,
+        messageId: 'preferRecord',
         fix: safeFix
           ? (fixer): TSESLint.RuleFix => {
               const key = context.sourceCode.getText(keyType.typeAnnotation);
@@ -90,8 +92,6 @@ export default createRule<Options, MessageIds>({
               return fixer.replaceText(node, `${prefix}${record}${postfix}`);
             }
           : null,
-        messageId: 'preferRecord',
-        node,
       });
     }
 
@@ -112,13 +112,13 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
+            node,
+            messageId: 'preferIndexSignature',
             fix(fixer) {
               const key = context.sourceCode.getText(params[0]);
               const type = context.sourceCode.getText(params[1]);
               return fixer.replaceText(node, `{ [key: ${key}]: ${type} }`);
             },
-            messageId: 'preferIndexSignature',
-            node,
           });
         },
       }),
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index fd9f14f1ce3b..50af5fe4118f 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -114,6 +114,8 @@ export default createRule<Options, MessageIds>({
         return;
       }
       context.report({
+        node,
+        messageId,
         data:
           messageId !== 'never'
             ? { cast: context.sourceCode.getText(node.typeAnnotation) }
@@ -166,8 +168,6 @@ export default createRule<Options, MessageIds>({
                 );
               }
             : undefined,
-        messageId,
-        node,
       });
     }
 
@@ -222,6 +222,7 @@ export default createRule<Options, MessageIds>({
         ) {
           const { parent } = node;
           suggest.push({
+            messageId: 'replaceObjectTypeAssertionWithAnnotation',
             data: { cast: context.sourceCode.getText(node.typeAnnotation) },
             fix: fixer => [
               fixer.insertTextAfter(
@@ -233,10 +234,10 @@ export default createRule<Options, MessageIds>({
                 getTextWithParentheses(context.sourceCode, node.expression),
               ),
             ],
-            messageId: 'replaceObjectTypeAssertionWithAnnotation',
           });
         }
         suggest.push({
+          messageId: 'replaceObjectTypeAssertionWithSatisfies',
           data: { cast: context.sourceCode.getText(node.typeAnnotation) },
           fix: fixer => [
             fixer.replaceText(
@@ -248,12 +249,11 @@ export default createRule<Options, MessageIds>({
               ` satisfies ${context.sourceCode.getText(node.typeAnnotation)}`,
             ),
           ],
-          messageId: 'replaceObjectTypeAssertionWithSatisfies',
         });
 
         context.report({
-          messageId: 'unexpectedObjectTypeAssertion',
           node,
+          messageId: 'unexpectedObjectTypeAssertion',
           suggest,
         });
       }
diff --git a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
index 8cc6c96430bf..2505b7c54262 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-definitions.ts
@@ -50,6 +50,8 @@ export default createRule({
           node: TSESTree.TSTypeAliasDeclaration,
         ): void {
           context.report({
+            node: node.id,
+            messageId: 'interfaceOverType',
             fix(fixer) {
               const typeNode = node.typeParameters ?? node.id;
               const fixes: TSESLint.RuleFix[] = [];
@@ -78,8 +80,6 @@ export default createRule({
 
               return fixes;
             },
-            messageId: 'interfaceOverType',
-            node: node.id,
           });
         },
       }),
@@ -124,8 +124,8 @@ export default createRule({
                 return fixes;
               };
           context.report({
-            messageId: 'typeOverInterface',
             node: node.id,
+            messageId: 'typeOverInterface',
             /**
              * remove automatically fix when the interface is within a declare global
              * @see {@link https://github.com/typescript-eslint/typescript-eslint/issues/2707}
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
index 21f6cd982347..0738857222fe 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-exports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
@@ -157,8 +157,8 @@ export default createRule<Options, MessageIds>({
           (node.exportKind === 'type' && valueSpecifiers.length)
         ) {
           sourceExports.reportValueExports.push({
-            inlineTypeSpecifiers,
             node,
+            inlineTypeSpecifiers,
             typeBasedSpecifiers,
             valueSpecifiers,
           });
@@ -176,6 +176,8 @@ export default createRule<Options, MessageIds>({
             if (report.valueSpecifiers.length === 0) {
               // Export is all type-only with no type specifiers; convert the entire export to `export type`.
               context.report({
+                node: report.node,
+                messageId: 'typeOverValue',
                 *fix(fixer) {
                   yield* fixExportInsertType(
                     fixer,
@@ -183,8 +185,6 @@ export default createRule<Options, MessageIds>({
                     report.node,
                   );
                 },
-                messageId: 'typeOverValue',
-                node: report.node,
               });
               continue;
             }
@@ -198,6 +198,8 @@ export default createRule<Options, MessageIds>({
               const exportNames = allExportNames[0];
 
               context.report({
+                node: report.node,
+                messageId: 'singleExportIsType',
                 data: { exportNames },
                 *fix(fixer) {
                   if (fixMixedExportsWithInlineTypeSpecifier) {
@@ -210,13 +212,13 @@ export default createRule<Options, MessageIds>({
                     );
                   }
                 },
-                messageId: 'singleExportIsType',
-                node: report.node,
               });
             } else {
               const exportNames = formatWordList(allExportNames);
 
               context.report({
+                node: report.node,
+                messageId: 'multipleExportsAreTypes',
                 data: { exportNames },
                 *fix(fixer) {
                   if (fixMixedExportsWithInlineTypeSpecifier) {
@@ -229,8 +231,6 @@ export default createRule<Options, MessageIds>({
                     );
                   }
                 },
-                messageId: 'multipleExportsAreTypes',
-                node: report.node,
               });
             }
           }
@@ -288,7 +288,7 @@ function* fixSeparateNamedExports(
   sourceCode: Readonly<TSESLint.SourceCode>,
   report: ReportValueExport,
 ): IterableIterator<TSESLint.RuleFix> {
-  const { inlineTypeSpecifiers, node, typeBasedSpecifiers, valueSpecifiers } =
+  const { node, inlineTypeSpecifiers, typeBasedSpecifiers, valueSpecifiers } =
     report;
   const typeSpecifiers = typeBasedSpecifiers.concat(inlineTypeSpecifiers);
   const source = getSourceFromExport(node);
diff --git a/packages/eslint-plugin/src/rules/consistent-type-imports.ts b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
index f15de1dd62ae..4369fde36235 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-imports.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-imports.ts
@@ -103,8 +103,8 @@ export default createRule<Options, MessageIds>({
     if (disallowTypeAnnotations) {
       selectors.TSImportType = (node): void => {
         context.report({
-          messageId: 'noImportTypeAnnotations',
           node,
+          messageId: 'noImportTypeAnnotations',
         });
       };
     }
@@ -116,22 +116,22 @@ export default createRule<Options, MessageIds>({
           node: TSESTree.ImportDeclaration,
         ): void {
           context.report({
+            node,
+            messageId: 'avoidImportType',
             fix(fixer) {
               return fixRemoveTypeSpecifierFromImportDeclaration(fixer, node);
             },
-            messageId: 'avoidImportType',
-            node,
           });
         },
         'ImportSpecifier[importKind = "type"]'(
           node: TSESTree.ImportSpecifier,
         ): void {
           context.report({
+            node,
+            messageId: 'avoidImportType',
             fix(fixer) {
               return fixRemoveTypeSpecifierFromImportSpecifier(fixer, node);
             },
-            messageId: 'avoidImportType',
-            node,
           });
         },
       };
@@ -287,8 +287,8 @@ export default createRule<Options, MessageIds>({
 
         if (node.importKind === 'value' && typeSpecifiers.length) {
           sourceImports.reportValueImports.push({
-            inlineTypeSpecifiers,
             node,
+            inlineTypeSpecifiers,
             typeSpecifiers,
             unusedSpecifiers,
             valueSpecifiers,
@@ -355,6 +355,8 @@ export default createRule<Options, MessageIds>({
                */
               if (report.node.attributes.length === 0) {
                 context.report({
+                  node: report.node,
+                  messageId: 'typeOverValue',
                   *fix(fixer) {
                     yield* fixToTypeImportDeclaration(
                       fixer,
@@ -362,8 +364,6 @@ export default createRule<Options, MessageIds>({
                       sourceImports,
                     );
                   },
-                  messageId: 'typeOverValue',
-                  node: report.node,
                 });
               }
             } else {
@@ -380,17 +380,17 @@ export default createRule<Options, MessageIds>({
 
                 if (importNames.length === 1) {
                   return {
+                    messageId: 'someImportsAreOnlyTypes',
                     data: {
                       typeImports,
                     },
-                    messageId: 'someImportsAreOnlyTypes',
                   };
                 }
                 return {
+                  messageId: 'someImportsAreOnlyTypes',
                   data: {
                     typeImports,
                   },
-                  messageId: 'someImportsAreOnlyTypes',
                 };
               })();
 
diff --git a/packages/eslint-plugin/src/rules/default-param-last.ts b/packages/eslint-plugin/src/rules/default-param-last.ts
index bd688bbe3ecd..1d120720d26c 100644
--- a/packages/eslint-plugin/src/rules/default-param-last.ts
+++ b/packages/eslint-plugin/src/rules/default-param-last.ts
@@ -72,7 +72,7 @@ export default createRule({
           (isOptionalParam(param) ||
             param.type === AST_NODE_TYPES.AssignmentPattern)
         ) {
-          context.report({ messageId: 'shouldBeLast', node: current });
+          context.report({ node: current, messageId: 'shouldBeLast' });
         }
       }
     }
diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
index 68787c31f635..186241cb72a2 100644
--- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
+++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts
@@ -222,8 +222,8 @@ export default createRule<Options, MessageIds>({
       checkFunctionReturnType(info, options, context.sourceCode, loc =>
         context.report({
           loc,
-          messageId: 'missingReturnType',
           node,
+          messageId: 'missingReturnType',
         }),
       );
     }
@@ -244,8 +244,8 @@ export default createRule<Options, MessageIds>({
         checkFunctionReturnType(info, options, context.sourceCode, loc =>
           context.report({
             loc,
-            messageId: 'missingReturnType',
             node,
+            messageId: 'missingReturnType',
           }),
         );
       },
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 1a17e40f8581..7d1c2f9aefe1 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -161,22 +161,22 @@ export default createRule<Options, MessageIds>({
       ) {
         const publicKeyword = findPublicKeyword(methodDefinition);
         context.report({
+          loc: rangeToLoc(context.sourceCode, publicKeyword.range),
+          messageId: 'unwantedPublicAccessibility',
           data: {
             name: methodName,
             type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
-          loc: rangeToLoc(context.sourceCode, publicKeyword.range),
-          messageId: 'unwantedPublicAccessibility',
         });
       } else if (check === 'explicit' && !methodDefinition.accessibility) {
         context.report({
+          loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
+          messageId: 'missingAccessibility',
           data: {
             name: methodName,
             type: nodeType,
           },
-          loc: getMemberHeadLoc(context.sourceCode, methodDefinition),
-          messageId: 'missingAccessibility',
           suggest: getMissingAccessibilitySuggestions(methodDefinition),
         });
       }
@@ -254,19 +254,19 @@ export default createRule<Options, MessageIds>({
 
       return [
         {
+          messageId: 'addExplicitAccessibility',
           data: { type: 'public' },
           fix: fixer => fix('public', fixer),
-          messageId: 'addExplicitAccessibility',
         },
         {
+          messageId: 'addExplicitAccessibility',
           data: { type: 'private' },
           fix: fixer => fix('private', fixer),
-          messageId: 'addExplicitAccessibility',
         },
         {
+          messageId: 'addExplicitAccessibility',
           data: { type: 'protected' },
           fix: fixer => fix('protected', fixer),
-          messageId: 'addExplicitAccessibility',
         },
       ];
     }
@@ -296,25 +296,25 @@ export default createRule<Options, MessageIds>({
       ) {
         const publicKeywordRange = findPublicKeyword(propertyDefinition);
         context.report({
+          loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
+          messageId: 'unwantedPublicAccessibility',
           data: {
             name: propertyName,
             type: nodeType,
           },
           fix: fixer => fixer.removeRange(publicKeywordRange.rangeToRemove),
-          loc: rangeToLoc(context.sourceCode, publicKeywordRange.range),
-          messageId: 'unwantedPublicAccessibility',
         });
       } else if (
         propCheck === 'explicit' &&
         !propertyDefinition.accessibility
       ) {
         context.report({
+          loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
+          messageId: 'missingAccessibility',
           data: {
             name: propertyName,
             type: nodeType,
           },
-          loc: getMemberHeadLoc(context.sourceCode, propertyDefinition),
-          messageId: 'missingAccessibility',
           suggest: getMissingAccessibilitySuggestions(propertyDefinition),
         });
       }
@@ -346,16 +346,16 @@ export default createRule<Options, MessageIds>({
         case 'explicit': {
           if (!node.accessibility) {
             context.report({
-              data: {
-                name: nodeName,
-                type: nodeType,
-              },
               loc: getParameterPropertyHeadLoc(
                 context.sourceCode,
                 node,
                 nodeName,
               ),
               messageId: 'missingAccessibility',
+              data: {
+                name: nodeName,
+                type: nodeType,
+              },
               suggest: getMissingAccessibilitySuggestions(node),
             });
           }
@@ -365,13 +365,13 @@ export default createRule<Options, MessageIds>({
           if (node.accessibility === 'public' && node.readonly) {
             const publicKeyword = findPublicKeyword(node);
             context.report({
+              loc: rangeToLoc(context.sourceCode, publicKeyword.range),
+              messageId: 'unwantedPublicAccessibility',
               data: {
                 name: nodeName,
                 type: nodeType,
               },
               fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove),
-              loc: rangeToLoc(context.sourceCode, publicKeyword.range),
-              messageId: 'unwantedPublicAccessibility',
             });
           }
           break;
diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
index e4bfa29cc05c..19786cd45155 100644
--- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
+++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts
@@ -186,34 +186,34 @@ export default createRule<Options, MessageIds>({
         ): void {
           if (param.type === AST_NODE_TYPES.Identifier) {
             context.report({
-              data: { name: param.name },
-              messageId: namedMessageId,
               node: param,
+              messageId: namedMessageId,
+              data: { name: param.name },
             });
           } else if (param.type === AST_NODE_TYPES.ArrayPattern) {
             context.report({
-              data: { type: 'Array pattern' },
-              messageId: unnamedMessageId,
               node: param,
+              messageId: unnamedMessageId,
+              data: { type: 'Array pattern' },
             });
           } else if (param.type === AST_NODE_TYPES.ObjectPattern) {
             context.report({
-              data: { type: 'Object pattern' },
-              messageId: unnamedMessageId,
               node: param,
+              messageId: unnamedMessageId,
+              data: { type: 'Object pattern' },
             });
           } else if (param.type === AST_NODE_TYPES.RestElement) {
             if (param.argument.type === AST_NODE_TYPES.Identifier) {
               context.report({
-                data: { name: param.argument.name },
-                messageId: namedMessageId,
                 node: param,
+                messageId: namedMessageId,
+                data: { name: param.argument.name },
               });
             } else {
               context.report({
-                data: { type: 'Rest' },
-                messageId: unnamedMessageId,
                 node: param,
+                messageId: unnamedMessageId,
+                data: { type: 'Rest' },
               });
             }
           }
@@ -445,8 +445,8 @@ export default createRule<Options, MessageIds>({
         node.parent.kind === 'set';
       if (!isConstructor && !isSetAccessor && !node.returnType) {
         context.report({
-          messageId: 'missingReturnType',
           node,
+          messageId: 'missingReturnType',
         });
       }
 
@@ -477,8 +477,8 @@ export default createRule<Options, MessageIds>({
         loc => {
           context.report({
             loc,
-            messageId: 'missingReturnType',
             node,
+            messageId: 'missingReturnType',
           });
         },
       );
@@ -506,8 +506,8 @@ export default createRule<Options, MessageIds>({
         loc => {
           context.report({
             loc,
-            messageId: 'missingReturnType',
             node,
+            messageId: 'missingReturnType',
           });
         },
       );
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index f67183eb4c73..3d37a0346767 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -841,12 +841,12 @@ export default createRule<Options, MessageIds>({
         // 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),
             },
-            messageId: 'incorrectGroupOrder',
-            node: member,
           });
 
           isCorrectlySorted = false;
@@ -886,12 +886,12 @@ export default createRule<Options, MessageIds>({
         if (name) {
           if (naturalOutOfOrder(name, previousName, order)) {
             context.report({
+              node: member,
+              messageId: 'incorrectOrder',
               data: {
                 beforeMember: previousName,
                 member: name,
               },
-              messageId: 'incorrectOrder',
-              node: member,
             });
 
             isCorrectlySorted = false;
@@ -947,13 +947,13 @@ export default createRule<Options, MessageIds>({
 
       const report = (member: Member): void =>
         context.report({
+          loc: member.loc,
+          messageId: 'incorrectRequiredMembersOrder',
           data: {
             member: getMemberName(member, context.sourceCode),
             optionalOrRequired:
               optionalityOrder === 'required-first' ? 'required' : 'optional',
           },
-          loc: member.loc,
-          messageId: 'incorrectRequiredMembersOrder',
         });
 
       // if the optionality of the first item is correct (based on optionalityOrder)
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index 7d87957d0b8a..9c9478d4f50f 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -147,11 +147,13 @@ export default createRule<Options, MessageIds>({
           if (duplicatedKeyMethodNodes.length > 0) {
             if (isParentModule) {
               context.report({
-                messageId: 'errorMethod',
                 node: methodNode,
+                messageId: 'errorMethod',
               });
             } else {
               context.report({
+                node: methodNode,
+                messageId: 'errorMethod',
                 *fix(fixer) {
                   const methodNodes = [
                     methodNode,
@@ -185,8 +187,6 @@ export default createRule<Options, MessageIds>({
                     }
                   }
                 },
-                messageId: 'errorMethod',
-                node: methodNode,
               });
             }
             return;
@@ -194,11 +194,13 @@ export default createRule<Options, MessageIds>({
 
           if (isParentModule) {
             context.report({
-              messageId: 'errorMethod',
               node: methodNode,
+              messageId: 'errorMethod',
             });
           } else {
             context.report({
+              node: methodNode,
+              messageId: 'errorMethod',
               fix: fixer => {
                 const key = getMethodKey(methodNode);
                 const params = getMethodParams(methodNode);
@@ -209,8 +211,6 @@ export default createRule<Options, MessageIds>({
                   `${key}: ${params} => ${returnType}${delimiter}`,
                 );
               },
-              messageId: 'errorMethod',
-              node: methodNode,
             });
           }
         },
@@ -223,6 +223,8 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
+            node: propertyNode,
+            messageId: 'errorProperty',
             fix: fixer => {
               const key = getMethodKey(propertyNode);
               const params = getMethodParams(typeNode);
@@ -233,8 +235,6 @@ export default createRule<Options, MessageIds>({
                 `${key}${params}: ${returnType}${delimiter}`,
               );
             },
-            messageId: 'errorProperty',
-            node: propertyNode,
           });
         },
       }),
diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
index 882360e8ad14..a315789334e4 100644
--- a/packages/eslint-plugin/src/rules/no-array-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -36,6 +36,8 @@ export default createRule({
         !isOptionalCallExpression(node)
       ) {
         context.report({
+          node,
+          messageId: 'useLiteral',
           fix(fixer) {
             if (node.arguments.length === 0) {
               return fixer.replaceText(node, '[]');
@@ -48,8 +50,6 @@ export default createRule({
               `[${fullText.slice(preambleLength + 1, -1)}]`,
             );
           },
-          messageId: 'useLiteral',
-          node,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-array-delete.ts b/packages/eslint-plugin/src/rules/no-array-delete.ts
index d132bd76e47e..a179418a7b01 100644
--- a/packages/eslint-plugin/src/rules/no-array-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-array-delete.ts
@@ -65,10 +65,11 @@ export default createRule<[], MessageId>({
         }
 
         context.report({
-          messageId: 'noArrayDelete',
           node,
+          messageId: 'noArrayDelete',
           suggest: [
             {
+              messageId: 'useSplice',
               fix(fixer): TSESLint.RuleFix | null {
                 const { object, property } = argument;
 
@@ -101,7 +102,6 @@ export default createRule<[], MessageId>({
 
                 return fixer.replaceText(node, suggestion);
               },
-              messageId: 'useSplice',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
index 22646c9c706b..8aeb692fbe09 100644
--- a/packages/eslint-plugin/src/rules/no-base-to-string.ts
+++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts
@@ -70,12 +70,12 @@ export default createRule<Options, MessageIds>({
       }
 
       context.report({
+        node,
+        messageId: 'baseToString',
         data: {
           name: context.sourceCode.getText(node),
           certainty,
         },
-        messageId: 'baseToString',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
index 77073274220d..d8604a55f853 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-non-null-assertion.ts
@@ -54,30 +54,30 @@ export default createRule({
           ) {
             if (isLeftHandPrimaryExpression(node.left)) {
               context.report({
-                messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
                 node,
+                messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
                 suggest: [
                   {
-                    fix: (fixer): TSESLint.RuleFix[] => [
-                      fixer.remove(leftHandFinalToken),
-                    ],
                     messageId: isAssign
                       ? 'notNeedInAssign'
                       : 'notNeedInEqualTest',
+                    fix: (fixer): TSESLint.RuleFix[] => [
+                      fixer.remove(leftHandFinalToken),
+                    ],
                   },
                 ],
               });
             } else {
               context.report({
-                messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
                 node,
+                messageId: isAssign ? 'confusingAssign' : 'confusingEqual',
                 suggest: [
                   {
+                    messageId: 'wrapUpLeft',
                     fix: (fixer): TSESLint.RuleFix[] => [
                       fixer.insertTextBefore(node.left, '('),
                       fixer.insertTextAfter(node.left, ')'),
                     ],
-                    messageId: 'wrapUpLeft',
                   },
                 ],
               });
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
index 79fde557516a..fdc10e18ee1f 100644
--- a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -116,15 +116,17 @@ export default createRule<Options, MessageId>({
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
-              fix: wrapVoidFix,
-              messageId: 'invalidVoidExprArrowWrapVoid',
               node,
+              messageId: 'invalidVoidExprArrowWrapVoid',
+              fix: wrapVoidFix,
             });
           }
 
           // handle wrapping with braces
           const arrowFunction = invalidAncestor;
           return context.report({
+            node,
+            messageId: 'invalidVoidExprArrow',
             fix(fixer) {
               if (!canFix(arrowFunction)) {
                 return null;
@@ -160,8 +162,6 @@ export default createRule<Options, MessageId>({
               }
               return fixer.replaceText(arrowBody, newArrowBodyText);
             },
-            messageId: 'invalidVoidExprArrow',
-            node,
           });
         }
 
@@ -171,15 +171,17 @@ export default createRule<Options, MessageId>({
           if (options.ignoreVoidOperator) {
             // handle wrapping with `void`
             return context.report({
-              fix: wrapVoidFix,
-              messageId: 'invalidVoidExprReturnWrapVoid',
               node,
+              messageId: 'invalidVoidExprReturnWrapVoid',
+              fix: wrapVoidFix,
             });
           }
 
           if (isFinalReturn(invalidAncestor)) {
             // remove the `return` keyword
             return context.report({
+              node,
+              messageId: 'invalidVoidExprReturnLast',
               fix(fixer) {
                 if (!canFix(invalidAncestor)) {
                   return null;
@@ -193,13 +195,13 @@ export default createRule<Options, MessageId>({
                 }
                 return fixer.replaceText(invalidAncestor, newReturnStmtText);
               },
-              messageId: 'invalidVoidExprReturnLast',
-              node,
             });
           }
 
           // move before the `return` keyword
           return context.report({
+            node,
+            messageId: 'invalidVoidExprReturn',
             fix(fixer) {
               const returnValue = invalidAncestor.argument;
               const returnValueText = context.sourceCode.getText(returnValue);
@@ -217,8 +219,6 @@ export default createRule<Options, MessageId>({
               }
               return fixer.replaceText(invalidAncestor, newReturnStmtText);
             },
-            messageId: 'invalidVoidExprReturn',
-            node,
           });
         }
 
@@ -226,15 +226,15 @@ export default createRule<Options, MessageId>({
         if (options.ignoreVoidOperator) {
           // this would be reported by this rule btw. such irony
           return context.report({
-            messageId: 'invalidVoidExprWrapVoid',
             node,
-            suggest: [{ fix: wrapVoidFix, messageId: 'voidExprWrapVoid' }],
+            messageId: 'invalidVoidExprWrapVoid',
+            suggest: [{ messageId: 'voidExprWrapVoid', fix: wrapVoidFix }],
           });
         }
 
         context.report({
-          messageId: 'invalidVoidExpr',
           node,
+          messageId: 'invalidVoidExpr',
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
index 91d77e451548..41464609c518 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-enum-values.ts
@@ -59,11 +59,11 @@ export default createRule({
 
           if (seenValues.has(value)) {
             context.report({
+              node: member,
+              messageId: 'duplicateValue',
               data: {
                 value,
               },
-              messageId: 'duplicateValue',
-              node: member,
             });
           } else {
             seenValues.add(value);
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index 14aa70bdc7a0..03f5e0422603 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -177,6 +177,9 @@ export default createRule<Options, MessageIds>({
         start: duplicateConstituent.duplicated.loc.start,
       };
       context.report({
+        loc: reportLocation,
+        node: duplicateConstituent.duplicated,
+        messageId: 'duplicate',
         data: {
           type:
             parentNode.type === AST_NODE_TYPES.TSIntersectionType
@@ -194,9 +197,6 @@ export default createRule<Options, MessageIds>({
             ...bracketAfterTokens,
           ].map(token => fixer.remove(token));
         },
-        loc: reportLocation,
-        messageId: 'duplicate',
-        node: duplicateConstituent.duplicated,
       });
     }
     return {
diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
index edcaeea83095..aa009578636d 100644
--- a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
+++ b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -48,9 +48,9 @@ export default createRule({
         }
 
         context.report({
-          fix: createFixer(node.argument),
-          messageId: 'dynamicDelete',
           node: node.argument.property,
+          messageId: 'dynamicDelete',
+          fix: createFixer(node.argument),
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index 2b54944bac43..ca94d47a886f 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -56,8 +56,8 @@ export default createRule<Options, MessageIds>({
         const extend = node.extends;
         if (extend.length === 0) {
           context.report({
-            messageId: 'noEmpty',
             node: node.id,
+            messageId: 'noEmpty',
           });
         } else if (extend.length === 1) {
           // interface extends exactly 1 interface --> Report depending on rule setting
@@ -93,16 +93,16 @@ export default createRule<Options, MessageIds>({
             );
 
             context.report({
-              messageId: 'noEmptyWithSuper',
               node: node.id,
+              messageId: 'noEmptyWithSuper',
               ...(useAutoFix
                 ? { fix }
                 : !mergedWithClassDeclaration
                   ? {
                       suggest: [
                         {
-                          fix,
                           messageId: 'noEmptyWithSuper',
+                          fix,
                         },
                       ],
                     }
diff --git a/packages/eslint-plugin/src/rules/no-empty-object-type.ts b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
index f6a2cf5fac1c..a4ece18a0a1c 100644
--- a/packages/eslint-plugin/src/rules/no-empty-object-type.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-object-type.ts
@@ -109,11 +109,12 @@ export default createRule<Options, MessageIds>({
 
           if (extend.length === 0) {
             context.report({
-              data: { option: 'allowInterfaces' },
-              messageId: 'noEmptyInterface',
               node: node.id,
+              messageId: 'noEmptyInterface',
+              data: { option: 'allowInterfaces' },
               ...(!mergedWithClassDeclaration && {
                 suggest: ['object', 'unknown'].map(replacement => ({
+                  messageId: 'replaceEmptyInterface',
                   data: { replacement },
                   fix(fixer): TSESLint.RuleFix {
                     const id = context.sourceCode.getText(node.id);
@@ -126,7 +127,6 @@ export default createRule<Options, MessageIds>({
                       `type ${id}${typeParam} = ${replacement}`,
                     );
                   },
-                  messageId: 'replaceEmptyInterface',
                 })),
               }),
             });
@@ -134,11 +134,12 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            messageId: 'noEmptyInterfaceWithSuper',
             node: node.id,
+            messageId: 'noEmptyInterfaceWithSuper',
             ...(!mergedWithClassDeclaration && {
               suggest: [
                 {
+                  messageId: 'replaceEmptyInterfaceWithSuper',
                   fix(fixer): TSESLint.RuleFix {
                     const extended = context.sourceCode.getText(extend[0]);
                     const id = context.sourceCode.getText(node.id);
@@ -151,7 +152,6 @@ export default createRule<Options, MessageIds>({
                       `type ${id}${typeParam} = ${extended}`,
                     );
                   },
-                  messageId: 'replaceEmptyInterfaceWithSuper',
                 },
               ],
             }),
@@ -171,14 +171,14 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            data: { option: 'allowObjectTypes' },
-            messageId: 'noEmptyObject',
             node,
+            messageId: 'noEmptyObject',
+            data: { option: 'allowObjectTypes' },
             suggest: ['object', 'unknown'].map(replacement => ({
+              messageId: 'replaceEmptyObjectType',
               data: { replacement },
               fix: (fixer): TSESLint.RuleFix =>
                 fixer.replaceText(node, replacement),
-              messageId: 'replaceEmptyObjectType',
             })),
           });
         },
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index 5b297b7357a8..1571617d8242 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -183,16 +183,16 @@ export default createRule<Options, MessageIds>({
           fix: null,
           suggest: [
             {
+              messageId: 'suggestUnknown',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.replaceText(node, 'unknown');
               },
-              messageId: 'suggestUnknown',
             },
             {
+              messageId: 'suggestNever',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.replaceText(node, 'never');
               },
-              messageId: 'suggestNever',
             },
           ],
         };
@@ -203,8 +203,8 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          messageId: 'unexpectedAny',
           node,
+          messageId: 'unexpectedAny',
           ...fixOrSuggest,
         });
       },
diff --git a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
index d30f51feca5b..fbeb009d2ba3 100644
--- a/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-extra-non-null-assertion.ts
@@ -22,11 +22,11 @@ export default createRule({
       node: TSESTree.TSNonNullExpression,
     ): void {
       context.report({
+        node,
+        messageId: 'noExtraNonNullAssertion',
         fix(fixer) {
           return fixer.removeRange([node.range[1] - 1, node.range[1]]);
         },
-        messageId: 'noExtraNonNullAssertion',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index 75641910c775..6a80ba9b876d 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -96,8 +96,8 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            messageId: 'empty',
             node: reportNode,
+            messageId: 'empty',
           });
 
           return;
@@ -139,16 +139,16 @@ export default createRule<Options, MessageIds>({
         if (onlyConstructor) {
           if (!allowConstructorOnly) {
             context.report({
-              messageId: 'onlyConstructor',
               node: reportNode,
+              messageId: 'onlyConstructor',
             });
           }
           return;
         }
         if (onlyStatic && !allowStaticOnly) {
           context.report({
-            messageId: 'onlyStatic',
             node: reportNode,
+            messageId: 'onlyStatic',
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
index 7f76e822caff..8d1da291470c 100644
--- a/packages/eslint-plugin/src/rules/no-floating-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -142,19 +142,20 @@ export default createRule<Options, MessageId>({
         if (isUnhandled) {
           if (promiseArray) {
             context.report({
+              node,
               messageId: options.ignoreVoid
                 ? 'floatingPromiseArrayVoid'
                 : 'floatingPromiseArray',
-              node,
             });
           } else if (options.ignoreVoid) {
             context.report({
+              node,
               messageId: nonFunctionHandler
                 ? 'floatingUselessRejectionHandlerVoid'
                 : 'floatingVoid',
-              node,
               suggest: [
                 {
+                  messageId: 'floatingFixVoid',
                   fix(fixer): TSESLint.RuleFix | TSESLint.RuleFix[] {
                     const tsNode = services.esTreeNodeToTSNodeMap.get(
                       node.expression,
@@ -170,26 +171,25 @@ export default createRule<Options, MessageId>({
                       ),
                     ];
                   },
-                  messageId: 'floatingFixVoid',
                 },
                 {
+                  messageId: 'floatingFixAwait',
                   fix: (fixer): TSESLint.RuleFix | TSESLint.RuleFix[] =>
                     addAwait(fixer, expression, node),
-                  messageId: 'floatingFixAwait',
                 },
               ],
             });
           } else {
             context.report({
+              node,
               messageId: nonFunctionHandler
                 ? 'floatingUselessRejectionHandler'
                 : 'floating',
-              node,
               suggest: [
                 {
+                  messageId: 'floatingFixAwait',
                   fix: (fixer): TSESLint.RuleFix | TSESLint.RuleFix[] =>
                     addAwait(fixer, expression, node),
-                  messageId: 'floatingFixAwait',
                 },
               ],
             });
diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
index be621a228927..0f7d3fd67db5 100644
--- a/packages/eslint-plugin/src/rules/no-implied-eval.ts
+++ b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -133,11 +133,11 @@ export default createRule({
           if (
             isBuiltinSymbolLike(services.program, type, 'FunctionConstructor')
           ) {
-            context.report({ messageId: 'noFunctionConstructor', node });
+            context.report({ node, messageId: 'noFunctionConstructor' });
             return;
           }
         } else {
-          context.report({ messageId: 'noFunctionConstructor', node });
+          context.report({ node, messageId: 'noFunctionConstructor' });
           return;
         }
       }
@@ -152,7 +152,7 @@ export default createRule({
         !isFunction(handler) &&
         isReferenceToGlobalFunction(calleeName, node, context.sourceCode)
       ) {
-        context.report({ messageId: 'noImpliedEvalError', node: handler });
+        context.report({ node: handler, messageId: 'noImpliedEvalError' });
       }
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
index 41af8d6d4c85..12887dd2331e 100644
--- a/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
+++ b/packages/eslint-plugin/src/rules/no-import-type-side-effects.ts
@@ -50,6 +50,8 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
+          node,
+          messageId: 'useTopLevelQualifier',
           fix(fixer) {
             const fixes: TSESLint.RuleFix[] = [];
             for (const specifier of specifiers) {
@@ -76,8 +78,6 @@ export default createRule<Options, MessageIds>({
 
             return fixes;
           },
-          messageId: 'useTopLevelQualifier',
-          node,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
index 900bab859dc0..e1e105dced2d 100644
--- a/packages/eslint-plugin/src/rules/no-inferrable-types.ts
+++ b/packages/eslint-plugin/src/rules/no-inferrable-types.ts
@@ -212,6 +212,8 @@ export default createRule<Options, MessageIds>({
           : keywordMap[typeNode.typeAnnotation.type];
 
       context.report({
+        node,
+        messageId: 'noInferrableType',
         data: {
           type,
         },
@@ -230,8 +232,6 @@ export default createRule<Options, MessageIds>({
           }
           yield fixer.remove(typeNode);
         },
-        messageId: 'noInferrableType',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
index 4c8dbd5937f7..2b5151e375bc 100644
--- a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
+++ b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -112,9 +112,9 @@ export default createRule<[Options], MessageIds>({
             .includes(fullyQualifiedName)
         ) {
           context.report({
-            data: { generic: fullyQualifiedName },
-            messageId: 'invalidVoidForGeneric',
             node,
+            messageId: 'invalidVoidForGeneric',
+            data: { generic: fullyQualifiedName },
           });
         }
         return;
@@ -122,10 +122,10 @@ export default createRule<[Options], MessageIds>({
 
       if (!allowInGenericTypeArguments) {
         context.report({
+          node,
           messageId: allowAsThisParameter
             ? 'invalidVoidNotReturnOrThisParam'
             : 'invalidVoidNotReturn',
-          node,
         });
       }
     }
@@ -139,8 +139,8 @@ export default createRule<[Options], MessageIds>({
     ): void {
       if (parentNode.default !== node) {
         context.report({
-          messageId: getNotReturnOrGenericMessageId(node),
           node,
+          messageId: getNotReturnOrGenericMessageId(node),
         });
       }
     }
@@ -214,6 +214,7 @@ export default createRule<[Options], MessageIds>({
         }
 
         context.report({
+          node,
           messageId:
             allowInGenericTypeArguments && allowAsThisParameter
               ? 'invalidVoidNotReturnOrThisParamOrGeneric'
@@ -222,7 +223,6 @@ export default createRule<[Options], MessageIds>({
                 : allowAsThisParameter
                   ? 'invalidVoidNotReturnOrThisParam'
                   : 'invalidVoidNotReturn',
-          node,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-loop-func.ts b/packages/eslint-plugin/src/rules/no-loop-func.ts
index dc30494ff22e..9a629a7af923 100644
--- a/packages/eslint-plugin/src/rules/no-loop-func.ts
+++ b/packages/eslint-plugin/src/rules/no-loop-func.ts
@@ -56,9 +56,9 @@ export default createRule<Options, MessageIds>({
 
       if (unsafeRefs.length > 0) {
         context.report({
-          data: { varNames: `'${unsafeRefs.join("', '")}'` },
-          messageId: 'unsafeRefs',
           node,
+          messageId: 'unsafeRefs',
+          data: { varNames: `'${unsafeRefs.join("', '")}'` },
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-magic-numbers.ts b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
index c06c89010e35..fe7c378127e8 100644
--- a/packages/eslint-plugin/src/rules/no-magic-numbers.ts
+++ b/packages/eslint-plugin/src/rules/no-magic-numbers.ts
@@ -123,9 +123,9 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
-            data: { raw },
-            messageId: 'noMagic',
             node: fullNumberNode,
+            messageId: 'noMagic',
+            data: { raw },
           });
 
           return;
diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
index a703d3ce3281..3adb84a3cb86 100644
--- a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
+++ b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -64,10 +64,10 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
           )
         ) {
           context.report({
+            node,
+            messageId: 'meaninglessVoidOperator',
             data: { type: checker.typeToString(argType) },
             fix,
-            messageId: 'meaninglessVoidOperator',
-            node,
           });
         } else if (
           checkNever &&
@@ -78,10 +78,10 @@ export default createRule<Options, 'meaninglessVoidOperator' | 'removeVoid'>({
           )
         ) {
           context.report({
-            data: { type: checker.typeToString(argType) },
-            messageId: 'meaninglessVoidOperator',
             node,
-            suggest: [{ fix, messageId: 'removeVoid' }],
+            messageId: 'meaninglessVoidOperator',
+            data: { type: checker.typeToString(argType) },
+            suggest: [{ messageId: 'removeVoid', fix }],
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-misused-new.ts b/packages/eslint-plugin/src/rules/no-misused-new.ts
index 16af769f1b48..54b3f6bf311c 100644
--- a/packages/eslint-plugin/src/rules/no-misused-new.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-new.ts
@@ -78,8 +78,8 @@ export default createRule({
         if (node.value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
           if (isMatchingParentType(node.parent.parent, node.value.returnType)) {
             context.report({
-              messageId: 'errorMessageClass',
               node,
+              messageId: 'errorMessageClass',
             });
           }
         }
@@ -95,8 +95,8 @@ export default createRule({
         ) {
           // constructor
           context.report({
-            messageId: 'errorMessageInterface',
             node,
+            messageId: 'errorMessageInterface',
           });
         }
       },
@@ -104,8 +104,8 @@ export default createRule({
         node: TSESTree.TSMethodSignature,
       ): void {
         context.report({
-          messageId: 'errorMessageInterface',
           node,
+          messageId: 'errorMessageInterface',
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
index f49469b2e80e..bedc2bee5fe1 100644
--- a/packages/eslint-plugin/src/rules/no-misused-promises.ts
+++ b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -291,8 +291,8 @@ export default createRule<Options, MessageId>({
       const tsNode = services.esTreeNodeToTSNodeMap.get(node);
       if (isAlwaysThenable(checker, tsNode)) {
         context.report({
-          messageId: 'conditional',
           node,
+          messageId: 'conditional',
         });
       }
     }
@@ -314,8 +314,8 @@ export default createRule<Options, MessageId>({
         const tsNode = services.esTreeNodeToTSNodeMap.get(argument);
         if (returnsThenable(checker, tsNode as ts.Expression)) {
           context.report({
-            messageId: 'voidReturnArgument',
             node: argument,
+            messageId: 'voidReturnArgument',
           });
         }
       }
@@ -330,8 +330,8 @@ export default createRule<Options, MessageId>({
 
       if (returnsThenable(checker, tsNode.right)) {
         context.report({
-          messageId: 'voidReturnVariable',
           node: node.right,
+          messageId: 'voidReturnVariable',
         });
       }
     }
@@ -358,8 +358,8 @@ export default createRule<Options, MessageId>({
 
       if (returnsThenable(checker, tsNode.initializer)) {
         context.report({
-          messageId: 'voidReturnVariable',
           node: node.init,
+          messageId: 'voidReturnVariable',
         });
       }
     }
@@ -378,8 +378,8 @@ export default createRule<Options, MessageId>({
           returnsThenable(checker, tsNode.initializer)
         ) {
           context.report({
-            messageId: 'voidReturnProperty',
             node: node.value,
+            messageId: 'voidReturnProperty',
           });
         }
       } else if (ts.isShorthandPropertyAssignment(tsNode)) {
@@ -390,8 +390,8 @@ export default createRule<Options, MessageId>({
           returnsThenable(checker, tsNode.name)
         ) {
           context.report({
-            messageId: 'voidReturnProperty',
             node: node.value,
+            messageId: 'voidReturnProperty',
           });
         }
       } else if (ts.isMethodDeclaration(tsNode)) {
@@ -432,8 +432,8 @@ export default createRule<Options, MessageId>({
 
         if (isVoidReturningFunctionType(checker, tsNode.name, contextualType)) {
           context.report({
-            messageId: 'voidReturnProperty',
             node: node.value,
+            messageId: 'voidReturnProperty',
           });
         }
         return;
@@ -472,8 +472,8 @@ export default createRule<Options, MessageId>({
         returnsThenable(checker, tsNode.expression)
       ) {
         context.report({
-          messageId: 'voidReturnReturnValue',
           node: node.argument,
+          messageId: 'voidReturnReturnValue',
         });
       }
     }
@@ -537,9 +537,9 @@ export default createRule<Options, MessageId>({
         return;
       }
       context.report({
-        data: { heritageTypeName: checker.typeToString(heritageType) },
-        messageId: 'voidReturnInheritedMethod',
         node: services.tsNodeToESTreeNodeMap.get(nodeMember),
+        messageId: 'voidReturnInheritedMethod',
+        data: { heritageTypeName: checker.typeToString(heritageType) },
       });
     }
 
@@ -567,8 +567,8 @@ export default createRule<Options, MessageId>({
         returnsThenable(checker, expression)
       ) {
         context.report({
-          messageId: 'voidReturnAttribute',
           node: node.value,
+          messageId: 'voidReturnAttribute',
         });
       }
     }
@@ -578,8 +578,8 @@ export default createRule<Options, MessageId>({
 
       if (isSometimesThenable(checker, tsNode.expression)) {
         context.report({
-          messageId: 'spread',
           node: node.argument,
+          messageId: 'spread',
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-mixed-enums.ts b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
index 663fa3ce77de..6d99f22e3f27 100644
--- a/packages/eslint-plugin/src/rules/no-mixed-enums.ts
+++ b/packages/eslint-plugin/src/rules/no-mixed-enums.ts
@@ -209,8 +209,8 @@ export default createRule({
 
           if (currentType !== desiredType) {
             context.report({
-              messageId: 'mixed',
               node: member.initializer ?? member,
+              messageId: 'mixed',
             });
             return;
           }
diff --git a/packages/eslint-plugin/src/rules/no-namespace.ts b/packages/eslint-plugin/src/rules/no-namespace.ts
index 069de48d38c9..38567e5c90d1 100644
--- a/packages/eslint-plugin/src/rules/no-namespace.ts
+++ b/packages/eslint-plugin/src/rules/no-namespace.ts
@@ -71,8 +71,8 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          messageId: 'moduleSyntaxIsPreferred',
           node,
+          messageId: 'moduleSyntaxIsPreferred',
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
index 6b100c4ef77d..7aa673541bfb 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts
@@ -63,8 +63,8 @@ export default createRule({
         }
 
         context.report({
-          messageId: 'noNonNullAssertedNullishCoalescing',
           node,
+          messageId: 'noNonNullAssertedNullishCoalescing',
           /*
           Use a suggestion instead of a fixer, because this can break type checks.
           The resulting type of the nullish coalesce is only influenced by the right operand if the left operand can be `null` or `undefined`.
@@ -80,6 +80,7 @@ export default createRule({
           */
           suggest: [
             {
+              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 const exclamationMark = nullThrows(
                   context.sourceCode.getLastToken(
@@ -90,7 +91,6 @@ export default createRule({
                 );
                 return fixer.remove(exclamationMark);
               },
-              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
index 96732d1b76b1..efc8fc26cf5a 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-asserted-optional-chain.ts
@@ -31,18 +31,18 @@ export default createRule({
         // selector guarantees this assertion
         const parent = node.parent as TSESTree.TSNonNullExpression;
         context.report({
-          messageId: 'noNonNullOptionalChain',
           node,
+          messageId: 'noNonNullOptionalChain',
           // use a suggestion instead of a fixer, because this can obviously break type checks
           suggest: [
             {
+              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.removeRange([
                   parent.range[1] - 1,
                   parent.range[1],
                 ]);
               },
-              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
@@ -55,15 +55,15 @@ export default createRule({
         node: TSESTree.TSNonNullExpression,
       ): void {
         context.report({
-          messageId: 'noNonNullOptionalChain',
           node,
+          messageId: 'noNonNullOptionalChain',
           // use a suggestion instead of a fixer, because this can obviously break type checks
           suggest: [
             {
+              messageId: 'suggestRemovingNonNull',
               fix(fixer): TSESLint.RuleFix {
                 return fixer.removeRange([node.range[1] - 1, node.range[1]]);
               },
-              messageId: 'suggestRemovingNonNull',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index b8aebaef4eec..1838bb697e2d 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -59,12 +59,13 @@ export default createRule<[], MessageIds>({
             if (node.parent.computed) {
               // it is x![y]?.z
               suggest.push({
-                fix: replaceTokenWithOptional(),
                 messageId: 'suggestOptionalChain',
+                fix: replaceTokenWithOptional(),
               });
             } else {
               // it is x!.y?.z
               suggest.push({
+                messageId: 'suggestOptionalChain',
                 fix(fixer) {
                   // x!.y?.z
                   //   ^ punctuator
@@ -77,20 +78,19 @@ export default createRule<[], MessageIds>({
                     fixer.insertTextBefore(punctuator, '?'),
                   ];
                 },
-                messageId: 'suggestOptionalChain',
               });
             }
           } else if (node.parent.computed) {
             // it is x!?.[y].z
             suggest.push({
-              fix: removeToken(),
               messageId: 'suggestOptionalChain',
+              fix: removeToken(),
             });
           } else {
             // it is x!?.y.z
             suggest.push({
-              fix: removeToken(),
               messageId: 'suggestOptionalChain',
+              fix: removeToken(),
             });
           }
         } else if (
@@ -100,21 +100,21 @@ export default createRule<[], MessageIds>({
           if (!node.parent.optional) {
             // it is x.y?.z!()
             suggest.push({
-              fix: replaceTokenWithOptional(),
               messageId: 'suggestOptionalChain',
+              fix: replaceTokenWithOptional(),
             });
           } else {
             // it is x.y.z!?.()
             suggest.push({
-              fix: removeToken(),
               messageId: 'suggestOptionalChain',
+              fix: removeToken(),
             });
           }
         }
 
         context.report({
-          messageId: 'noNonNull',
           node,
+          messageId: 'noNonNull',
           suggest,
         });
       },
diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
index e3eba802d03a..5a989dc8c631 100644
--- a/packages/eslint-plugin/src/rules/no-redeclare.ts
+++ b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -87,13 +87,13 @@ export default createRule<Options, MessageIds>({
       ) {
         for (const comment of variable.eslintExplicitGlobalComments) {
           yield {
-            type: 'comment',
             loc: getNameLocationInGlobalDirectiveComment(
               context.sourceCode,
               comment,
               variable.name,
             ),
             node: comment,
+            type: 'comment',
           };
         }
       }
@@ -144,7 +144,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one class declaration, which needs to be reported
           for (const { identifier } of classDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -165,7 +165,7 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one function declaration, which needs to be reported
           for (const { identifier } of functionDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
@@ -186,14 +186,14 @@ export default createRule<Options, MessageIds>({
 
           // there's more than one enum declaration, which needs to be reported
           for (const { identifier } of enumDecls) {
-            yield { type: 'syntax', loc: identifier.loc, node: identifier };
+            yield { loc: identifier.loc, node: identifier, type: 'syntax' };
           }
           return;
         }
       }
 
       for (const { identifier } of identifiers) {
-        yield { type: 'syntax', loc: identifier.loc, node: identifier };
+        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
       }
     }
 
@@ -218,14 +218,14 @@ export default createRule<Options, MessageIds>({
         const data = { id: variable.name };
 
         // Report extra declarations.
-        for (const { type, loc, node } of extraDeclarations) {
+        for (const { loc, node, type } of extraDeclarations) {
           const messageId =
             type === declaration.type ? 'redeclared' : detailMessageId;
 
           if (node) {
-            context.report({ data, loc, messageId, node });
+            context.report({ loc, node, messageId, data });
           } else if (loc) {
-            context.report({ data, loc, messageId });
+            context.report({ loc, messageId, data });
           }
         }
       }
diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
index ccdb7adde84e..46aa4d6c1a73 100644
--- a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -293,15 +293,15 @@ export default createRule({
           ] as const) {
             if (typeFlags === checkFlag) {
               context.report({
-                data: {
-                  container: 'intersection',
-                  typeName,
-                },
+                node: typeNode,
                 messageId:
                   typeFlags === ts.TypeFlags.Any && typeName !== 'any'
                     ? 'errorTypeOverrides'
                     : messageId,
-                node: typeNode,
+                data: {
+                  container: 'intersection',
+                  typeName,
+                },
               });
               return true;
             }
@@ -370,6 +370,8 @@ export default createRule({
             }
             if (Number.isInteger(primitive)) {
               context.report({
+                node: typeRef,
+                messageId: 'primitiveOverridden',
                 data: {
                   literal: typeValues.map(name => name.typeName).join(' | '),
                   primitive:
@@ -377,8 +379,6 @@ export default createRule({
                       primitive as keyof typeof primitiveTypeFlagNames
                     ],
                 },
-                messageId: 'primitiveOverridden',
-                node: typeRef,
               });
             }
           }
@@ -395,12 +395,12 @@ export default createRule({
           if (matchedLiteralTypes) {
             for (const typeNode of typeNodes) {
               context.report({
+                node: typeNode,
+                messageId: 'primitiveOverridden',
                 data: {
                   literal: matchedLiteralTypes.join(' | '),
                   primitive: primitiveTypeFlagNames[primitiveTypeFlag],
                 },
-                messageId: 'primitiveOverridden',
-                node: typeNode,
               });
             }
           }
@@ -423,15 +423,15 @@ export default createRule({
           ] as const) {
             if (typeFlags === checkFlag) {
               context.report({
-                data: {
-                  container: 'union',
-                  typeName,
-                },
+                node: typeNode,
                 messageId:
                   typeFlags === ts.TypeFlags.Any && typeName !== 'any'
                     ? 'errorTypeOverrides'
                     : 'overrides',
-                node: typeNode,
+                data: {
+                  container: 'union',
+                  typeName,
+                },
               });
               return true;
             }
@@ -442,12 +442,12 @@ export default createRule({
             !isNodeInsideReturnType(node)
           ) {
             context.report({
+              node: typeNode,
+              messageId: 'overridden',
               data: {
                 container: 'union',
                 typeName: 'never',
               },
-              messageId: 'overridden',
-              node: typeNode,
             });
             return true;
           }
@@ -520,12 +520,12 @@ export default createRule({
 
           for (const [primitiveTypeFlag, pairs] of grouped) {
             context.report({
+              node: typeNode,
+              messageId: 'literalOverridden',
               data: {
                 literal: pairs.map(pair => pair.literalValue).join(' | '),
                 primitive: primitiveTypeFlagNames[primitiveTypeFlag],
               },
-              messageId: 'literalOverridden',
-              node: typeNode,
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 3cfe4193b338..26dcbcd6c821 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -76,8 +76,8 @@ export default util.createRule<Options, MessageIds>({
         // of the commonjs standard
         if (!variable?.identifiers.length) {
           context.report({
-            messageId: 'noRequireImports',
             node,
+            messageId: 'noRequireImports',
           });
         }
       },
@@ -95,8 +95,8 @@ export default util.createRule<Options, MessageIds>({
           return;
         }
         context.report({
-          messageId: 'noRequireImports',
           node,
+          messageId: 'noRequireImports',
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-restricted-types.ts b/packages/eslint-plugin/src/rules/no-restricted-types.ts
index ffddaf22d15c..8192b9380c7e 100644
--- a/packages/eslint-plugin/src/rules/no-restricted-types.ts
+++ b/packages/eslint-plugin/src/rules/no-restricted-types.ts
@@ -157,6 +157,8 @@ export default createRule<Options, MessageIds>({
           : undefined;
 
       context.report({
+        node: typeNode,
+        messageId: 'bannedTypeMessage',
         data: {
           name,
           customMessage,
@@ -164,16 +166,14 @@ export default createRule<Options, MessageIds>({
         fix: fixWith
           ? (fixer): TSESLint.RuleFix => fixer.replaceText(typeNode, fixWith)
           : null,
-        messageId: 'bannedTypeMessage',
-        node: typeNode,
         suggest: suggest?.map(replacement => ({
+          messageId: 'bannedTypeReplacement',
           data: {
             name,
             replacement,
           },
           fix: (fixer): TSESLint.RuleFix =>
             fixer.replaceText(typeNode, replacement),
-          messageId: 'bannedTypeReplacement',
         })),
       });
     }
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index e7ed3f9b2f8a..1a730f5c1199 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -614,18 +614,18 @@ export default createRule<Options, MessageIds>({
             node: variable.identifiers[0],
             ...(location.global
               ? {
+                  messageId: 'noShadowGlobal',
                   data: {
                     name: variable.name,
                   },
-                  messageId: 'noShadowGlobal',
                 }
               : {
+                  messageId: 'noShadow',
                   data: {
                     name: variable.name,
                     shadowedColumn: location.column,
                     shadowedLine: location.line,
                   },
-                  messageId: 'noShadow',
                 }),
           });
         }
diff --git a/packages/eslint-plugin/src/rules/no-this-alias.ts b/packages/eslint-plugin/src/rules/no-this-alias.ts
index 0f5c71f88692..842b6bb6edf9 100644
--- a/packages/eslint-plugin/src/rules/no-this-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-this-alias.ts
@@ -72,11 +72,11 @@ export default createRule<Options, MessageIds>({
             : false;
         if (!hasAllowedName) {
           context.report({
+            node: id,
             messageId:
               id.type === AST_NODE_TYPES.Identifier
                 ? 'thisAssignment'
                 : 'thisDestructure',
-            node: id,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index fcb332c1ba64..9c6b3df5479d 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -190,15 +190,17 @@ export default createRule<Options, MessageIds>({
     ): void {
       if (isRoot) {
         return context.report({
+          node,
+          messageId: 'noTypeAlias',
           data: {
             alias: type.toLowerCase(),
           },
-          messageId: 'noTypeAlias',
-          node,
         });
       }
 
       return context.report({
+        node,
+        messageId: 'noCompositionAlias',
         data: {
           compositionType:
             compositionType === AST_NODE_TYPES.TSUnionType
@@ -206,8 +208,6 @@ export default createRule<Options, MessageIds>({
               : 'intersection',
           typeName: type,
         },
-        messageId: 'noCompositionAlias',
-        node,
       });
     }
 
@@ -331,7 +331,7 @@ export default createRule<Options, MessageIds>({
           return acc;
         }, []);
       }
-      return [{ compositionType, node }];
+      return [{ node, compositionType }];
     }
 
     return {
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
index 8e4c51570180..9a0c38c47a80 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -217,6 +217,16 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
+          node,
+          messageId: comparison.expressionIsNullableBoolean
+            ? comparison.literalBooleanInComparison
+              ? comparison.negated
+                ? 'comparingNullableToTrueNegated'
+                : 'comparingNullableToTrueDirect'
+              : 'comparingNullableToFalse'
+            : comparison.negated
+              ? 'negated'
+              : 'direct',
           *fix(fixer) {
             // 1. isUnaryNegation - parent negation
             // 2. literalBooleanInComparison - is compared to literal boolean
@@ -255,16 +265,6 @@ export default createRule<Options, MessageIds>({
               yield fixer.insertTextAfter(mutatedNode, ' ?? true)');
             }
           },
-          messageId: comparison.expressionIsNullableBoolean
-            ? comparison.literalBooleanInComparison
-              ? comparison.negated
-                ? 'comparingNullableToTrueNegated'
-                : 'comparingNullableToTrueDirect'
-              : 'comparingNullableToFalse'
-            : comparison.negated
-              ? 'negated'
-              : 'direct',
-          node,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 79b03cfb93f6..d9f104cad880 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -292,7 +292,7 @@ export default createRule<Options, MessageId>({
       }
 
       if (messageId) {
-        context.report({ messageId, node });
+        context.report({ node, messageId });
       }
     }
 
@@ -340,7 +340,7 @@ export default createRule<Options, MessageId>({
       }
 
       if (messageId) {
-        context.report({ messageId, node });
+        context.report({ node, messageId });
       }
     }
 
@@ -373,7 +373,7 @@ export default createRule<Options, MessageId>({
       const leftType = getConstrainedTypeAtLocation(services, node.left);
       const rightType = getConstrainedTypeAtLocation(services, node.right);
       if (isLiteral(leftType) && isLiteral(rightType)) {
-        context.report({ messageId: 'literalBooleanExpression', node });
+        context.report({ node, messageId: 'literalBooleanExpression' });
         return;
       }
       // Workaround for https://github.com/microsoft/TypeScript/issues/37160
@@ -405,7 +405,7 @@ export default createRule<Options, MessageId>({
           (leftType.flags === NULL && !isComparable(rightType, NULL)) ||
           (rightType.flags === NULL && !isComparable(leftType, NULL))
         ) {
-          context.report({ messageId: 'noOverlapBooleanExpression', node });
+          context.report({ node, messageId: 'noOverlapBooleanExpression' });
           return;
         }
       }
@@ -518,14 +518,14 @@ export default createRule<Options, MessageId>({
         }
         if (!returnTypes.some(isPossiblyFalsy)) {
           return context.report({
-            messageId: 'alwaysTruthyFunc',
             node: callback,
+            messageId: 'alwaysTruthyFunc',
           });
         }
         if (!returnTypes.some(isPossiblyTruthy)) {
           return context.report({
-            messageId: 'alwaysFalsyFunc',
             node: callback,
+            messageId: 'alwaysFalsyFunc',
           });
         }
       }
@@ -687,12 +687,12 @@ export default createRule<Options, MessageId>({
       );
 
       context.report({
+        loc: questionDotOperator.loc,
+        node,
+        messageId: 'neverOptionalChain',
         fix(fixer) {
           return fixer.replaceText(questionDotOperator, fix);
         },
-        loc: questionDotOperator.loc,
-        messageId: 'neverOptionalChain',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
index 413e6cecadd5..0e771c9d34fd 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-parameter-property-assignment.ts
@@ -150,8 +150,8 @@ export default createRule({
             return;
           }
           context.report({
-            messageId: 'unnecessaryAssign',
             node,
+            messageId: 'unnecessaryAssign',
           });
         });
       },
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
index bdbb73897e50..7e1a5e9444d9 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -110,14 +110,14 @@ export default createRule({
       ) {
         currentFailedNamespaceExpression = node;
         context.report({
+          node: qualifier,
+          messageId: 'unnecessaryQualifier',
           data: {
             name: context.sourceCode.getText(name),
           },
           fix(fixer) {
             return fixer.removeRange([qualifier.range[0], name.range[0]]);
           },
-          messageId: 'unnecessaryQualifier',
-          node: qualifier,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
index d0e7fad7508a..3559ecde1440 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-template-expression.ts
@@ -106,6 +106,8 @@ export default createRule<[], MessageId>({
 
         if (hasSingleStringVariable) {
           context.report({
+            node: node.expressions[0],
+            messageId: 'noUnnecessaryTemplateExpression',
             fix(fixer): TSESLint.RuleFix | null {
               const wrappingCode = getMovedNodeCode({
                 destinationNode: node,
@@ -115,8 +117,6 @@ export default createRule<[], MessageId>({
 
               return fixer.replaceText(node, wrappingCode);
             },
-            messageId: 'noUnnecessaryTemplateExpression',
-            node: node.expressions[0],
           });
 
           return;
@@ -247,6 +247,8 @@ export default createRule<[], MessageId>({
           }
 
           context.report({
+            node: expression,
+            messageId: 'noUnnecessaryTemplateExpression',
             fix(fixer): TSESLint.RuleFix[] {
               return [
                 // Remove the quasis' parts that are related to the current expression.
@@ -262,8 +264,6 @@ export default createRule<[], MessageId>({
                 ...fixers.flatMap(cb => cb(fixer)),
               ];
             },
-            messageId: 'noUnnecessaryTemplateExpression',
-            node: expression,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
index 3fc30c1ec231..a41afacf62a4 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -97,14 +97,14 @@ export default createRule<[], MessageIds>({
       }
 
       context.report({
+        node: arg,
+        messageId: 'unnecessaryTypeParameter',
         fix: fixer =>
           fixer.removeRange(
             i === 0
               ? esParameters.range
               : [esParameters.params[i - 1].range[1], arg.range[1]],
           ),
-        messageId: 'unnecessaryTypeParameter',
-        node: arg,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index a43a842d7193..d20e0313a24d 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -229,6 +229,8 @@ export default createRule<Options, MessageIds>({
 
         if (typeIsUnchanged && wouldSameTypeBeInferred) {
           context.report({
+            node,
+            messageId: 'unnecessaryAssertion',
             fix(fixer) {
               if (node.type === AST_NODE_TYPES.TSTypeAssertion) {
                 const openingAngleBracket = nullThrows(
@@ -278,8 +280,6 @@ export default createRule<Options, MessageIds>({
               //          ^--remove--^
               return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
             },
-            messageId: 'unnecessaryAssertion',
-            node,
           });
         }
 
@@ -292,14 +292,14 @@ export default createRule<Options, MessageIds>({
         ) {
           if (node.parent.left === node) {
             context.report({
+              node,
+              messageId: 'contextuallyUnnecessary',
               fix(fixer) {
                 return fixer.removeRange([
                   node.expression.range[1],
                   node.range[1],
                 ]);
               },
-              messageId: 'contextuallyUnnecessary',
-              node,
             });
           }
           // for all other = assignments we ignore non-null checks
@@ -322,11 +322,11 @@ export default createRule<Options, MessageIds>({
           }
 
           context.report({
+            node,
+            messageId: 'unnecessaryAssertion',
             fix(fixer) {
               return fixer.removeRange([node.range[1] - 1, node.range[1]]);
             },
-            messageId: 'unnecessaryAssertion',
-            node,
           });
         } else {
           // we know it's a nullable type
@@ -370,14 +370,14 @@ export default createRule<Options, MessageIds>({
 
             if (isValidUndefined && isValidNull && isValidVoid) {
               context.report({
+                node,
+                messageId: 'contextuallyUnnecessary',
                 fix(fixer) {
                   return fixer.removeRange([
                     node.expression.range[1],
                     node.range[1],
                   ]);
                 },
-                messageId: 'contextuallyUnnecessary',
-                node,
               });
             }
           }
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
index 1590efad34da..493e93e96877 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-constraint.ts
@@ -78,14 +78,15 @@ export default createRule({
 
       if (constraint) {
         context.report({
+          node,
+          messageId: 'unnecessaryConstraint',
           data: {
             name: node.name.name,
             constraint,
           },
-          messageId: 'unnecessaryConstraint',
-          node,
           suggest: [
             {
+              messageId: 'removeUnnecessaryConstraint',
               data: {
                 constraint,
               },
@@ -95,7 +96,6 @@ export default createRule({
                   shouldAddTrailingComma() ? ',' : '',
                 );
               },
-              messageId: 'removeUnnecessaryConstraint',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
index d5351ec137aa..11eb71f1b804 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -67,13 +67,13 @@ export default createRule({
         }
 
         context.report({
+          node: esTypeParameter,
+          messageId: 'sole',
           data: {
             name: typeParameter.name.text,
             descriptor,
             uses: identifierCounts === 1 ? 'never used' : 'used only once',
           },
-          messageId: 'sole',
-          node: esTypeParameter,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
index 82c56eb7d58a..47bfd870f981 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-argument.ts
@@ -201,16 +201,16 @@ export default createRule<[], MessageIds>({
             if (isTypeAnyType(spreadArgType)) {
               // foo(...any)
               context.report({
-                messageId: 'unsafeSpread',
                 node: argument,
+                messageId: 'unsafeSpread',
               });
             } else if (isTypeAnyArrayType(spreadArgType, checker)) {
               // foo(...any[])
 
               // TODO - we could break down the spread and compare the array type against each argument
               context.report({
-                messageId: 'unsafeArraySpread',
                 node: argument,
+                messageId: 'unsafeArraySpread',
               });
             } else if (checker.isTupleType(spreadArgType)) {
               // foo(...[tuple1, tuple2])
@@ -231,12 +231,12 @@ export default createRule<[], MessageIds>({
                 );
                 if (result) {
                   context.report({
+                    node: argument,
+                    messageId: 'unsafeTupleSpread',
                     data: {
                       receiver: checker.typeToString(parameterType),
                       sender: checker.typeToString(tupleType),
                     },
-                    messageId: 'unsafeTupleSpread',
-                    node: argument,
                   });
                 }
               }
@@ -268,12 +268,12 @@ export default createRule<[], MessageIds>({
             );
             if (result) {
               context.report({
+                node: argument,
+                messageId: 'unsafeArgument',
                 data: {
                   receiver: checker.typeToString(parameterType),
                   sender: checker.typeToString(argumentType),
                 },
-                messageId: 'unsafeArgument',
-                node: argument,
               });
             }
           }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
index 3169a0e3ac37..a9f1358c0c6d 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -88,9 +88,9 @@ export default createRule({
       // const [x] = ([] as any[]);
       if (isTypeAnyArrayType(senderType, checker)) {
         context.report({
-          data: createData(senderType),
-          messageId: 'unsafeArrayPattern',
           node: receiverNode,
+          messageId: 'unsafeArrayPattern',
+          data: createData(senderType),
         });
         return false;
       }
@@ -127,9 +127,9 @@ export default createRule({
         // check for the any type first so we can handle [[[x]]] = [any]
         if (isTypeAnyType(senderType)) {
           context.report({
-            data: createData(senderType),
-            messageId: 'unsafeArrayPatternFromTuple',
             node: receiverElement,
+            messageId: 'unsafeArrayPatternFromTuple',
+            data: createData(senderType),
           });
           // we want to report on every invalid element in the tuple
           didReport = true;
@@ -214,9 +214,9 @@ export default createRule({
         // check for the any type first so we can handle {x: {y: z}} = {x: any}
         if (isTypeAnyType(senderType)) {
           context.report({
-            data: createData(senderType),
-            messageId: 'unsafeArrayPatternFromTuple',
             node: receiverProperty.value,
+            messageId: 'unsafeArrayPatternFromTuple',
+            data: createData(senderType),
           });
           didReport = true;
         } else if (
@@ -278,9 +278,9 @@ export default createRule({
         }
 
         context.report({
-          data: createData(senderType),
-          messageId,
           node: reportingNode,
+          messageId,
+          data: createData(senderType),
         });
 
         return true;
@@ -302,9 +302,9 @@ export default createRule({
 
       const { receiver, sender } = result;
       context.report({
-        data: createData(sender, receiver),
-        messageId: 'unsafeAssignment',
         node: reportingNode,
+        messageId: 'unsafeAssignment',
+        data: createData(sender, receiver),
       });
       return true;
     }
@@ -402,9 +402,9 @@ export default createRule({
         const restType = services.getTypeAtLocation(node.argument);
         if (isTypeAnyType(restType) || isTypeAnyArrayType(restType, checker)) {
           context.report({
-            data: createData(restType),
-            messageId: 'unsafeArraySpread',
             node,
+            messageId: 'unsafeArraySpread',
+            data: createData(restType),
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 4ce0b6ff4fa3..4ceed8c4b61d 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -69,11 +69,11 @@ export default createRule<[], MessageIds>({
         const isErrorType = tsutils.isIntrinsicErrorType(type);
 
         context.report({
+          node: reportingNode,
+          messageId,
           data: {
             type: isErrorType ? '`error` type' : '`any`',
           },
-          messageId,
-          node: reportingNode,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
index 28eb665a544c..3a605e81ea53 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-declaration-merging.ts
@@ -39,8 +39,8 @@ export default createRule({
 
       if (defs.some(def => def.node.type === unsafeKind)) {
         context.report({
-          messageId: 'unsafeMerging',
           node,
+          messageId: 'unsafeMerging',
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
index 524951f98b38..fe2106fae9d7 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts
@@ -142,10 +142,11 @@ export default createRule({
 
         if (isMismatchedComparison(leftType, rightType)) {
           context.report({
-            messageId: 'mismatchedCondition',
             node,
+            messageId: 'mismatchedCondition',
             suggest: [
               {
+                messageId: 'replaceValueWithEnum',
                 fix(fixer): TSESLint.RuleFix | null {
                   // Replace the right side with an enum key if possible:
                   //
@@ -178,7 +179,6 @@ export default createRule({
 
                   return null;
                 },
-                messageId: 'replaceValueWithEnum',
               },
             ],
           });
@@ -198,8 +198,8 @@ export default createRule({
 
         if (isMismatchedComparison(leftType, rightType)) {
           context.report({
-            messageId: 'mismatchedCase',
             node,
+            messageId: 'mismatchedCase',
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
index fb00dbe70d84..4d0cee981ec6 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-function-type.ts
@@ -30,8 +30,8 @@ export default createRule({
         isReferenceToGlobalFunction('Function', node, context.sourceCode)
       ) {
         context.report({
-          messageId: 'bannedFunctionType',
           node,
+          messageId: 'bannedFunctionType',
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
index 595ce11f30ab..51fff98c5a55 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-member-access.ts
@@ -95,12 +95,12 @@ export default createRule({
         }
 
         context.report({
+          node: node.property,
+          messageId,
           data: {
             type: createDataType(type),
             property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
           },
-          messageId,
-          node: node.property,
         });
       }
 
@@ -131,12 +131,12 @@ export default createRule({
         if (isTypeAnyType(type)) {
           const propertyName = context.sourceCode.getText(node);
           context.report({
+            node,
+            messageId: 'unsafeComputedMemberAccess',
             data: {
               type: createDataType(type),
               property: `[${propertyName}]`,
             },
-            messageId: 'unsafeComputedMemberAccess',
-            node,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
index e866830e9a02..b5becaa4e633 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
@@ -193,6 +193,8 @@ export default createRule({
 
         // If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
         return context.report({
+          node: reportingNode,
+          messageId,
           data: {
             type: isErrorType
               ? 'error'
@@ -202,8 +204,6 @@ export default createRule({
                   ? '`Promise<any>`'
                   : '`any[]`',
           },
-          messageId,
-          node: reportingNode,
         });
       }
 
@@ -222,12 +222,12 @@ export default createRule({
 
         const { receiver, sender } = result;
         return context.report({
+          node: reportingNode,
+          messageId: 'unsafeReturnAssignment',
           data: {
             receiver: checker.typeToString(receiver),
             sender: checker.typeToString(sender),
           },
-          messageId: 'unsafeReturnAssignment',
-          node: reportingNode,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
index 9bad9d881670..fcfca3145db6 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-unary-minus.ts
@@ -49,9 +49,9 @@ export default util.createRule<Options, MessageIds>({
             )
         ) {
           context.report({
-            data: { type: checker.typeToString(argType) },
-            messageId: 'unaryMinus',
             node,
+            messageId: 'unaryMinus',
+            data: { type: checker.typeToString(argType) },
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index 3467ce20656e..59be0e04d4ca 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -434,9 +434,9 @@ export default createRule<Options, MessageIds>({
         ) {
           if (options.reportUsedIgnorePattern && used) {
             context.report({
-              data: getUsedIgnoredMessageData(variable, 'array-destructure'),
-              messageId: 'usedIgnoredVar',
               node: def.name,
+              messageId: 'usedIgnoredVar',
+              data: getUsedIgnoredMessageData(variable, 'array-destructure'),
             });
           }
           continue;
@@ -464,9 +464,9 @@ export default createRule<Options, MessageIds>({
           ) {
             if (options.reportUsedIgnorePattern && used) {
               context.report({
-                data: getUsedIgnoredMessageData(variable, 'catch-clause'),
-                messageId: 'usedIgnoredVar',
                 node: def.name,
+                messageId: 'usedIgnoredVar',
+                data: getUsedIgnoredMessageData(variable, 'catch-clause'),
               });
             }
             continue;
@@ -483,9 +483,9 @@ export default createRule<Options, MessageIds>({
           ) {
             if (options.reportUsedIgnorePattern && used) {
               context.report({
-                data: getUsedIgnoredMessageData(variable, 'parameter'),
-                messageId: 'usedIgnoredVar',
                 node: def.name,
+                messageId: 'usedIgnoredVar',
+                data: getUsedIgnoredMessageData(variable, 'parameter'),
               });
             }
             continue;
@@ -506,9 +506,9 @@ export default createRule<Options, MessageIds>({
         ) {
           if (options.reportUsedIgnorePattern && used) {
             context.report({
-              data: getUsedIgnoredMessageData(variable, 'variable'),
-              messageId: 'usedIgnoredVar',
               node: def.name,
+              messageId: 'usedIgnoredVar',
+              data: getUsedIgnoredMessageData(variable, 'variable'),
             });
           }
           continue;
@@ -617,11 +617,11 @@ export default createRule<Options, MessageIds>({
             };
 
             context.report({
+              loc,
+              messageId,
               data: unusedVar.references.some(ref => ref.isWrite())
                 ? getAssignedMessageData(unusedVar)
                 : getDefinedMessageData(unusedVar),
-              loc,
-              messageId,
             });
 
             // If there are no regular declaration, report the first `/*globals*/` comment directive.
@@ -632,14 +632,14 @@ export default createRule<Options, MessageIds>({
             const directiveComment = unusedVar.eslintExplicitGlobalComments[0];
 
             context.report({
-              data: getDefinedMessageData(unusedVar),
               loc: getNameLocationInGlobalDirectiveComment(
                 context.sourceCode,
                 directiveComment,
                 unusedVar.name,
               ),
-              messageId: 'unusedVar',
               node: programNode,
+              messageId: 'unusedVar',
+              data: getDefinedMessageData(unusedVar),
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
index 90b209753054..b7f5a2576e40 100644
--- a/packages/eslint-plugin/src/rules/no-use-before-define.ts
+++ b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -314,11 +314,11 @@ export default createRule<Options, MessageIds>({
 
         function report(): void {
           context.report({
+            node: reference.identifier,
+            messageId: 'noUseBeforeDefine',
             data: {
               name: reference.identifier.name,
             },
-            messageId: 'noUseBeforeDefine',
-            node: reference.identifier,
           });
         }
 
diff --git a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
index afc8d7cf3f54..70f3e7e8acae 100644
--- a/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-empty-export.ts
@@ -68,9 +68,9 @@ export default createRule({
       if (foundOtherExport) {
         for (const emptyExport of emptyExports) {
           context.report({
-            fix: fixer => fixer.remove(emptyExport),
-            messageId: 'uselessExport',
             node: emptyExport,
+            messageId: 'uselessExport',
+            fix: fixer => fixer.remove(emptyExport),
           });
         }
       }
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index 0010e41b77a1..19fcd3795294 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -86,8 +86,8 @@ export default createRule<Options, MessageIds>({
 
           if (!variable?.identifiers.length) {
             context.report({
-              messageId: 'noVarReqs',
               node,
+              messageId: 'noVarReqs',
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
index 6172ccc7d472..d587d1871c9b 100644
--- a/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
+++ b/packages/eslint-plugin/src/rules/no-wrapper-object-types.ts
@@ -48,12 +48,12 @@ export default createRule({
       const preferred = typeName.toLowerCase();
 
       context.report({
+        node,
+        messageId: 'bannedClassType',
         data: { preferred, typeName },
         fix: includeFix
           ? (fixer): TSESLint.RuleFix => fixer.replaceText(node, preferred)
           : undefined,
-        messageId: 'bannedClassType',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
index 31bf981787a2..3abdfc0d279c 100644
--- a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
+++ b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -129,6 +129,8 @@ export default createRule({
             ) > OperatorPrecedence.Unary;
 
           context.report({
+            node,
+            messageId: 'preferNonNullAssertion',
             fix(fixer) {
               return fixer.replaceText(
                 node,
@@ -137,8 +139,6 @@ export default createRule({
                   : `(${expressionSourceCode})!`,
               );
             },
-            messageId: 'preferNonNullAssertion',
-            node,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/only-throw-error.ts b/packages/eslint-plugin/src/rules/only-throw-error.ts
index fe3b4d96b5a6..d860bb88d93c 100644
--- a/packages/eslint-plugin/src/rules/only-throw-error.ts
+++ b/packages/eslint-plugin/src/rules/only-throw-error.ts
@@ -69,7 +69,7 @@ export default createRule<Options, MessageIds>({
       const type = services.getTypeAtLocation(node);
 
       if (type.flags & ts.TypeFlags.Undefined) {
-        context.report({ messageId: 'undef', node });
+        context.report({ node, messageId: 'undef' });
         return;
       }
 
@@ -85,7 +85,7 @@ export default createRule<Options, MessageIds>({
         return;
       }
 
-      context.report({ messageId: 'object', node });
+      context.report({ node, messageId: 'object' });
     }
 
     return {
diff --git a/packages/eslint-plugin/src/rules/parameter-properties.ts b/packages/eslint-plugin/src/rules/parameter-properties.ts
index a999dce781d7..a83af1b14135 100644
--- a/packages/eslint-plugin/src/rules/parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/parameter-properties.ts
@@ -118,11 +118,11 @@ export default createRule<Options, MessageIds>({
                   (node.parameter.left as TSESTree.Identifier).name;
 
             context.report({
+              node,
+              messageId: 'preferClassProperty',
               data: {
                 parameter: name,
               },
-              messageId: 'preferClassProperty',
-              node,
             });
           }
         },
@@ -187,11 +187,11 @@ export default createRule<Options, MessageIds>({
             )
           ) {
             context.report({
+              node: nodes.classProperty,
+              messageId: 'preferParameterProperty',
               data: {
                 parameter: name,
               },
-              messageId: 'preferParameterProperty',
-              node: nodes.classProperty,
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/prefer-as-const.ts b/packages/eslint-plugin/src/rules/prefer-as-const.ts
index 4d1cdb2e5796..eb0a1e12008e 100644
--- a/packages/eslint-plugin/src/rules/prefer-as-const.ts
+++ b/packages/eslint-plugin/src/rules/prefer-as-const.ts
@@ -38,21 +38,21 @@ export default createRule({
       ) {
         if (canFix) {
           context.report({
-            fix: fixer => fixer.replaceText(typeNode, 'const'),
-            messageId: 'preferConstAssertion',
             node: typeNode,
+            messageId: 'preferConstAssertion',
+            fix: fixer => fixer.replaceText(typeNode, 'const'),
           });
         } else {
           context.report({
-            messageId: 'variableConstAssertion',
             node: typeNode,
+            messageId: 'variableConstAssertion',
             suggest: [
               {
+                messageId: 'variableSuggest',
                 fix: (fixer): TSESLint.RuleFix[] => [
                   fixer.remove(typeNode.parent),
                   fixer.insertTextAfter(valueNode, ' as const'),
                 ],
-                messageId: 'variableSuggest',
               },
             ],
           });
diff --git a/packages/eslint-plugin/src/rules/prefer-destructuring.ts b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
index 9917e5cf1d52..fdf3bc1deeaf 100644
--- a/packages/eslint-plugin/src/rules/prefer-destructuring.ts
+++ b/packages/eslint-plugin/src/rules/prefer-destructuring.ts
@@ -147,9 +147,9 @@ export default createRule<Options, MessageIds>({
             return;
           }
           context.report({
-            data: { type: 'object' },
-            messageId: 'preferDestructuring',
             node: reportNode,
+            messageId: 'preferDestructuring',
+            data: { type: 'object' },
           });
           return;
         }
diff --git a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
index f4b7e2f843f9..00dae8cccb96 100644
--- a/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
+++ b/packages/eslint-plugin/src/rules/prefer-enum-initializers.ts
@@ -30,32 +30,32 @@ export default createRule<[], MessageIds>({
         if (member.initializer == null) {
           const name = context.sourceCode.getText(member);
           context.report({
+            node: member,
+            messageId: 'defineInitializer',
             data: {
               name,
             },
-            messageId: 'defineInitializer',
-            node: member,
             suggest: [
               {
+                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: index },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = ${index}`);
                 },
-                messageId: 'defineInitializerSuggestion',
               },
               {
+                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: index + 1 },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = ${index + 1}`);
                 },
-                messageId: 'defineInitializerSuggestion',
               },
               {
+                messageId: 'defineInitializerSuggestion',
                 data: { name, suggested: `'${name}'` },
                 fix: (fixer): TSESLint.RuleFix => {
                   return fixer.replaceText(member, `${name} = '${name}'`);
                 },
-                messageId: 'defineInitializerSuggestion',
               },
             ],
           });
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
index b19f46d2355a..cf0ffa82eb4c 100644
--- a/packages/eslint-plugin/src/rules/prefer-find.ts
+++ b/packages/eslint-plugin/src/rules/prefer-find.ts
@@ -251,10 +251,11 @@ export default createRule({
           const filterExpressions = parseArrayFilterExpressions(object);
           if (filterExpressions.length !== 0) {
             context.report({
-              messageId: 'preferFind',
               node,
+              messageId: 'preferFind',
               suggest: [
                 {
+                  messageId: 'preferFindSuggestion',
                   fix: (fixer): TSESLint.RuleFix[] => {
                     return [
                       ...filterExpressions.map(filterExpression =>
@@ -271,7 +272,6 @@ export default createRule({
                       ),
                     ];
                   },
-                  messageId: 'preferFindSuggestion',
                 },
               ],
             });
@@ -291,10 +291,11 @@ export default createRule({
           const filterExpressions = parseArrayFilterExpressions(object);
           if (filterExpressions.length !== 0) {
             context.report({
-              messageId: 'preferFind',
               node,
+              messageId: 'preferFind',
               suggest: [
                 {
+                  messageId: 'preferFindSuggestion',
                   fix: (fixer): TSESLint.RuleFix[] => {
                     return [
                       ...filterExpressions.map(filterExpression =>
@@ -311,7 +312,6 @@ export default createRule({
                       ),
                     ];
                   },
-                  messageId: 'preferFindSuggestion',
                 },
               ],
             });
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
index b6b399dcf3de..ce7ef8a8e180 100644
--- a/packages/eslint-plugin/src/rules/prefer-for-of.ts
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -155,8 +155,8 @@ export default createRule({
           isIndexOnlyUsedWithArray(node.body, indexVar, arrayExpression)
         ) {
           context.report({
-            messageId: 'preferForOf',
             node,
+            messageId: 'preferForOf',
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index 3454088da54a..ff7a26c17caa 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -86,11 +86,11 @@ export default createRule({
           // the message can be confusing if we don't point directly to the `this` node instead of the whole member
           // and in favour of generating at most one error we'll only report the first occurrence of `this` if there are multiple
           context.report({
+            node: tsThisTypes[0],
+            messageId: 'unexpectedThisOnFunctionOnlyInterface',
             data: {
               interfaceName: node.id.name,
             },
-            messageId: 'unexpectedThisOnFunctionOnlyInterface',
-            node: tsThisTypes[0],
           });
           return;
         }
@@ -177,12 +177,12 @@ export default createRule({
             };
 
         context.report({
+          node: member,
+          messageId: 'functionTypeOverCallableType',
           data: {
             literalOrInterface: phrases[node.type],
           },
           fix,
-          messageId: 'functionTypeOverCallableType',
-          node: member,
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
index 5082eb9e88ef..2d01a09b0b7f 100644
--- a/packages/eslint-plugin/src/rules/prefer-includes.ts
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -188,8 +188,8 @@ export default createRule({
 
       // Report it.
       context.report({
-        messageId: 'preferIncludes',
         node: compareNode,
+        messageId: 'preferIncludes',
         ...(allowFixing && {
           *fix(fixer): Generator<TSESLint.RuleFix> {
             if (negative) {
@@ -239,6 +239,8 @@ export default createRule({
         }
 
         context.report({
+          node: callNode,
+          messageId: 'preferStringIncludes',
           *fix(fixer) {
             const argNode = callNode.arguments[0];
             const needsParen =
@@ -259,8 +261,6 @@ export default createRule({
               `${node.optional ? '?.' : '.'}includes('${escapeString(text)}')`,
             );
           },
-          messageId: 'preferStringIncludes',
-          node: callNode,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
index 6f980defce9a..26c75e06ec57 100644
--- a/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
+++ b/packages/eslint-plugin/src/rules/prefer-literal-enum-member.ts
@@ -143,8 +143,8 @@ export default createRule({
         }
 
         context.report({
-          messageId: 'notLiteral',
           node: node.id,
+          messageId: 'notLiteral',
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index a138b9d9064d..774c65e53771 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -35,11 +35,11 @@ export default createRule({
           moduleType.value === 'module'
         ) {
           context.report({
+            node,
+            messageId: 'useNamespace',
             fix(fixer) {
               return fixer.replaceText(moduleType, 'namespace');
             },
-            messageId: 'useNamespace',
-            node,
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 7b2a17b9c170..507441c1715f 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -278,10 +278,11 @@ export default createRule<Options, MessageIds>({
 
         if (isFixable) {
           context.report({
-            messageId: 'preferNullishOverTernary',
             node,
+            messageId: 'preferNullishOverTernary',
             suggest: [
               {
+                messageId: 'suggestNullish',
                 fix(fixer: TSESLint.RuleFixer): TSESLint.RuleFix {
                   const [left, right] =
                     operator === '===' || operator === '=='
@@ -295,7 +296,6 @@ export default createRule<Options, MessageIds>({
                     )}`,
                   );
                 },
-                messageId: 'suggestNullish',
               },
             ],
           });
@@ -376,12 +376,12 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
-          messageId: 'preferNullishOverOr',
           node: barBarOperator,
+          messageId: 'preferNullishOverOr',
           suggest: [
             {
-              fix,
               messageId: 'suggestNullish',
+              fix,
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
index 42079069dafc..070eec96bad1 100644
--- a/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
+++ b/packages/eslint-plugin/src/rules/prefer-optional-chain.ts
@@ -192,10 +192,11 @@ export default createRule<
           return leftPrecedence < OperatorPrecedence.LeftHandSide;
         }
         checkNullishAndReport(context, parserServices, options, [leftNode], {
-          messageId: 'preferOptionalChain',
           node: parentNode,
+          messageId: 'preferOptionalChain',
           suggest: [
             {
+              messageId: 'optionalChainSuggest',
               fix: (fixer): RuleFix => {
                 const leftNodeText = context.sourceCode.getText(leftNode);
                 // Any node that is made of an operator with higher or equal precedence,
@@ -213,7 +214,6 @@ export default createRule<
                   `${maybeWrappedLeftNode}?.${maybeWrappedProperty}`,
                 );
               },
-              messageId: 'optionalChainSuggest',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
index eb7b0040f884..155664548521 100644
--- a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
+++ b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
@@ -69,8 +69,8 @@ export default createRule<Options, MessageIds>({
       }
 
       context.report({
-        messageId: 'rejectAnError',
         node: callExpression,
+        messageId: 'rejectAnError',
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
index 96a294b82b7c..7d343d6eda5a 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly-parameter-types.ts
@@ -122,8 +122,8 @@ export default createRule<Options, MessageIds>({
 
           if (!isReadOnly) {
             context.report({
-              messageId: 'shouldBeReadonly',
               node: actualParam,
+              messageId: 'shouldBeReadonly',
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
index 8fd23a7bea50..9a543e514dd6 100644
--- a/packages/eslint-plugin/src/rules/prefer-readonly.ts
+++ b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -229,11 +229,11 @@ export default createRule<Options, MessageIds>({
 
           context.report({
             ...reportNodeOrLoc,
+            messageId: 'preferReadonly',
             data: {
               name: context.sourceCode.getText(nameNode),
             },
             fix: fixer => fixer.insertTextBefore(nameNode, 'readonly '),
-            messageId: 'preferReadonly',
           });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
index 8da4992ed537..012235e21be5 100644
--- a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
+++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -87,6 +87,8 @@ export default createRule({
         // Check the owner type of the `reduce` method.
         if (isArrayType(calleeObjType)) {
           context.report({
+            node: secondArg,
+            messageId: 'preferTypeParameter',
             fix: fixer => {
               const fixes = [
                 fixer.removeRange([
@@ -110,8 +112,6 @@ export default createRule({
 
               return fixes;
             },
-            messageId: 'preferTypeParameter',
-            node: secondArg,
           });
 
           return;
diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
index c51ed2dd438e..2e378c346577 100644
--- a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
+++ b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -134,14 +134,14 @@ export default createRule({
             return;
           }
           return context.report({
+            node: memberNode.property,
+            messageId: 'regExpExecOverStringMatch',
             fix: getWrappingFixer({
-              innerNode: [objectNode],
               node: callNode,
+              innerNode: [objectNode],
               sourceCode: context.sourceCode,
               wrap: objectCode => `${regExp.toString()}.exec(${objectCode})`,
             }),
-            messageId: 'regExpExecOverStringMatch',
-            node: memberNode.property,
           });
         }
 
@@ -152,28 +152,28 @@ export default createRule({
         switch (argumentTypes) {
           case ArgumentType.RegExp:
             return context.report({
+              node: memberNode.property,
+              messageId: 'regExpExecOverStringMatch',
               fix: getWrappingFixer({
-                innerNode: [objectNode, argumentNode],
                 node: callNode,
+                innerNode: [objectNode, argumentNode],
                 sourceCode: context.sourceCode,
                 wrap: (objectCode, argumentCode) =>
                   `${argumentCode}.exec(${objectCode})`,
               }),
-              messageId: 'regExpExecOverStringMatch',
-              node: memberNode.property,
             });
 
           case ArgumentType.String:
             return context.report({
+              node: memberNode.property,
+              messageId: 'regExpExecOverStringMatch',
               fix: getWrappingFixer({
-                innerNode: [objectNode, argumentNode],
                 node: callNode,
+                innerNode: [objectNode, argumentNode],
                 sourceCode: context.sourceCode,
                 wrap: (objectCode, argumentCode) =>
                   `RegExp(${argumentCode}).exec(${objectCode})`,
               }),
-              messageId: 'regExpExecOverStringMatch',
-              node: memberNode.property,
             });
         }
       },
diff --git a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
index 8e7412b29ee4..057e6cbd56e1 100644
--- a/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-return-this-type.ts
@@ -140,9 +140,9 @@ export default createRule({
 
       if (isFunctionReturningThis(originalFunc, originalClass)) {
         context.report({
-          fix: fixer => fixer.replaceText(node, 'this'),
-          messageId: 'useThisType',
           node,
+          messageId: 'useThisType',
+          fix: fixer => fixer.replaceText(node, 'this'),
         });
       }
     }
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
index 6aaebc20a98c..b8972897361b 100644
--- a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -435,6 +435,8 @@ export default createRule<Options, MessageIds>({
 
         const eqNode = parentNode;
         context.report({
+          node: parentNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           fix(fixer) {
             // Don't fix if it can change the behavior.
             if (!isCharacter(eqNode.right)) {
@@ -448,8 +450,6 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
-          node: parentNode,
         });
       },
 
@@ -471,6 +471,8 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
+          node: parentNode,
+          messageId: 'preferStartsWith',
           fix(fixer) {
             return fixWithArgument(
               fixer,
@@ -482,8 +484,6 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
-          messageId: 'preferStartsWith',
-          node: parentNode,
         });
       },
 
@@ -509,6 +509,8 @@ export default createRule<Options, MessageIds>({
         }
 
         context.report({
+          node: parentNode,
+          messageId: 'preferEndsWith',
           fix(fixer) {
             return fixWithArgument(
               fixer,
@@ -520,8 +522,6 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
-          messageId: 'preferEndsWith',
-          node: parentNode,
         });
       },
 
@@ -552,6 +552,8 @@ export default createRule<Options, MessageIds>({
 
         const { isStartsWith, text } = parsed;
         context.report({
+          node: callNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           *fix(fixer) {
             if (!parentNode.operator.startsWith('!')) {
               yield fixer.insertTextBefore(parentNode, '!');
@@ -568,8 +570,6 @@ export default createRule<Options, MessageIds>({
             );
             yield fixer.removeRange([callNode.range[1], parentNode.range[1]]);
           },
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
-          node: callNode,
         });
       },
 
@@ -638,6 +638,8 @@ export default createRule<Options, MessageIds>({
         const negativeIndexSupported =
           (node.property as TSESTree.Identifier).name === 'slice';
         context.report({
+          node: parentNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
           fix(fixer) {
             // Don't fix if it can change the behavior.
             if (
@@ -678,8 +680,6 @@ export default createRule<Options, MessageIds>({
               node.optional,
             );
           },
-          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
-          node: parentNode,
         });
       },
 
@@ -699,6 +699,8 @@ export default createRule<Options, MessageIds>({
         const messageId = isStartsWith ? 'preferStartsWith' : 'preferEndsWith';
         const methodName = isStartsWith ? 'startsWith' : 'endsWith';
         context.report({
+          node: callNode,
+          messageId,
           *fix(fixer) {
             const argNode = callNode.arguments[0];
             const needsParen =
@@ -720,8 +722,6 @@ export default createRule<Options, MessageIds>({
               )}`,
             );
           },
-          messageId,
-          node: callNode,
         });
       },
     };
diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
index 7b21d55378aa..dc01b4a59a08 100644
--- a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
+++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts
@@ -70,11 +70,11 @@ export default createRule<[], MessageIds>({
               );
 
             context.report({
+              node: comment,
+              messageId: 'preferExpectErrorComment',
               fix: isLineComment(comment)
                 ? lineCommentRuleFixer
                 : blockCommentRuleFixer,
-              messageId: 'preferExpectErrorComment',
-              node: comment,
             });
           }
         });
diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
index bc92232846e8..fb0d34e44a73 100644
--- a/packages/eslint-plugin/src/rules/promise-function-async.ts
+++ b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -148,12 +148,15 @@ export default createRule<Options, MessageIds>({
         // Report without auto fixer because the return type is unknown
         return context.report({
           loc: getFunctionHeadLoc(node, context.sourceCode),
-          messageId: 'missingAsync',
           node,
+          messageId: 'missingAsync',
         });
       }
 
       context.report({
+        loc: getFunctionHeadLoc(node, context.sourceCode),
+        node,
+        messageId: 'missingAsync',
         fix: fixer => {
           if (
             node.parent.type === AST_NODE_TYPES.MethodDefinition ||
@@ -210,9 +213,6 @@ export default createRule<Options, MessageIds>({
 
           return fixer.insertTextBefore(node, 'async ');
         },
-        loc: getFunctionHeadLoc(node, context.sourceCode),
-        messageId: 'missingAsync',
-        node,
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
index c2c69cbcf1d4..05d60b60e447 100644
--- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
+++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts
@@ -75,7 +75,7 @@ export default createRule<Options, MessageIds>({
       }
 
       if (isTypeArrayTypeOrUnionOfArrayTypes(calleeObjType, checker)) {
-        context.report({ messageId: 'requireCompare', node: callee.parent });
+        context.report({ node: callee.parent, messageId: 'requireCompare' });
       }
     }
 
diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index f6018d5e846a..9d0fd1d40ffa 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -187,21 +187,21 @@ export default createRule({
         }
 
         context.report({
+          loc: getFunctionHeadLoc(node, context.sourceCode),
+          node,
+          messageId: 'missingAwait',
           data: {
             name: upperCaseFirst(getFunctionNameWithKind(node)),
           },
-          loc: getFunctionHeadLoc(node, context.sourceCode),
-          messageId: 'missingAwait',
-          node,
           suggest: [
             {
+              messageId: 'removeAsync',
               fix: (fixer): RuleFix[] =>
                 changes.map(change =>
                   change.replacement !== undefined
                     ? fixer.replaceTextRange(change.range, change.replacement)
                     : fixer.removeRange(change.range),
                 ),
-              messageId: 'removeAsync',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index 80ad7ea4b151..306342754018 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -172,12 +172,12 @@ export default createRule<Options, MessageIds>({
             isTypeFlagSet(baseType, ts.TypeFlags.Null | ts.TypeFlags.Undefined))
         ) {
           context.report({
+            node: baseNode,
+            messageId: 'invalid',
             data: {
               type: typeChecker.typeToString(baseType),
               stringLike,
             },
-            messageId: 'invalid',
-            node: baseNode,
           });
           hadIndividualComplaint = true;
           continue;
@@ -194,12 +194,12 @@ export default createRule<Options, MessageIds>({
                 isDeeplyObjectType(subBaseType)
           ) {
             context.report({
+              node: baseNode,
+              messageId: 'invalid',
               data: {
                 type: typeChecker.typeToString(subBaseType),
                 stringLike,
               },
-              messageId: 'invalid',
-              node: baseNode,
             });
             hadIndividualComplaint = true;
             continue;
@@ -221,13 +221,13 @@ export default createRule<Options, MessageIds>({
           isTypeFlagSetInUnion(otherType, ts.TypeFlags.NumberLike)
         ) {
           return context.report({
+            node,
+            messageId: 'mismatched',
             data: {
               left: typeChecker.typeToString(leftType),
               right: typeChecker.typeToString(rightType),
               stringLike,
             },
-            messageId: 'mismatched',
-            node,
           });
         }
 
@@ -236,12 +236,12 @@ export default createRule<Options, MessageIds>({
           isTypeFlagSetInUnion(otherType, ts.TypeFlags.BigIntLike)
         ) {
           return context.report({
+            node,
+            messageId: 'bigintAndNumber',
             data: {
               left: typeChecker.typeToString(leftType),
               right: typeChecker.typeToString(rightType),
             },
-            messageId: 'bigintAndNumber',
-            node,
           });
         }
       }
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index bc9784ed8564..b546ac0d02fd 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -128,9 +128,9 @@ export default createRule<Options, MessageId>({
 
           if (!recursivelyCheckType(expressionType)) {
             context.report({
-              data: { type: checker.typeToString(expressionType) },
-              messageId: 'invalidType',
               node: expression,
+              messageId: 'invalidType',
+              data: { type: checker.typeToString(expressionType) },
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
index 579172859f22..b5ac4eb88a27 100644
--- a/packages/eslint-plugin/src/rules/return-await.ts
+++ b/packages/eslint-plugin/src/rules/return-await.ts
@@ -293,11 +293,11 @@ export default createRule({
           const useAutoFix = !(isTypeAnyType(type) || isTypeUnknownType(type));
 
           context.report({
-            messageId: 'nonPromiseAwait',
             node,
+            messageId: 'nonPromiseAwait',
             ...fixOrSuggest(useAutoFix, {
-              fix: fixer => removeAwait(fixer, node),
               messageId: 'nonPromiseAwait',
+              fix: fixer => removeAwait(fixer, node),
             }),
           });
         }
@@ -321,16 +321,16 @@ export default createRule({
         case 'await':
           if (!isAwait) {
             context.report({
-              messageId: 'requiredPromiseAwait',
               node,
+              messageId: 'requiredPromiseAwait',
               ...fixOrSuggest(useAutoFix, {
+                messageId: 'requiredPromiseAwaitSuggestion',
                 fix: fixer =>
                   insertAwait(
                     fixer,
                     node,
                     isHigherPrecedenceThanAwait(expression),
                   ),
-                messageId: 'requiredPromiseAwaitSuggestion',
               }),
             });
           }
@@ -340,11 +340,11 @@ export default createRule({
         case 'no-await':
           if (isAwait) {
             context.report({
-              messageId: 'disallowedPromiseAwait',
               node,
+              messageId: 'disallowedPromiseAwait',
               ...fixOrSuggest(useAutoFix, {
-                fix: fixer => removeAwait(fixer, node),
                 messageId: 'disallowedPromiseAwaitSuggestion',
+                fix: fixer => removeAwait(fixer, node),
               }),
             });
           }
diff --git a/packages/eslint-plugin/src/rules/sort-type-constituents.ts b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
index 3f8b8e60a958..87e40ea75ed2 100644
--- a/packages/eslint-plugin/src/rules/sort-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/sort-type-constituents.ts
@@ -200,8 +200,8 @@ export default createRule<Options, MessageIds>({
       const sourceOrder = node.types.map(type => {
         const group = groupOrder?.indexOf(getGroup(type)) ?? -1;
         return {
-          group: group === -1 ? Number.MAX_SAFE_INTEGER : group,
           node: type,
+          group: group === -1 ? Number.MAX_SAFE_INTEGER : group,
           text: context.sourceCode.getText(type),
         };
       });
@@ -258,17 +258,17 @@ export default createRule<Options, MessageIds>({
             return fixer.replaceText(node, sorted);
           };
           return context.report({
-            data,
-            messageId,
             node,
+            messageId,
+            data,
             // don't autofix if any of the types have leading/trailing comments
             // the logic for preserving them correctly is a pain - we may implement this later
             ...(hasComments
               ? {
                   suggest: [
                     {
-                      fix,
                       messageId: 'suggestFix',
+                      fix,
                     },
                   ],
                 }
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index dbdfacb03d4a..99b8f095071c 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -429,7 +429,7 @@ export default createRule<Options, MessageId>({
       // nullish
       if (is('nullish')) {
         // condition is always false
-        context.report({ messageId: 'conditionErrorNullish', node });
+        context.report({ node, messageId: 'conditionErrorNullish' });
         return;
       }
 
@@ -444,49 +444,49 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableBoolean)
             context.report({
-              messageId: 'conditionErrorNullableBoolean',
               node,
+              messageId: 'conditionErrorNullableBoolean',
               suggest: [
                 {
+                  messageId: 'conditionFixDefaultFalse',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? false`,
                   }),
-                  messageId: 'conditionFixDefaultFalse',
                 },
                 {
+                  messageId: 'conditionFixCompareFalse',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} === false`,
                   }),
-                  messageId: 'conditionFixCompareFalse',
                 },
               ],
             });
           } else {
             // if (nullableBoolean)
             context.report({
-              messageId: 'conditionErrorNullableBoolean',
               node,
+              messageId: 'conditionErrorNullableBoolean',
               suggest: [
                 {
+                  messageId: 'conditionFixDefaultFalse',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? false`,
                   }),
-                  messageId: 'conditionFixDefaultFalse',
                 },
                 {
+                  messageId: 'conditionFixCompareTrue',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} === true`,
                   }),
-                  messageId: 'conditionFixCompareTrue',
                 },
               ],
             });
@@ -509,67 +509,67 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!string)
             context.report({
-              messageId: 'conditionErrorString',
               node,
+              messageId: 'conditionErrorString',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareStringLength',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code}.length === 0`,
                   }),
-                  messageId: 'conditionFixCompareStringLength',
                 },
                 {
+                  messageId: 'conditionFixCompareEmptyString',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} === ""`,
                   }),
-                  messageId: 'conditionFixCompareEmptyString',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (string)
             context.report({
-              messageId: 'conditionErrorString',
               node,
+              messageId: 'conditionErrorString',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareStringLength',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code}.length > 0`,
                   }),
-                  messageId: 'conditionFixCompareStringLength',
                 },
                 {
+                  messageId: 'conditionFixCompareEmptyString',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} !== ""`,
                   }),
-                  messageId: 'conditionFixCompareEmptyString',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -584,66 +584,66 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableString)
             context.report({
-              messageId: 'conditionErrorNullableString',
               node,
+              messageId: 'conditionErrorNullableString',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
                 {
+                  messageId: 'conditionFixDefaultEmptyString',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? ""`,
                   }),
-                  messageId: 'conditionFixDefaultEmptyString',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (nullableString)
             context.report({
-              messageId: 'conditionErrorNullableString',
               node,
+              messageId: 'conditionErrorNullableString',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
                 {
+                  messageId: 'conditionFixDefaultEmptyString',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? ""`,
                   }),
-                  messageId: 'conditionFixDefaultEmptyString',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -659,93 +659,93 @@ export default createRule<Options, MessageId>({
             if (isLogicalNegationExpression(node.parent)) {
               // if (!array.length)
               context.report({
+                node,
+                messageId: 'conditionErrorNumber',
                 fix: getWrappingFixer({
-                  innerNode: node,
                   node: node.parent,
+                  innerNode: node,
                   sourceCode: context.sourceCode,
                   wrap: code => `${code} === 0`,
                 }),
-                messageId: 'conditionErrorNumber',
-                node,
               });
             } else {
               // if (array.length)
               context.report({
+                node,
+                messageId: 'conditionErrorNumber',
                 fix: getWrappingFixer({
                   node,
                   sourceCode: context.sourceCode,
                   wrap: code => `${code} > 0`,
                 }),
-                messageId: 'conditionErrorNumber',
-                node,
               });
             }
           } else if (isLogicalNegationExpression(node.parent)) {
             // if (!number)
             context.report({
-              messageId: 'conditionErrorNumber',
               node,
+              messageId: 'conditionErrorNumber',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareZero',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     // TODO: we have to compare to 0n if the type is bigint
                     wrap: code => `${code} === 0`,
                   }),
-                  messageId: 'conditionFixCompareZero',
                 },
                 {
                   // TODO: don't suggest this for bigint because it can't be NaN
+                  messageId: 'conditionFixCompareNaN',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `Number.isNaN(${code})`,
                   }),
-                  messageId: 'conditionFixCompareNaN',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (number)
             context.report({
-              messageId: 'conditionErrorNumber',
               node,
+              messageId: 'conditionErrorNumber',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareZero',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} !== 0`,
                   }),
-                  messageId: 'conditionFixCompareZero',
                 },
                 {
+                  messageId: 'conditionFixCompareNaN',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `!Number.isNaN(${code})`,
                   }),
-                  messageId: 'conditionFixCompareNaN',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -760,66 +760,66 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableNumber)
             context.report({
-              messageId: 'conditionErrorNullableNumber',
               node,
+              messageId: 'conditionErrorNullableNumber',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
                 {
+                  messageId: 'conditionFixDefaultZero',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? 0`,
                   }),
-                  messageId: 'conditionFixDefaultZero',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `!Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
           } else {
             // if (nullableNumber)
             context.report({
-              messageId: 'conditionErrorNullableNumber',
               node,
+              messageId: 'conditionErrorNullableNumber',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
                 {
+                  messageId: 'conditionFixDefaultZero',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} ?? 0`,
                   }),
-                  messageId: 'conditionFixDefaultZero',
                 },
                 {
+                  messageId: 'conditionFixCastBoolean',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `Boolean(${code})`,
                   }),
-                  messageId: 'conditionFixCastBoolean',
                 },
               ],
             });
@@ -831,7 +831,7 @@ export default createRule<Options, MessageId>({
       // object
       if (is('object')) {
         // condition is always true
-        context.report({ messageId: 'conditionErrorObject', node });
+        context.report({ node, messageId: 'conditionErrorObject' });
         return;
       }
 
@@ -841,33 +841,33 @@ export default createRule<Options, MessageId>({
           if (isLogicalNegationExpression(node.parent)) {
             // if (!nullableObject)
             context.report({
-              messageId: 'conditionErrorNullableObject',
               node,
+              messageId: 'conditionErrorNullableObject',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
-                    innerNode: node,
                     node: node.parent,
+                    innerNode: node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} == null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
               ],
             });
           } else {
             // if (nullableObject)
             context.report({
-              messageId: 'conditionErrorNullableObject',
               node,
+              messageId: 'conditionErrorNullableObject',
               suggest: [
                 {
+                  messageId: 'conditionFixCompareNullish',
                   fix: getWrappingFixer({
                     node,
                     sourceCode: context.sourceCode,
                     wrap: code => `${code} != null`,
                   }),
-                  messageId: 'conditionFixCompareNullish',
                 },
               ],
             });
@@ -891,24 +891,24 @@ export default createRule<Options, MessageId>({
         if (!options.allowNullableEnum) {
           if (isLogicalNegationExpression(node.parent)) {
             context.report({
+              node,
+              messageId: 'conditionErrorNullableEnum',
               fix: getWrappingFixer({
-                innerNode: node,
                 node: node.parent,
+                innerNode: node,
                 sourceCode: context.sourceCode,
                 wrap: code => `${code} == null`,
               }),
-              messageId: 'conditionErrorNullableEnum',
-              node,
             });
           } else {
             context.report({
+              node,
+              messageId: 'conditionErrorNullableEnum',
               fix: getWrappingFixer({
                 node,
                 sourceCode: context.sourceCode,
                 wrap: code => `${code} != null`,
               }),
-              messageId: 'conditionErrorNullableEnum',
-              node,
             });
           }
         }
@@ -919,16 +919,16 @@ export default createRule<Options, MessageId>({
       if (is('any')) {
         if (!options.allowAny) {
           context.report({
-            messageId: 'conditionErrorAny',
             node,
+            messageId: 'conditionErrorAny',
             suggest: [
               {
+                messageId: 'conditionFixCastBoolean',
                 fix: getWrappingFixer({
                   node,
                   sourceCode: context.sourceCode,
                   wrap: code => `Boolean(${code})`,
                 }),
-                messageId: 'conditionFixCastBoolean',
               },
             ],
           });
@@ -937,7 +937,7 @@ export default createRule<Options, MessageId>({
       }
 
       // other
-      context.report({ messageId: 'conditionErrorOther', node });
+      context.report({ node, messageId: 'conditionErrorOther' });
     }
 
     /** The types we care about */
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
index b376784d0331..c5ebc2970175 100644
--- a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
+++ b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
@@ -161,6 +161,8 @@ export default createRule<Options, MessageIds>({
       // match the members of a union.
       if (missingLiteralBranchTypes.length > 0 && defaultCase === undefined) {
         context.report({
+          node: node.discriminant,
+          messageId: 'switchIsNotExhaustive',
           data: {
             missingBranches: missingLiteralBranchTypes
               .map(missingType =>
@@ -170,10 +172,9 @@ export default createRule<Options, MessageIds>({
               )
               .join(' | '),
           },
-          messageId: 'switchIsNotExhaustive',
-          node: node.discriminant,
           suggest: [
             {
+              messageId: 'addMissingCases',
               fix(fixer): TSESLint.RuleFix | null {
                 return fixSwitch(
                   fixer,
@@ -182,7 +183,6 @@ export default createRule<Options, MessageIds>({
                   symbolName?.toString(),
                 );
               },
-              messageId: 'addMissingCases',
             },
           ],
         });
@@ -285,8 +285,8 @@ export default createRule<Options, MessageIds>({
         !containsNonLiteralType
       ) {
         context.report({
-          messageId: 'dangerousDefaultCase',
           node: defaultCase,
+          messageId: 'dangerousDefaultCase',
         });
       }
     }
@@ -303,15 +303,15 @@ export default createRule<Options, MessageIds>({
 
       if (containsNonLiteralType && defaultCase === undefined) {
         context.report({
-          data: { missingBranches: 'default' },
-          messageId: 'switchIsNotExhaustive',
           node: node.discriminant,
+          messageId: 'switchIsNotExhaustive',
+          data: { missingBranches: 'default' },
           suggest: [
             {
+              messageId: 'addMissingCases',
               fix(fixer): TSESLint.RuleFix {
                 return fixSwitch(fixer, node, [null]);
               },
-              messageId: 'addMissingCases',
             },
           ],
         });
diff --git a/packages/eslint-plugin/src/rules/triple-slash-reference.ts b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
index c2999060415e..57e150c23e07 100644
--- a/packages/eslint-plugin/src/rules/triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/triple-slash-reference.ts
@@ -66,11 +66,11 @@ export default createRule<Options, MessageIds>({
       references.forEach(reference => {
         if (reference.importName === source.value) {
           context.report({
+            node: reference.comment,
+            messageId: 'tripleSlashReference',
             data: {
               module: reference.importName,
             },
-            messageId: 'tripleSlashReference',
-            node: reference.comment,
           });
         }
       });
@@ -104,11 +104,11 @@ export default createRule<Options, MessageIds>({
               (referenceResult[1] === 'lib' && lib === 'never')
             ) {
               context.report({
+                node: comment,
+                messageId: 'tripleSlashReference',
                 data: {
                   module: referenceResult[2],
                 },
-                messageId: 'tripleSlashReference',
-                node: comment,
               });
               return;
             }
diff --git a/packages/eslint-plugin/src/rules/typedef.ts b/packages/eslint-plugin/src/rules/typedef.ts
index c46b4810451a..1ad02b167717 100644
--- a/packages/eslint-plugin/src/rules/typedef.ts
+++ b/packages/eslint-plugin/src/rules/typedef.ts
@@ -76,9 +76,9 @@ export default createRule<[Options], MessageIds>({
   ) {
     function report(location: TSESTree.Node, name?: string): void {
       context.report({
-        data: { name },
-        messageId: name ? 'expectedTypedefNamed' : 'expectedTypedef',
         node: location,
+        messageId: name ? 'expectedTypedefNamed' : 'expectedTypedef',
+        data: { name },
       });
     }
 
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 69eeb5b31a7b..37e8d0868e25 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -154,11 +154,11 @@ export default createRule<Options, MessageIds>({
       );
       if (dangerous) {
         context.report({
+          node,
           messageId:
             firstParamIsThis === false
               ? 'unboundWithoutThisAnnotation'
               : 'unbound',
-          node,
         });
         return true;
       }
diff --git a/packages/eslint-plugin/src/rules/unified-signatures.ts b/packages/eslint-plugin/src/rules/unified-signatures.ts
index 20561350163e..29a64f8c11ed 100644
--- a/packages/eslint-plugin/src/rules/unified-signatures.ts
+++ b/packages/eslint-plugin/src/rules/unified-signatures.ts
@@ -130,6 +130,9 @@ export default createRule<Options, MessageIds>({
               : p1.typeAnnotation;
 
             context.report({
+              loc: p1.loc,
+              node: p1,
+              messageId: 'singleParameterDifference',
               data: {
                 failureStringStart: failureStringStart(lineOfOtherOverload),
                 type1: context.sourceCode.getText(
@@ -139,9 +142,6 @@ export default createRule<Options, MessageIds>({
                   typeAnnotation1?.typeAnnotation,
                 ),
               },
-              loc: p1.loc,
-              messageId: 'singleParameterDifference',
-              node: p1,
             });
             break;
           }
@@ -152,15 +152,15 @@ export default createRule<Options, MessageIds>({
               : otherSignature.loc.start.line;
 
             context.report({
-              data: {
-                failureStringStart: failureStringStart(lineOfOtherOverload),
-              },
               loc: extraParameter.loc,
+              node: extraParameter,
               messageId:
                 extraParameter.type === AST_NODE_TYPES.RestElement
                   ? 'omittingRestParameter'
                   : 'omittingSingleParameter',
-              node: extraParameter,
+              data: {
+                failureStringStart: failureStringStart(lineOfOtherOverload),
+              },
             });
           }
         }
diff --git a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
index 31e05dfc494a..520a62ee5f84 100644
--- a/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
+++ b/packages/eslint-plugin/src/rules/use-unknown-in-catch-callback-variable.ts
@@ -163,6 +163,7 @@ export default createRule<[], MessageIds>({
               node: catchVariableOuter,
               suggest: [
                 {
+                  messageId: 'addUnknownTypeAnnotationSuggestion',
                   fix: (fixer: TSESLint.RuleFixer): TSESLint.RuleFix[] => {
                     if (
                       argument.type ===
@@ -179,7 +180,6 @@ export default createRule<[], MessageIds>({
                       fixer.insertTextAfter(catchVariableInner, ': unknown'),
                     ];
                   },
-                  messageId: 'addUnknownTypeAnnotationSuggestion',
                 },
               ],
             };
@@ -189,23 +189,23 @@ export default createRule<[], MessageIds>({
             node: catchVariableOuter,
             suggest: [
               {
+                messageId: 'wrongTypeAnnotationSuggestion',
                 fix: (fixer: TSESLint.RuleFixer): TSESLint.RuleFix =>
                   fixer.replaceText(catchVariableTypeAnnotation, ': unknown'),
-                messageId: 'wrongTypeAnnotationSuggestion',
               },
             ],
           };
         }
         case AST_NODE_TYPES.ArrayPattern: {
           return {
-            messageId: 'useUnknownArrayDestructuringPattern',
             node: catchVariableOuter,
+            messageId: 'useUnknownArrayDestructuringPattern',
           };
         }
         case AST_NODE_TYPES.ObjectPattern: {
           return {
-            messageId: 'useUnknownObjectDestructuringPattern',
             node: catchVariableOuter,
+            messageId: 'useUnknownObjectDestructuringPattern',
           };
         }
         case AST_NODE_TYPES.RestElement: {
@@ -215,9 +215,9 @@ export default createRule<[], MessageIds>({
               node: catchVariableOuter,
               suggest: [
                 {
+                  messageId: 'addUnknownRestTypeAnnotationSuggestion',
                   fix: (fixer): TSESLint.RuleFix =>
                     fixer.insertTextAfter(catchVariableInner, ': [unknown]'),
-                  messageId: 'addUnknownRestTypeAnnotationSuggestion',
                 },
               ],
             };
@@ -226,9 +226,9 @@ export default createRule<[], MessageIds>({
             node: catchVariableOuter,
             suggest: [
               {
+                messageId: 'wrongRestTypeAnnotationSuggestion',
                 fix: (fixer): TSESLint.RuleFix =>
                   fixer.replaceText(catchVariableTypeAnnotation, ': [unknown]'),
-                messageId: 'wrongRestTypeAnnotationSuggestion',
               },
             ],
           };
@@ -299,9 +299,9 @@ export default createRule<[], MessageIds>({
           // to determine exactly where, and whether we can fix it.
           const overrides = refineReportIfPossible(node);
           context.report({
-            data,
-            messageId: 'useUnknown',
             node,
+            messageId: 'useUnknown',
+            data,
             ...overrides,
           });
         }
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 e238eaf75dad..a6469f6ffe64 100644
--- a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
@@ -5,496 +5,476 @@ import rule from '../../src/rules/adjacent-overload-signatures';
 const ruleTester = new RuleTester();
 
 ruleTester.run('adjacent-overload-signatures', rule, {
-  invalid: [
+  valid: [
     {
       code: `
-function wrap() {
-  function foo(s: string);
-  function foo(n: number);
-  type bar = number;
-  function foo(sn: string | number) {}
-}
+function error(a: string);
+function error(b: number);
+function error(ab: string | number) {}
+export { error };
       `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: `
-if (true) {
-  function foo(s: string);
-  function foo(n: number);
-  let a = 1;
-  function foo(sn: string | number) {}
-  foo(a);
+import { connect } from 'react-redux';
+export interface ErrorMessageModel {
+  message: string;
 }
+function mapStateToProps() {}
+function mapDispatchToProps() {}
+export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
       `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
-    {
-      code: `
+    `
+export const foo = 'a',
+  bar = 'b';
+export interface Foo {}
+export class Foo {}
+    `,
+    `
+export interface Foo {}
+export const foo = 'a',
+  bar = 'b';
+export class Foo {}
+    `,
+    `
+const foo = 'a',
+  bar = 'b';
+interface Foo {}
+class Foo {}
+    `,
+    `
+interface Foo {}
+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 {}
-export function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-export function foo(s: string);
-export function foo(n: number);
-export type bar = number;
-export type baz = number | string;
-export function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 function foo(s: string);
 function foo(n: number);
+function foo(sn: string | number) {}
 function bar(): void {}
 function baz(): void {}
-function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-function foo(s: string);
-function foo(n: number);
-type bar = number;
-type baz = number | string;
-function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-function foo(s: string) {}
-function foo(n: number) {}
-const a = '';
-const b = '';
-function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-function foo(s: string) {}
-function foo(n: number) {}
-class Bar {}
-function foo(sn: string | number) {}
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 5,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-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) {}
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'foo' },
-          line: 9,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 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 function foo(sn: string | number);
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-declare function foo(s: string);
-declare function foo(n: number);
-const a = '';
-const b = '';
-declare function foo(sn: string | number);
-      `,
-      errors: [
-        {
-          column: 1,
-          data: { name: 'foo' },
-          line: 6,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 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;
-  export function foo(sn: string | number): void;
 }
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'foo' },
-          line: 7,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-declare module 'Foo' {
+    `,
+    `
+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 baz(): void;
 }
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'baz' },
-          line: 8,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
+    `,
+    `
+type Foo = {
+  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;
+};
+    `,
+    `
+interface Foo {
+  (s: string): void;
+  (n: number): void;
+  (sn: string | number): void;
+  foo(n: 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;
+  call(): void;
+}
+    `,
+    `
+interface Foo {
+  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;
+}
+    `,
+    `
+interface Foo {
+  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;
+}
+    `,
+    `
+class Foo {
+  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 {}
+}
+    `,
+    `
+class Foo {
+  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 {}
+}
+    `,
+    `
+class Foo {
+  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) {}',
+    `
+interface Foo {
+  [Symbol.toStringTag](): void;
+  [Symbol.iterator](): void;
+}
+    `,
+    // private members
+    `
+class Test {
+  #private(): void;
+  #private(arg: number): void {}
+
+  bar() {}
+
+  '#private'(): void;
+  '#private'(arg: number): void {}
+}
+    `,
+    // block statement
+    `
+function wrap() {
+  function foo(s: string);
+  function foo(n: number);
+  function foo(sn: string | number) {}
+}
+    `,
+    `
+if (true) {
+  function foo(s: string);
+  function foo(n: number);
+  function foo(sn: string | number) {}
+}
+    `,
+  ],
+  invalid: [
     {
       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;
+function wrap() {
+  function foo(s: string);
+  function foo(n: number);
+  type bar = number;
+  function foo(sn: string | number) {}
 }
       `,
       errors: [
         {
           column: 3,
           data: { name: 'foo' },
-          line: 7,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       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;
+if (true) {
+  function foo(s: string);
+  function foo(n: number);
+  let a = 1;
+  function foo(sn: string | number) {}
+  foo(a);
 }
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { name: 'baz' },
-          line: 8,
-          messageId: 'adjacentSignature',
-        },
-      ],
-    },
-    {
-      code: `
-type Foo = {
-  foo(s: string): void;
-  foo(n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-};
       `,
       errors: [
         {
           column: 3,
           data: { name: 'foo' },
-          line: 7,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-type Foo = {
-  foo(s: string): void;
-  ['foo'](n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-};
+export function foo(s: string);
+export function foo(n: number);
+export function bar(): void {}
+export function baz(): void {}
+export function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
+          column: 1,
           data: { name: 'foo' },
-          line: 7,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-type Foo = {
-  foo(s: string): void;
-  name: string;
-  foo(n: number): void;
-  foo(sn: string | number): void;
-  bar(): void;
-  baz(): void;
-};
+export function foo(s: string);
+export function foo(n: number);
+export type bar = number;
+export type baz = number | string;
+export function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
+          column: 1,
           data: { name: 'foo' },
-          line: 5,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  (s: string): void;
-  foo(n: number): void;
-  (n: number): void;
-  (sn: string | number): void;
-  bar(): void;
-  baz(): void;
-  call(): void;
-}
+function foo(s: string);
+function foo(n: number);
+function bar(): void {}
+function baz(): void {}
+function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
-          data: { name: 'call' },
-          line: 5,
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  foo(s: string): void;
-  foo(n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-}
+function foo(s: string);
+function foo(n: number);
+type bar = number;
+type baz = number | string;
+function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
+          column: 1,
           data: { name: 'foo' },
-          line: 7,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  foo(s: string): void;
-  ['foo'](n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-}
+function foo(s: string) {}
+function foo(n: number) {}
+const a = '';
+const b = '';
+function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
+          column: 1,
           data: { name: 'foo' },
-          line: 7,
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  foo(s: string): void;
-  'foo'(n: number): void;
-  bar(): void;
-  baz(): void;
-  foo(sn: string | number): void;
-}
+function foo(s: string) {}
+function foo(n: number) {}
+class Bar {}
+function foo(sn: string | number) {}
       `,
       errors: [
         {
-          column: 3,
+          column: 1,
           data: { name: 'foo' },
-          line: 7,
+          line: 5,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  foo(s: string): void;
+function foo(s: string) {}
+function foo(n: number) {}
+function foo(sn: string | number) {}
+class Bar {
+  foo(s: string);
+  foo(n: number);
   name: string;
-  foo(n: number): void;
-  foo(sn: string | number): void;
-  bar(): void;
-  baz(): void;
+  foo(sn: string | number) {}
 }
       `,
       errors: [
         {
           column: 3,
           data: { name: 'foo' },
-          line: 5,
+          line: 9,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  foo(): void;
-  bar: {
-    baz(s: string): void;
-    baz(n: number): void;
-    foo(): void;
-    baz(sn: string | number): void;
-  };
-}
+declare function foo(s: string);
+declare function foo(n: number);
+declare function bar(): void;
+declare function baz(): void;
+declare function foo(sn: string | number);
       `,
       errors: [
         {
-          column: 5,
-          data: { name: 'baz' },
-          line: 8,
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  new (s: string);
-  new (n: number);
-  foo(): void;
-  bar(): void;
-  new (sn: string | number);
-}
+declare function foo(s: string);
+declare function foo(n: number);
+const a = '';
+const b = '';
+declare function foo(sn: string | number);
       `,
       errors: [
         {
-          column: 3,
-          data: { name: 'new' },
-          line: 7,
+          column: 1,
+          data: { name: 'foo' },
+          line: 6,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-interface Foo {
-  new (s: string);
-  foo(): void;
-  new (n: number);
-  bar(): void;
-  new (sn: string | number);
+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: [
         {
           column: 3,
-          data: { name: 'new' },
-          line: 5,
-          messageId: 'adjacentSignature',
-        },
-        {
-          column: 3,
-          data: { name: 'new' },
+          data: { name: 'foo' },
           line: 7,
           messageId: 'adjacentSignature',
         },
@@ -502,31 +482,33 @@ interface Foo {
     },
     {
       code: `
-class Foo {
-  constructor(s: string);
-  constructor(n: number);
-  bar(): void {}
-  baz(): void {}
-  constructor(sn: string | number) {}
+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: [
         {
           column: 3,
-          data: { name: 'constructor' },
-          line: 7,
+          data: { name: 'baz' },
+          line: 8,
           messageId: 'adjacentSignature',
         },
       ],
     },
-    {
-      code: `
-class Foo {
-  foo(s: string): void;
-  foo(n: number): void;
-  bar(): void {}
-  baz(): void {}
-  foo(sn: string | number): void {}
+    {
+      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;
 }
       `,
       errors: [
@@ -540,73 +522,73 @@ class Foo {
     },
     {
       code: `
-class Foo {
-  foo(s: string): void;
-  ['foo'](n: number): void;
-  bar(): void {}
-  baz(): void {}
-  foo(sn: string | number): void {}
+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;
 }
       `,
       errors: [
         {
           column: 3,
-          data: { name: 'foo' },
-          line: 7,
+          data: { name: 'baz' },
+          line: 8,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-class Foo {
-  // prettier-ignore
-  "foo"(s: string): void;
+type Foo = {
+  foo(s: string): void;
   foo(n: number): void;
-  bar(): void {}
-  baz(): void {}
-  foo(sn: string | number): void {}
-}
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
       `,
       errors: [
         {
           column: 3,
           data: { name: 'foo' },
-          line: 8,
+          line: 7,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-class Foo {
-  constructor(s: string);
-  name: string;
-  constructor(n: number);
-  constructor(sn: string | number) {}
-  bar(): void {}
-  baz(): void {}
-}
+type Foo = {
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
       `,
       errors: [
         {
           column: 3,
-          data: { name: 'constructor' },
-          line: 5,
+          data: { name: 'foo' },
+          line: 7,
           messageId: 'adjacentSignature',
         },
       ],
     },
     {
       code: `
-class Foo {
+type Foo = {
   foo(s: string): void;
   name: string;
   foo(n: number): void;
-  foo(sn: string | number): void {}
-  bar(): void {}
-  baz(): void {}
-}
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+};
       `,
       errors: [
         {
@@ -619,310 +601,328 @@ class Foo {
     },
     {
       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 {}
+interface Foo {
+  (s: string): void;
+  foo(n: number): void;
+  (n: number): void;
+  (sn: string | number): void;
+  bar(): void;
+  baz(): void;
+  call(): void;
 }
       `,
       errors: [
         {
           column: 3,
-          data: { name: 'static foo' },
+          data: { name: 'call' },
           line: 5,
           messageId: 'adjacentSignature',
         },
       ],
     },
-    // private members
     {
       code: `
-class Test {
-  #private(): void;
-  '#private'(): void;
-  #private(arg: number): void {}
-  '#private'(arg: number): void {}
+interface Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
 }
       `,
       errors: [
         {
           column: 3,
-          data: { name: '#private' },
-          line: 5,
-          messageId: 'adjacentSignature',
-        },
-        {
-          column: 3,
-          data: { name: '"#private"' },
-          line: 6,
+          data: { name: 'foo' },
+          line: 7,
           messageId: 'adjacentSignature',
         },
       ],
     },
-  ],
-  valid: [
-    {
-      code: `
-function error(a: string);
-function error(b: number);
-function error(ab: string | number) {}
-export { error };
-      `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-    },
     {
       code: `
-import { connect } from 'react-redux';
-export interface ErrorMessageModel {
-  message: string;
-}
-function mapStateToProps() {}
-function mapDispatchToProps() {}
-export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
-      `,
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-    },
-    `
-export const foo = 'a',
-  bar = 'b';
-export interface Foo {}
-export class Foo {}
-    `,
-    `
-export interface Foo {}
-export const foo = 'a',
-  bar = 'b';
-export class Foo {}
-    `,
-    `
-const foo = 'a',
-  bar = 'b';
-interface Foo {}
-class Foo {}
-    `,
-    `
-interface Foo {}
-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 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;
-}
-    `,
-    `
-type Foo = {
-  foo(s: string): void;
-  foo(n: number): void;
-  foo(sn: string | number): void;
-  bar(): void;
-  baz(): void;
-};
-    `,
-    `
-type Foo = {
+interface Foo {
   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;
-}
-    `,
-    `
-interface Foo {
-  (s: string): void;
-  (n: number): void;
-  (sn: string | number): void;
-  foo(n: number): void;
   bar(): void;
   baz(): void;
-  call(): void;
+  foo(sn: string | number): void;
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 interface Foo {
   foo(s: string): void;
-  foo(n: number): void;
-  foo(sn: string | number): void;
+  'foo'(n: number): void;
   bar(): void;
   baz(): void;
+  foo(sn: string | number): void;
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 interface Foo {
   foo(s: string): void;
-  ['foo'](n: number): void;
+  name: string;
+  foo(n: number): void;
   foo(sn: string | number): void;
   bar(): void;
   baz(): void;
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 interface Foo {
   foo(): void;
   bar: {
     baz(s: string): void;
     baz(n: number): void;
+    foo(): void;
     baz(sn: string | number): void;
   };
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 5,
+          data: { name: 'baz' },
+          line: 8,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 interface Foo {
   new (s: string);
   new (n: number);
+  foo(): void;
+  bar(): void;
   new (sn: string | number);
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'new' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  new (s: string);
   foo(): void;
+  new (n: number);
+  bar(): void;
+  new (sn: string | number);
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'new' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+        {
+          column: 3,
+          data: { name: 'new' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   constructor(s: string);
   constructor(n: number);
-  constructor(sn: string | number) {}
   bar(): void {}
   baz(): void {}
+  constructor(sn: string | number) {}
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'constructor' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   foo(s: string): void;
   foo(n: number): void;
-  foo(sn: string | number): void {}
   bar(): void {}
   baz(): void {}
+  foo(sn: string | number): void {}
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   foo(s: string): void;
   ['foo'](n: number): void;
+  bar(): void {}
+  baz(): void {}
   foo(sn: string | number): void {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 7,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  // prettier-ignore
+  "foo"(s: string): void;
+  foo(n: number): void;
   bar(): void {}
   baz(): void {}
+  foo(sn: string | number): void {}
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 8,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
+  constructor(s: string);
   name: string;
+  constructor(n: number);
+  constructor(sn: string | number) {}
+  bar(): void {}
+  baz(): void {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'constructor' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
   foo(s: string): void;
+  name: string;
   foo(n: number): void;
   foo(sn: string | number): void {}
   bar(): void {}
   baz(): void {}
 }
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  name: string;
   static foo(s: string): void;
+  name: string;
   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) {}',
-    `
-interface Foo {
-  [Symbol.toStringTag](): void;
-  [Symbol.iterator](): void;
-}
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: 'static foo' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
     // private members
-    `
+    {
+      code: `
 class Test {
   #private(): void;
-  #private(arg: number): void {}
-
-  bar() {}
-
   '#private'(): void;
+  #private(arg: number): void {}
   '#private'(arg: number): void {}
 }
-    `,
-    // block statement
-    `
-function wrap() {
-  function foo(s: string);
-  function foo(n: number);
-  function foo(sn: string | number) {}
-}
-    `,
-    `
-if (true) {
-  function foo(s: string);
-  function foo(n: number);
-  function foo(sn: string | number) {}
-}
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { name: '#private' },
+          line: 5,
+          messageId: 'adjacentSignature',
+        },
+        {
+          column: 3,
+          data: { name: '"#private"' },
+          line: 6,
+          messageId: 'adjacentSignature',
+        },
+      ],
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/array-type.test.ts b/packages/eslint-plugin/tests/rules/array-type.test.ts
index 0bed905c68a8..ed58c32d1fe2 100644
--- a/packages/eslint-plugin/tests/rules/array-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/array-type.test.ts
@@ -10,989 +10,299 @@ import { areOptionsValid } from '../areOptionsValid';
 const ruleTester = new RuleTester();
 
 ruleTester.run('array-type', rule, {
-  invalid: [
+  valid: [
     // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
       options: [{ default: 'array' }],
-      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly (string | number)[] = [];',
       options: [{ default: 'array' }],
-      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array', readonly: 'array' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
       options: [{ default: 'array', readonly: 'array' }],
-      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array', readonly: 'array' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly (string | number)[] = [];',
       options: [{ default: 'array', readonly: 'array' }],
-      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array', readonly: 'array-simple' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
       options: [{ default: 'array', readonly: 'array-simple' }],
-      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array', readonly: 'array-simple' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array', readonly: 'array-simple' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array', readonly: 'generic' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: (string | number)[] = [];',
       options: [{ default: 'array', readonly: 'generic' }],
-      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<number> = [];',
       options: [{ default: 'array', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array-simple' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'array-simple' }],
-      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array-simple' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array-simple' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array-simple', readonly: 'array' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'array-simple', readonly: 'array' }],
-      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array-simple', readonly: 'array' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a: readonly (string | number)[] = [];',
       options: [{ default: 'array-simple', readonly: 'array' }],
-      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
-      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
-      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array-simple', readonly: 'array-simple' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: number[] = [];',
       options: [{ default: 'array-simple', readonly: 'generic' }],
-      output: 'let a: number[] = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'array-simple', readonly: 'generic' }],
-      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<number> = [];',
       options: [{ default: 'array-simple', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'array-simple', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: Array<number> = [];',
       options: [{ default: 'generic' }],
-      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'generic' }],
-      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<number> = [];',
       options: [{ default: 'generic' }],
-      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'let a: ReadonlyArray<string | number> = [];',
       options: [{ default: 'generic' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array' }],
-      output: 'let a: Array<number> = [];',
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array' }],
-      output: 'let a: Array<string | number> = [];',
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
     },
     {
       code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array' }],
-      output: 'let a: readonly number[] = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
     },
     {
       code: 'let a: ReadonlyArray<string | number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array' }],
-      output: 'let a: readonly (string | number)[] = [];',
+      options: [{ default: 'generic', readonly: 'generic' }],
     },
     {
-      code: 'let a: number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: Array<number> = [];',
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: Array<string | number> = [];',
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: readonly number[] = [];',
+      code: 'let a: readonly number[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
       code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: Array<number> = [];',
+      code: 'let a: Array<number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
-      code: 'let a: (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: Array<string | number> = [];',
+      code: 'let a: Array<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
       code: 'let a: readonly number[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'number',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<string | number> = [];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
-      code: 'let a: bigint[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'bigint' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: Array<bigint> = [];',
+      code: 'let a: Array<bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: (string | bigint)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: Array<string | bigint> = [];',
+      code: 'let a: readonly bigint[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: ReadonlyArray<bigint> = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'bigint',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let a: readonly (string | bigint)[] = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Array<bigint> = [];',
       options: [{ default: 'generic', readonly: 'array-simple' }],
-      output: 'let a: readonly bigint[] = [];',
     },
     {
-      code: 'let a: (string | bigint)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: Array<string | bigint> = [];',
+      code: 'let a: Array<string | bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
       code: 'let a: readonly bigint[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'bigint',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
     {
-      code: 'let a: readonly (string | bigint)[] = [];',
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic', readonly: 'generic' }],
-      output: 'let a: ReadonlyArray<string | bigint> = [];',
+      code: 'let a: ReadonlyArray<string | bigint> = [];',
+      options: [{ default: 'generic', readonly: 'array-simple' }],
     },
 
     // End of base cases
 
     {
-      code: 'let a: { foo: Array<Bar> }[] = [];',
-      errors: [
-        {
-          column: 15,
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: 'let a = new Array();',
       options: [{ default: 'array' }],
-      output: 'let a: { foo: Bar[] }[] = [];',
     },
     {
-      code: 'let a: Array<{ foo: Bar[] }> = [];',
-      errors: [
-        {
-          column: 21,
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
-      options: [{ default: 'generic' }],
-      output: 'let a: Array<{ foo: Array<Bar> }> = [];',
+      code: 'let a: { foo: Bar[] }[] = [];',
+      options: [{ default: 'array' }],
     },
     {
-      code: 'let a: Array<{ foo: Foo | Bar[] }> = [];',
-      errors: [
-        {
-          column: 27,
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          messageId: 'errorStringGeneric',
-        },
-      ],
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
       options: [{ default: 'generic' }],
-      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = [];',
     },
     {
-      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
-      errors: [
-        {
-          column: 17,
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-        {
-          column: 30,
-          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
-      options: [{ default: 'array' }],
-      output: 'function foo(a: Bar[]): Bar[] {}',
+      code: 'let yy: number[][] = [[4, 5], [6]];',
+      options: [{ default: 'array-simple' }],
     },
     {
-      code: 'let x: Array<undefined> = [undefined] as undefined[];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
       options: [{ default: 'array-simple' }],
-      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
-      errors: [
-        {
-          column: 20,
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
       options: [{ default: 'array-simple' }],
-      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: "let z: Array = [3, '4'];",
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'let fooVar: Array<(c: number) => number>;',
       options: [{ default: 'array-simple' }],
-      output: "let z: any[] = [3, '4'];",
     },
     {
-      code: "let ya = [[1, '2']] as [number, string][];",
-      errors: [
-        {
-          column: 24,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
+      code: 'type fooUnion = Array<string | number | boolean>;',
       options: [{ default: 'array-simple' }],
-      output: "let ya = [[1, '2']] as Array<[number, string]>;",
     },
     {
-      code: 'type Arr<T> = Array<T>;',
-      errors: [
-        {
-          column: 15,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
+      code: 'type fooIntersection = Array<string & number>;',
       options: [{ default: 'array-simple' }],
-      output: 'type Arr<T> = T[];',
     },
     {
       code: `
-// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+namespace fooName {
+  type BarType = { bar: string };
+  type BazType<T> = Arr<T>;
+}
       `,
-      errors: [
-        {
-          column: 15,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
       options: [{ default: 'array-simple' }],
-      output: `
-// Ignore user defined aliases
-let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
-      `,
     },
     {
       code: `
-interface ArrayClass<T> {
-  foo: Array<T>;
-  bar: T[];
-  baz: Arr<T>;
-  xyz: this[];
+interface FooInterface {
+  '.bar': { baz: string[] };
 }
       `,
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
       options: [{ default: 'array-simple' }],
-      output: `
-interface ArrayClass<T> {
-  foo: T[];
-  bar: T[];
-  baz: Arr<T>;
-  xyz: this[];
-}
-      `,
+    },
+    {
+      code: 'let yy: number[][] = [[4, 5], [6]];',
+      options: [{ default: 'array' }],
+    },
+    {
+      code: "let ya = [[1, '2']] as [number, string][];",
+      options: [{ default: 'array' }],
     },
     {
       code: `
@@ -1000,860 +310,1464 @@ function barFunction(bar: ArrayClass<String>[]) {
   return bar.map(e => e.bar);
 }
       `,
-      errors: [
-        {
-          column: 27,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: `
-function barFunction(bar: Array<ArrayClass<String>>) {
-  return bar.map(e => e.bar);
+      options: [{ default: 'array' }],
+    },
+    {
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
 }
       `,
+      options: [{ default: 'array' }],
     },
     {
       code: 'let barVar: ((c: number) => number)[];',
-      errors: [
-        {
-          column: 13,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: 'let barVar: Array<(c: number) => number>;',
+      options: [{ default: 'array' }],
     },
     {
       code: 'type barUnion = (string | number | boolean)[];',
-      errors: [
-        {
-          column: 17,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: 'type barUnion = Array<string | number | boolean>;',
+      options: [{ default: 'array' }],
     },
     {
       code: 'type barIntersection = (string & number)[];',
-      errors: [
-        {
-          column: 24,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: 'type barIntersection = Array<string & number>;',
-    },
-    {
-      code: "let v: Array<fooName.BarType> = [{ bar: 'bar' }];",
-      errors: [
-        {
-          column: 8,
-          data: {
-            className: 'Array',
-            readonlyPrefix: '',
-            type: 'fooName.BarType',
-          },
-          line: 1,
-          messageId: 'errorStringArraySimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: "let v: fooName.BarType[] = [{ bar: 'bar' }];",
-    },
-    {
-      code: "let w: fooName.BazType<string>[] = [['baz']];",
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 1,
-          messageId: 'errorStringGenericSimple',
-        },
-      ],
-      options: [{ default: 'array-simple' }],
-      output: "let w: Array<fooName.BazType<string>> = [['baz']];",
+      options: [{ default: 'array' }],
     },
     {
-      code: 'let x: Array<undefined> = [undefined] as undefined[];',
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      code: `
+interface FooInterface {
+  '.bar': { baz: string[] };
+}
+      `,
       options: [{ default: 'array' }],
-      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
-      errors: [
-        {
-          column: 20,
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
       options: [{ default: 'array' }],
-      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: "let z: Array = [3, '4'];",
-      errors: [
-        {
-          column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
-          line: 1,
-          messageId: 'errorStringArray',
-        },
-      ],
-      options: [{ default: 'array' }],
-      output: "let z: any[] = [3, '4'];",
+      code: 'let xx: Array<Array<number>> = [[1, 2], [3]];',
+      options: [{ default: 'generic' }],
     },
     {
       code: 'type Arr<T> = Array<T>;',
-      errors: [
-        {
-          column: 15,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+      options: [{ default: 'generic' }],
+    },
+    {
+      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);
+}
+      `,
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'let fooVar: Array<(c: number) => number>;',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'type fooUnion = Array<string | number | boolean>;',
+      options: [{ default: 'generic' }],
+    },
+    {
+      code: 'type fooIntersection = Array<string & number>;',
+      options: [{ default: 'generic' }],
+    },
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      options: [{ default: 'generic' }],
+    },
+
+    // nested readonly
+    {
+      code: 'let a: ReadonlyArray<number[]> = [[]];',
+      options: [{ default: 'array', readonly: 'generic' }],
+    },
+    {
+      code: 'let a: readonly Array<number>[] = [[]];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: 'let a: Readonly = [];',
+      options: [{ default: 'generic', readonly: 'array' }],
+    },
+    {
+      code: "const x: Readonly<string> = 'a';",
+      options: [{ default: 'array' }],
+    },
+  ],
+  invalid: [
+    // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
+    {
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
       options: [{ default: 'array' }],
-      output: 'type Arr<T> = T[];',
+      output: 'let a: number[] = [];',
     },
     {
-      code: `
-// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
-      `,
+      code: 'let a: Array<string | number> = [];',
       errors: [
         {
-          column: 15,
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
+          line: 1,
           messageId: 'errorStringArray',
         },
       ],
       options: [{ default: 'array' }],
-      output: `
-// Ignore user defined aliases
-let yyyy: Arr<Arr<string>[][]> = [[[['2']]]];
-      `,
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: `
-interface ArrayClass<T> {
-  foo: Array<T>;
-  bar: T[];
-  baz: Arr<T>;
-}
-      `,
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
           messageId: 'errorStringArray',
         },
       ],
       options: [{ default: 'array' }],
-      output: `
-interface ArrayClass<T> {
-  foo: T[];
-  bar: T[];
-  baz: Arr<T>;
-}
-      `,
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: `
-function fooFunction(foo: Array<ArrayClass<string>>) {
-  return foo.map(e => e.foo);
-}
-      `,
+      code: 'let a: ReadonlyArray<string | number> = [];',
       errors: [
         {
-          column: 27,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
           messageId: 'errorStringArray',
         },
       ],
       options: [{ default: 'array' }],
-      output: `
-function fooFunction(foo: ArrayClass<string>[]) {
-  return foo.map(e => e.foo);
-}
-      `,
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let fooVar: Array<(c: number) => number>;',
+      code: 'let a: Array<number> = [];',
       errors: [
         {
-          column: 13,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'let fooVar: ((c: number) => number)[];',
+      options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'type fooUnion = Array<string | number | boolean>;',
+      code: 'let a: Array<string | number> = [];',
       errors: [
         {
-          column: 17,
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'type fooUnion = (string | number | boolean)[];',
+      options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'type fooIntersection = Array<string & number>;',
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
-          column: 24,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'type fooIntersection = (string & number)[];',
+      options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let x: Array;',
+      code: 'let a: ReadonlyArray<string | number> = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'let x: any[];',
+      options: [{ default: 'array', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'let x: Array<>;',
+      code: 'let a: Array<number> = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'let x: any[];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let x: Array;',
+      code: 'let a: Array<string | number> = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          messageId: 'errorStringArraySimple',
+          messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array-simple' }],
-      output: 'let x: any[];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: 'let x: Array<>;',
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
           column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
           line: 1,
           messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'array-simple' }],
-      output: 'let x: any[];',
+      options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let x: Array<number> = [1] as number[];',
+      code: 'let a: readonly (string | number)[] = [];',
       errors: [
         {
-          column: 31,
-          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: 'let x: Array<number> = [1] as Array<number>;',
+      options: [{ default: 'array', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: "let y: string[] = <Array<string>>['2'];",
+      code: 'let a: Array<number> = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: "let y: Array<string> = <Array<string>>['2'];",
+      options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: "let ya = [[1, '2']] as [number, string][];",
+      code: 'let a: Array<string | number> = [];',
       errors: [
         {
-          column: 24,
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: "let ya = [[1, '2']] as Array<[number, string]>;",
+      options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: (string | number)[] = [];',
     },
     {
-      code: `
-// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
-      `,
+      code: 'let a: readonly number[] = [];',
       errors: [
         {
-          column: 15,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 3,
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
           messageId: 'errorStringGeneric',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: `
-// Ignore user defined aliases
-let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
-      `,
+      options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: `
-interface ArrayClass<T> {
-  foo: Array<T>;
-  bar: T[];
-  baz: Arr<T>;
-}
-      `,
+      code: 'let a: readonly (string | number)[] = [];',
       errors: [
         {
           column: 8,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 4,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
           messageId: 'errorStringGeneric',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: `
-interface ArrayClass<T> {
-  foo: Array<T>;
-  bar: Array<T>;
-  baz: Arr<T>;
-}
-      `,
+      options: [{ default: 'array', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: `
-function barFunction(bar: ArrayClass<String>[]) {
-  return bar.map(e => e.bar);
-}
-      `,
+      code: 'let a: Array<number> = [];',
       errors: [
         {
-          column: 27,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
-          line: 2,
-          messageId: 'errorStringGeneric',
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: `
-function barFunction(bar: Array<ArrayClass<String>>) {
-  return bar.map(e => e.bar);
-}
-      `,
+      options: [{ default: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'let barVar: ((c: number) => number)[];',
+      code: 'let a: (string | number)[] = [];',
       errors: [
         {
-          column: 13,
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: 'let barVar: Array<(c: number) => number>;',
+      options: [{ default: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'type barUnion = (string | number | boolean)[];',
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
-          column: 17,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: 'type barUnion = Array<string | number | boolean>;',
+      options: [{ default: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'type barIntersection = (string & number)[];',
+      code: 'let a: readonly (string | number)[] = [];',
       errors: [
         {
-          column: 24,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: 'type barIntersection = Array<string & number>;',
+      options: [{ default: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: `
-interface FooInterface {
-  '.bar': { baz: string[] };
-}
-      `,
+      code: 'let a: Array<number> = [];',
       errors: [
         {
-          column: 18,
-          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
-          line: 3,
-          messageId: 'errorStringGeneric',
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: `
-interface FooInterface {
-  '.bar': { baz: Array<string> };
-}
-      `,
+      options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: number[] = [];',
     },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      code: 'let a: (string | number)[] = [];',
       errors: [
         {
-          column: 28,
+          column: 8,
           data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          messageId: 'errorStringArray',
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
+      options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
-          column: 28,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
           line: 1,
-          messageId: 'errorStringGeneric',
+          messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'generic' }],
-      output: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'type Foo = ReadonlyArray<object>[];',
+      code: 'let a: ReadonlyArray<string | number> = [];',
       errors: [
         {
-          column: 12,
+          column: 8,
           data: {
             className: 'ReadonlyArray',
             readonlyPrefix: 'readonly ',
-            type: 'object',
+            type: 'T',
           },
           line: 1,
           messageId: 'errorStringArray',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'type Foo = (readonly object[])[];',
+      options: [{ default: 'array-simple', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
-      code: 'const foo: Array<new (...args: any[]) => void> = [];',
+      code: 'let a: Array<number> = [];',
       errors: [
         {
-          column: 12,
-          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
           line: 1,
-          messageId: 'errorStringArray',
+          messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'const foo: (new (...args: any[]) => void)[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: number[] = [];',
     },
     {
-      code: 'const foo: ReadonlyArray<new (...args: any[]) => void> = [];',
+      code: 'let a: (string | number)[] = [];',
       errors: [
         {
-          column: 12,
-          data: {
-            className: 'ReadonlyArray',
-            readonlyPrefix: 'readonly ',
-            type: 'T',
-          },
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
           line: 1,
-          messageId: 'errorStringArray',
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'array' }],
-      output: 'const foo: readonly (new (...args: any[]) => void)[] = [];',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: "const x: Readonly<string[]> = ['a', 'b'];",
+      code: 'let a: ReadonlyArray<number> = [];',
       errors: [
         {
+          column: 8,
           data: {
-            className: 'Readonly',
+            className: 'ReadonlyArray',
             readonlyPrefix: 'readonly ',
-            type: 'string[]',
+            type: 'number',
           },
-          messageId: 'errorStringArrayReadonly',
+          line: 1,
+          messageId: 'errorStringArraySimple',
         },
       ],
-      options: [{ default: 'array' }],
-      output: "const x: readonly string[] = ['a', 'b'];",
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'declare function foo<E extends Readonly<string[]>>(extra: E): E;',
+      code: 'let a: readonly (string | number)[] = [];',
       errors: [
         {
+          column: 8,
           data: {
-            className: 'Readonly',
+            className: 'ReadonlyArray',
             readonlyPrefix: 'readonly ',
-            type: 'string[]',
+            type: 'T',
           },
-          messageId: 'errorStringArraySimpleReadonly',
+          line: 1,
+          messageId: 'errorStringGenericSimple',
         },
       ],
-      options: [{ default: 'array-simple' }],
-      output: 'declare function foo<E extends readonly string[]>(extra: E): E;',
+      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
-  ],
-  valid: [
-    // Base cases from https://github.com/typescript-eslint/typescript-eslint/issues/2323#issuecomment-663977655
     {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array' }],
+      code: 'let a: Array<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: number[] = [];',
     },
     {
       code: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
       code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
       code: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
-    },
-    {
-      code: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
-    },
-    {
-      code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
-    },
-    {
-      code: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'array-simple', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
       code: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let a: Array<number> = [];',
     },
     {
       code: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
       code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array', readonly: 'array-simple' }],
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
       code: 'let a: number[] = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: Array<number> = [];',
     },
     {
       code: 'let a: (string | number)[] = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
       code: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
       code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array' }],
+      output: 'let a: readonly (string | number)[] = [];',
     },
     {
       code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple' }],
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple' }],
+      code: 'let a: ReadonlyArray<number> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: readonly number[] = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple' }],
+      code: 'let a: readonly (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
       code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<number> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      code: 'let a: (string | number)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<string | number> = [];',
     },
     {
       code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'number',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<number> = [];',
     },
     {
       code: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array' }],
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | number> = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'let a: bigint[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'bigint' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<bigint> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
-    },
-    {
-      code: 'let a: readonly number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'let a: (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: Array<string | bigint> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'array-simple' }],
+      code: 'let a: ReadonlyArray<bigint> = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'bigint',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'array-simple' }],
+      output: 'let a: readonly bigint[] = [];',
     },
     {
-      code: 'let a: number[] = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let a: (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: Array<string | bigint> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let a: readonly bigint[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'bigint',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<bigint> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let a: readonly (string | bigint)[] = [];',
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic', readonly: 'generic' }],
+      output: 'let a: ReadonlyArray<string | bigint> = [];',
     },
+
+    // End of base cases
+
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'array-simple', readonly: 'generic' }],
+      code: 'let a: { foo: Array<Bar> }[] = [];',
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let a: { foo: Bar[] }[] = [];',
     },
     {
-      code: 'let a: Array<number> = [];',
+      code: 'let a: Array<{ foo: Bar[] }> = [];',
+      errors: [
+        {
+          column: 21,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: Array<{ foo: Array<Bar> }> = [];',
     },
     {
-      code: 'let a: Array<string | number> = [];',
+      code: 'let a: Array<{ foo: Foo | Bar[] }> = [];',
+      errors: [
+        {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = [];',
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'generic' }],
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
+      errors: [
+        {
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+        {
+          column: 30,
+          data: { className: 'Array', readonlyPrefix: '', type: 'Bar' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'function foo(a: Bar[]): Bar[] {}',
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic' }],
+      code: 'let x: Array<undefined> = [undefined] as undefined[];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: "let y: string[] = <Array<string>>['2'];",
+      errors: [
+        {
+          column: 20,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: "let z: Array = [3, '4'];",
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: "let z: any[] = [3, '4'];",
     },
     {
-      code: 'let a: ReadonlyArray<number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: "let ya = [[1, '2']] as [number, string][];",
+      errors: [
+        {
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'generic' }],
+      code: 'type Arr<T> = Array<T>;',
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'type Arr<T> = T[];',
     },
     {
-      code: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
+      `,
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
     },
     {
-      code: 'let a: readonly number[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
+      errors: [
+        {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
+}
+      `,
     },
     {
-      code: 'let a: readonly (string | number)[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'let barVar: ((c: number) => number)[];',
+      errors: [
+        {
+          column: 13,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'let barVar: Array<(c: number) => number>;',
     },
     {
-      code: 'let a: Array<number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'type barUnion = (string | number | boolean)[];',
+      errors: [
+        {
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'type barUnion = Array<string | number | boolean>;',
     },
     {
-      code: 'let a: Array<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'type barIntersection = (string & number)[];',
+      errors: [
+        {
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'type barIntersection = Array<string & number>;',
     },
     {
-      code: 'let a: readonly number[] = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: "let v: Array<fooName.BarType> = [{ bar: 'bar' }];",
+      errors: [
+        {
+          column: 8,
+          data: {
+            className: 'Array',
+            readonlyPrefix: '',
+            type: 'fooName.BarType',
+          },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: "let v: fooName.BarType[] = [{ bar: 'bar' }];",
+    },
+    {
+      code: "let w: fooName.BazType<string>[] = [['baz']];",
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGenericSimple',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: "let w: Array<fooName.BazType<string>> = [['baz']];",
     },
     {
-      code: 'let a: ReadonlyArray<string | number> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'let x: Array<undefined> = [undefined] as undefined[];',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'undefined' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let x: undefined[] = [undefined] as undefined[];',
     },
     {
-      code: 'let a: Array<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: "let y: string[] = <Array<string>>['2'];",
+      errors: [
+        {
+          column: 20,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: "let y: string[] = <string[]>['2'];",
     },
     {
-      code: 'let a: readonly bigint[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: "let z: Array = [3, '4'];",
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: "let z: any[] = [3, '4'];",
     },
     {
-      code: 'let a: readonly (string | bigint)[] = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'type Arr<T> = Array<T>;',
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'type Arr<T> = T[];',
     },
     {
-      code: 'let a: Array<bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Arr<string>[][]> = [[[['2']]]];
+      `,
     },
     {
-      code: 'let a: Array<string | bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
     },
     {
-      code: 'let a: readonly bigint[] = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
+      errors: [
+        {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: `
+function fooFunction(foo: ArrayClass<string>[]) {
+  return foo.map(e => e.foo);
+}
+      `,
     },
     {
-      code: 'let a: ReadonlyArray<string | bigint> = [];',
-      options: [{ default: 'generic', readonly: 'array-simple' }],
+      code: 'let fooVar: Array<(c: number) => number>;',
+      errors: [
+        {
+          column: 13,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let fooVar: ((c: number) => number)[];',
     },
-
-    // End of base cases
-
     {
-      code: 'let a = new Array();',
+      code: 'type fooUnion = Array<string | number | boolean>;',
+      errors: [
+        {
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'type fooUnion = (string | number | boolean)[];',
     },
     {
-      code: 'let a: { foo: Bar[] }[] = [];',
+      code: 'type fooIntersection = Array<string & number>;',
+      errors: [
+        {
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: 'type fooIntersection = (string & number)[];',
     },
     {
-      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
-      options: [{ default: 'generic' }],
+      code: 'let x: Array;',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let yy: number[][] = [[4, 5], [6]];',
-      options: [{ default: 'array-simple' }],
+      code: 'let x: Array<>;',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'let x: any[];',
     },
     {
-      code: `
-function fooFunction(foo: Array<ArrayClass<string>>) {
-  return foo.map(e => e.foo);
-}
-      `,
+      code: 'let x: Array;',
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'any' },
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple' }],
+      output: 'let x: any[];',
     },
     {
-      code: `
-function bazFunction(baz: Arr<ArrayClass<String>>) {
-  return baz.map(e => e.baz);
-}
-      `,
+      code: 'let x: Array<>;',
+      errors: [
+        {
+          column: 8,
+          line: 1,
+          messageId: 'errorStringArraySimple',
+        },
+      ],
       options: [{ default: 'array-simple' }],
+      output: 'let x: any[];',
     },
     {
-      code: 'let fooVar: Array<(c: number) => number>;',
-      options: [{ default: 'array-simple' }],
+      code: 'let x: Array<number> = [1] as number[];',
+      errors: [
+        {
+          column: 31,
+          data: { className: 'Array', readonlyPrefix: '', type: 'number' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let x: Array<number> = [1] as Array<number>;',
     },
     {
-      code: 'type fooUnion = Array<string | number | boolean>;',
-      options: [{ default: 'array-simple' }],
+      code: "let y: string[] = <Array<string>>['2'];",
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: "let y: Array<string> = <Array<string>>['2'];",
     },
     {
-      code: 'type fooIntersection = Array<string & number>;',
-      options: [{ default: 'array-simple' }],
+      code: "let ya = [[1, '2']] as [number, string][];",
+      errors: [
+        {
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
     },
     {
       code: `
-namespace fooName {
-  type BarType = { bar: string };
-  type BazType<T> = Arr<T>;
-}
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      errors: [
+        {
+          column: 15,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 3,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
       `,
-      options: [{ default: 'array-simple' }],
     },
     {
       code: `
-interface FooInterface {
-  '.bar': { baz: string[] };
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
+      errors: [
+        {
+          column: 8,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 4,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: Array<T>;
+  baz: Arr<T>;
 }
       `,
-      options: [{ default: 'array-simple' }],
-    },
-    {
-      code: 'let yy: number[][] = [[4, 5], [6]];',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: "let ya = [[1, '2']] as [number, string][];",
-      options: [{ default: 'array' }],
     },
     {
       code: `
@@ -1861,27 +1775,59 @@ 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);
+      errors: [
+        {
+          column: 27,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 2,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
 }
       `,
-      options: [{ default: 'array' }],
     },
     {
       code: 'let barVar: ((c: number) => number)[];',
-      options: [{ default: 'array' }],
+      errors: [
+        {
+          column: 13,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'let barVar: Array<(c: number) => number>;',
     },
     {
       code: 'type barUnion = (string | number | boolean)[];',
-      options: [{ default: 'array' }],
+      errors: [
+        {
+          column: 17,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'type barUnion = Array<string | number | boolean>;',
     },
     {
       code: 'type barIntersection = (string & number)[];',
-      options: [{ default: 'array' }],
+      errors: [
+        {
+          column: 24,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
+      options: [{ default: 'generic' }],
+      output: 'type barIntersection = Array<string & number>;',
     },
     {
       code: `
@@ -1889,71 +1835,125 @@ 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;',
-      options: [{ default: 'array' }],
-    },
-    {
-      code: 'let xx: Array<Array<number>> = [[1, 2], [3]];',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'type Arr<T> = Array<T>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: `
-function fooFunction(foo: Array<ArrayClass<string>>) {
-  return foo.map(e => e.foo);
-}
-      `,
+      errors: [
+        {
+          column: 18,
+          data: { className: 'Array', readonlyPrefix: '', type: 'string' },
+          line: 3,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
-    },
-    {
-      code: `
-function bazFunction(baz: Arr<ArrayClass<String>>) {
-  return baz.map(e => e.baz);
+      output: `
+interface FooInterface {
+  '.bar': { baz: Array<string> };
 }
       `,
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'let fooVar: Array<(c: number) => number>;',
-      options: [{ default: 'generic' }],
-    },
-    {
-      code: 'type fooUnion = Array<string | number | boolean>;',
-      options: [{ default: 'generic' }],
     },
     {
-      code: 'type fooIntersection = Array<string & number>;',
-      options: [{ default: 'generic' }],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/172
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      errors: [
+        {
+          column: 28,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
     },
     {
       // 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 (infer E)[] ? E : T;',
+      errors: [
+        {
+          column: 28,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringGeneric',
+        },
+      ],
       options: [{ default: 'generic' }],
+      output: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
     },
-
-    // nested readonly
     {
-      code: 'let a: ReadonlyArray<number[]> = [[]];',
-      options: [{ default: 'array', readonly: 'generic' }],
+      code: 'type Foo = ReadonlyArray<object>[];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'object',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'type Foo = (readonly object[])[];',
     },
     {
-      code: 'let a: readonly Array<number>[] = [[]];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'const foo: Array<new (...args: any[]) => void> = [];',
+      errors: [
+        {
+          column: 12,
+          data: { className: 'Array', readonlyPrefix: '', type: 'T' },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'const foo: (new (...args: any[]) => void)[] = [];',
     },
     {
-      code: 'let a: Readonly = [];',
-      options: [{ default: 'generic', readonly: 'array' }],
+      code: 'const foo: ReadonlyArray<new (...args: any[]) => void> = [];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            className: 'ReadonlyArray',
+            readonlyPrefix: 'readonly ',
+            type: 'T',
+          },
+          line: 1,
+          messageId: 'errorStringArray',
+        },
+      ],
+      options: [{ default: 'array' }],
+      output: 'const foo: readonly (new (...args: any[]) => void)[] = [];',
     },
     {
-      code: "const x: Readonly<string> = 'a';",
+      code: "const x: Readonly<string[]> = ['a', 'b'];",
+      errors: [
+        {
+          data: {
+            className: 'Readonly',
+            readonlyPrefix: 'readonly ',
+            type: 'string[]',
+          },
+          messageId: 'errorStringArrayReadonly',
+        },
+      ],
       options: [{ default: 'array' }],
+      output: "const x: readonly string[] = ['a', 'b'];",
+    },
+    {
+      code: 'declare function foo<E extends Readonly<string[]>>(extra: E): E;',
+      errors: [
+        {
+          data: {
+            className: 'Readonly',
+            readonlyPrefix: 'readonly ',
+            type: 'string[]',
+          },
+          messageId: 'errorStringArraySimpleReadonly',
+        },
+      ],
+      options: [{ default: 'array-simple' }],
+      output: 'declare function foo<E extends readonly string[]>(extra: E): E;',
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/await-thenable.test.ts b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
index 3779ff6385fe..7a9a1bb17739 100644
--- a/packages/eslint-plugin/tests/rules/await-thenable.test.ts
+++ b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
@@ -16,186 +16,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('await-thenable', rule, {
-  invalid: [
-    {
-      code: 'await 0;',
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: ' 0;',
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: "await 'value';",
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: " 'value';",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: "async () => await (Math.random() > 0.5 ? '' : 0);",
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: "async () =>  (Math.random() > 0.5 ? '' : 0);",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: noFormat`async () => await(Math.random() > 0.5 ? '' : 0);`,
-      errors: [
-        {
-          line: 1,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: "async () => (Math.random() > 0.5 ? '' : 0);",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class NonPromise extends Array {}
-await new NonPromise();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-class NonPromise extends Array {}
- new NonPromise();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  class IncorrectThenable {
-    then() {}
-  }
-  const thenable = new IncorrectThenable();
-
-  await thenable;
-}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-async function test() {
-  class IncorrectThenable {
-    then() {}
-  }
-  const thenable = new IncorrectThenable();
-
-   thenable;
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const callback: (() => void) | undefined;
-await callback?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const callback: (() => void) | undefined;
- callback?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const obj: { a?: { b?: () => void } };
-await obj.a?.b?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const obj: { a?: { b?: () => void } };
- obj.a?.b?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-declare const obj: { a: { b: { c?: () => void } } } | undefined;
-await obj?.a.b.c?.();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId,
-          suggestions: [
-            {
-              messageId: 'removeAwait',
-              output: `
-declare const obj: { a: { b: { c?: () => void } } } | undefined;
- obj?.a.b.c?.();
-      `,
-            },
-          ],
-        },
-      ],
-    },
-  ],
-
   valid: [
     `
 async function test() {
@@ -379,4 +199,183 @@ const doSomething = async (
 };
     `,
   ],
+  invalid: [
+    {
+      code: 'await 0;',
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: ' 0;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "await 'value';",
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: " 'value';",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "async () => await (Math.random() > 0.5 ? '' : 0);",
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: "async () =>  (Math.random() > 0.5 ? '' : 0);",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: noFormat`async () => await(Math.random() > 0.5 ? '' : 0);`,
+      errors: [
+        {
+          line: 1,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: "async () => (Math.random() > 0.5 ? '' : 0);",
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+class NonPromise extends Array {}
+await new NonPromise();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+class NonPromise extends Array {}
+ new NonPromise();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  class IncorrectThenable {
+    then() {}
+  }
+  const thenable = new IncorrectThenable();
+
+  await thenable;
+}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+async function test() {
+  class IncorrectThenable {
+    then() {}
+  }
+  const thenable = new IncorrectThenable();
+
+   thenable;
+}
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const callback: (() => void) | undefined;
+await callback?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const callback: (() => void) | undefined;
+ callback?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const obj: { a?: { b?: () => void } };
+await obj.a?.b?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const obj: { a?: { b?: () => void } };
+ obj.a?.b?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+declare const obj: { a: { b: { c?: () => void } } } | undefined;
+await obj?.a.b.c?.();
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId,
+          suggestions: [
+            {
+              messageId: 'removeAwait',
+              output: `
+declare const obj: { a: { b: { c?: () => void } } } | undefined;
+ obj?.a.b.c?.();
+      `,
+            },
+          ],
+        },
+      ],
+    },
+  ],
 });
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 5cc5e3d5dfa3..4fe0e9d97d0d 100644
--- a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
@@ -5,6 +5,109 @@ import rule from '../../src/rules/ban-ts-comment';
 const ruleTester = new RuleTester();
 
 ruleTester.run('ts-expect-error', rule, {
+  valid: [
+    '// just a comment containing @ts-expect-error somewhere',
+    `
+/*
+ @ts-expect-error running with long description in a block
+*/
+    `,
+    `
+/* @ts-expect-error not on the last line
+ */
+    `,
+    `
+/**
+ * @ts-expect-error not on the last line
+ */
+    `,
+    `
+/* not on the last line
+ * @ts-expect-error
+ */
+    `,
+    `
+/* @ts-expect-error
+ * not on the last line */
+    `,
+    {
+      code: '// @ts-expect-error',
+      options: [{ 'ts-expect-error': false }],
+    },
+    {
+      code: '// @ts-expect-error here is why the error is expected',
+      options: [
+        {
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-expect-error here is why the error is expected */
+      `,
+      options: [
+        {
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: '// @ts-expect-error exactly 21 characters',
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-expect-error exactly 21 characters*/
+      `,
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+    {
+      code: '// @ts-expect-error: TS1234 because xyz',
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+/*
+ * @ts-expect-error: TS1234 because xyz */
+      `,
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-expect-error': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
+    },
+    {
+      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
+      options: [
+        {
+          'ts-expect-error': 'allow-with-description',
+        },
+      ],
+    },
+  ],
   invalid: [
     {
       code: '// @ts-expect-error',
@@ -336,20 +439,44 @@ if (false) {
       ],
     },
   ],
+});
+
+ruleTester.run('ts-ignore', rule, {
   valid: [
-    '// just a comment containing @ts-expect-error somewhere',
+    '// just a comment containing @ts-ignore somewhere',
+    {
+      code: '// @ts-ignore',
+      options: [{ 'ts-ignore': false }],
+    },
+    {
+      code: '// @ts-ignore I think that I am exempted from any need to follow the rules!',
+      options: [{ 'ts-ignore': 'allow-with-description' }],
+    },
+    {
+      code: `
+/*
+ @ts-ignore running with long description in a block
+*/
+      `,
+      options: [
+        {
+          minimumDescriptionLength: 21,
+          'ts-ignore': 'allow-with-description',
+        },
+      ],
+    },
     `
 /*
- @ts-expect-error running with long description in a block
+ @ts-ignore
 */
     `,
     `
-/* @ts-expect-error not on the last line
+/* @ts-ignore not on the last line
  */
     `,
     `
 /**
- * @ts-expect-error not on the last line
+ * @ts-ignore not on the last line
  */
     `,
     `
@@ -358,90 +485,75 @@ if (false) {
  */
     `,
     `
-/* @ts-expect-error
+/* @ts-ignore
  * not on the last line */
     `,
     {
-      code: '// @ts-expect-error',
-      options: [{ 'ts-expect-error': false }],
+      code: '// @ts-ignore: TS1234 because xyz',
+      options: [
+        {
+          minimumDescriptionLength: 10,
+          'ts-ignore': {
+            descriptionFormat: '^: TS\\d+ because .+$',
+          },
+        },
+      ],
     },
     {
-      code: '// @ts-expect-error here is why the error is expected',
+      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
       options: [
         {
-          'ts-expect-error': 'allow-with-description',
+          'ts-ignore': 'allow-with-description',
         },
       ],
     },
     {
       code: `
 /*
- * @ts-expect-error here is why the error is expected */
+ * @ts-ignore here is why the error is expected */
       `,
       options: [
         {
-          'ts-expect-error': 'allow-with-description',
+          'ts-ignore': 'allow-with-description',
         },
       ],
     },
     {
-      code: '// @ts-expect-error exactly 21 characters',
+      code: '// @ts-ignore exactly 21 characters',
       options: [
         {
           minimumDescriptionLength: 21,
-          'ts-expect-error': 'allow-with-description',
+          'ts-ignore': 'allow-with-description',
         },
       ],
     },
     {
       code: `
 /*
- * @ts-expect-error exactly 21 characters*/
+ * @ts-ignore exactly 21 characters*/
       `,
       options: [
         {
           minimumDescriptionLength: 21,
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: '// @ts-expect-error: TS1234 because xyz',
-      options: [
-        {
-          minimumDescriptionLength: 10,
-          'ts-expect-error': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
+          'ts-ignore': 'allow-with-description',
         },
       ],
     },
     {
       code: `
 /*
- * @ts-expect-error: TS1234 because xyz */
+ * @ts-ignore: TS1234 because xyz */
       `,
       options: [
         {
           minimumDescriptionLength: 10,
-          'ts-expect-error': {
+          'ts-ignore': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
     },
-    {
-      code: noFormat`// @ts-expect-error 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
-      options: [
-        {
-          'ts-expect-error': 'allow-with-description',
-        },
-      ],
-    },
   ],
-});
-
-ruleTester.run('ts-ignore', rule, {
   invalid: [
     {
       code: '// @ts-ignore',
@@ -822,121 +934,65 @@ if (false) {
       ],
     },
   ],
+});
+
+ruleTester.run('ts-nocheck', rule, {
   valid: [
-    '// just a comment containing @ts-ignore somewhere',
+    '// just a comment containing @ts-nocheck somewhere',
     {
-      code: '// @ts-ignore',
-      options: [{ 'ts-ignore': false }],
+      code: '// @ts-nocheck',
+      options: [{ 'ts-nocheck': false }],
     },
     {
-      code: '// @ts-ignore I think that I am exempted from any need to follow the rules!',
-      options: [{ 'ts-ignore': 'allow-with-description' }],
+      code: '// @ts-nocheck no doubt, people will put nonsense here from time to time just to get the rule to stop reporting, perhaps even long messages with other nonsense in them like other // @ts-nocheck or // @ts-ignore things',
+      options: [{ 'ts-nocheck': 'allow-with-description' }],
     },
     {
       code: `
 /*
- @ts-ignore running with long description in a block
+ @ts-nocheck running with long description in a block
 */
       `,
       options: [
         {
           minimumDescriptionLength: 21,
-          'ts-ignore': 'allow-with-description',
+          'ts-nocheck': 'allow-with-description',
         },
       ],
     },
-    `
-/*
- @ts-ignore
-*/
-    `,
-    `
-/* @ts-ignore not on the last line
- */
-    `,
-    `
-/**
- * @ts-ignore not on the last line
- */
-    `,
-    `
-/* not on the last line
- * @ts-expect-error
- */
-    `,
-    `
-/* @ts-ignore
- * not on the last line */
-    `,
     {
-      code: '// @ts-ignore: TS1234 because xyz',
+      code: '// @ts-nocheck: TS1234 because xyz',
       options: [
         {
           minimumDescriptionLength: 10,
-          'ts-ignore': {
+          'ts-nocheck': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
     },
     {
-      code: noFormat`// @ts-ignore 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
-      options: [
-        {
-          'ts-ignore': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: `
-/*
- * @ts-ignore here is why the error is expected */
-      `,
-      options: [
-        {
-          'ts-ignore': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: '// @ts-ignore exactly 21 characters',
-      options: [
-        {
-          minimumDescriptionLength: 21,
-          'ts-ignore': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: `
-/*
- * @ts-ignore exactly 21 characters*/
-      `,
+      code: noFormat`// @ts-nocheck 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
       options: [
         {
-          minimumDescriptionLength: 21,
-          'ts-ignore': 'allow-with-description',
+          'ts-nocheck': 'allow-with-description',
         },
       ],
     },
-    {
-      code: `
+    '//// @ts-nocheck - pragma comments may contain 2 or 3 leading slashes',
+    `
+/**
+ @ts-nocheck
+*/
+    `,
+    `
 /*
- * @ts-ignore: TS1234 because xyz */
-      `,
-      options: [
-        {
-          minimumDescriptionLength: 10,
-          'ts-ignore': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-        },
-      ],
-    },
+ @ts-nocheck
+*/
+    `,
+    '/** @ts-nocheck */',
+    '/* @ts-nocheck */',
   ],
-});
-
-ruleTester.run('ts-nocheck', rule, {
   invalid: [
     {
       code: '// @ts-nocheck',
@@ -1072,65 +1128,74 @@ if (false) {
       ],
     },
   ],
+});
+
+ruleTester.run('ts-check', rule, {
   valid: [
-    '// just a comment containing @ts-nocheck somewhere',
-    {
-      code: '// @ts-nocheck',
-      options: [{ 'ts-nocheck': false }],
-    },
+    '// just a comment containing @ts-check somewhere',
+    `
+/*
+ @ts-check running with long description in a block
+*/
+    `,
     {
-      code: '// @ts-nocheck no doubt, people will put nonsense here from time to time just to get the rule to stop reporting, perhaps even long messages with other nonsense in them like other // @ts-nocheck or // @ts-ignore things',
-      options: [{ 'ts-nocheck': 'allow-with-description' }],
+      code: '// @ts-check',
+      options: [{ 'ts-check': false }],
     },
     {
-      code: `
-/*
- @ts-nocheck running with long description in a block
-*/
-      `,
+      code: '// @ts-check with a description and also with a no-op // @ts-ignore',
       options: [
-        {
-          minimumDescriptionLength: 21,
-          'ts-nocheck': 'allow-with-description',
-        },
+        { minimumDescriptionLength: 3, 'ts-check': 'allow-with-description' },
       ],
     },
     {
-      code: '// @ts-nocheck: TS1234 because xyz',
+      code: '// @ts-check: TS1234 because xyz',
       options: [
         {
           minimumDescriptionLength: 10,
-          'ts-nocheck': {
+          'ts-check': {
             descriptionFormat: '^: TS\\d+ because .+$',
           },
         },
       ],
     },
     {
-      code: noFormat`// @ts-nocheck 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
+      code: noFormat`// @ts-check 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
       options: [
         {
-          'ts-nocheck': 'allow-with-description',
+          'ts-check': 'allow-with-description',
         },
       ],
     },
-    '//// @ts-nocheck - pragma comments may contain 2 or 3 leading slashes',
-    `
+    {
+      code: '//// @ts-check - pragma comments may contain 2 or 3 leading slashes',
+      options: [{ 'ts-check': true }],
+    },
+    {
+      code: `
 /**
- @ts-nocheck
+ @ts-check
 */
-    `,
-    `
+      `,
+      options: [{ 'ts-check': true }],
+    },
+    {
+      code: `
 /*
- @ts-nocheck
+ @ts-check
 */
-    `,
-    '/** @ts-nocheck */',
-    '/* @ts-nocheck */',
+      `,
+      options: [{ 'ts-check': true }],
+    },
+    {
+      code: '/** @ts-check */',
+      options: [{ 'ts-check': true }],
+    },
+    {
+      code: '/* @ts-check */',
+      options: [{ 'ts-check': true }],
+    },
   ],
-});
-
-ruleTester.run('ts-check', rule, {
   invalid: [
     {
       code: '// @ts-check',
@@ -1257,69 +1322,4 @@ if (false) {
       ],
     },
   ],
-  valid: [
-    '// just a comment containing @ts-check somewhere',
-    `
-/*
- @ts-check running with long description in a block
-*/
-    `,
-    {
-      code: '// @ts-check',
-      options: [{ 'ts-check': false }],
-    },
-    {
-      code: '// @ts-check with a description and also with a no-op // @ts-ignore',
-      options: [
-        { minimumDescriptionLength: 3, 'ts-check': 'allow-with-description' },
-      ],
-    },
-    {
-      code: '// @ts-check: TS1234 because xyz',
-      options: [
-        {
-          minimumDescriptionLength: 10,
-          'ts-check': {
-            descriptionFormat: '^: TS\\d+ because .+$',
-          },
-        },
-      ],
-    },
-    {
-      code: noFormat`// @ts-check 👨‍👩‍👧‍👦👨‍👩‍👧‍👦👨‍👩‍👧‍👦`,
-      options: [
-        {
-          'ts-check': 'allow-with-description',
-        },
-      ],
-    },
-    {
-      code: '//// @ts-check - pragma comments may contain 2 or 3 leading slashes',
-      options: [{ 'ts-check': true }],
-    },
-    {
-      code: `
-/**
- @ts-check
-*/
-      `,
-      options: [{ 'ts-check': true }],
-    },
-    {
-      code: `
-/*
- @ts-check
-*/
-      `,
-      options: [{ 'ts-check': true }],
-    },
-    {
-      code: '/** @ts-check */',
-      options: [{ 'ts-check': true }],
-    },
-    {
-      code: '/* @ts-check */',
-      options: [{ 'ts-check': true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts b/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
index fdc00a705308..70ebf3d6f107 100644
--- a/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
@@ -49,20 +49,6 @@ console.log(woah);
 const ruleTester = new RuleTester();
 
 ruleTester.run('ban-tslint-comment', rule, {
-  invalid: [...PALANTIR_EXAMPLES, ...MORE_EXAMPLES].map(
-    ({ code, column, line, output, text }) => ({
-      code,
-      errors: [
-        {
-          column: column ?? 1,
-          data: { text: text ?? code },
-          line: line ?? 1,
-          messageId: 'commentDetected' as const,
-        },
-      ],
-      output: output ?? '',
-    }),
-  ),
   valid: [
     {
       code: 'let a: readonly any[] = [];',
@@ -80,4 +66,18 @@ ruleTester.run('ban-tslint-comment', rule, {
       code: '/* another comment that mentions tslint */',
     },
   ],
+  invalid: [...PALANTIR_EXAMPLES, ...MORE_EXAMPLES].map(
+    ({ code, column, line, output, text }) => ({
+      code,
+      errors: [
+        {
+          column: column ?? 1,
+          data: { text: text ?? code },
+          line: line ?? 1,
+          messageId: 'commentDetected' as const,
+        },
+      ],
+      output: output ?? '',
+    }),
+  ),
 });
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 5564a2ce7719..df8a7ad66d45 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
@@ -5,6 +5,259 @@ import rule from '../../src/rules/class-literal-property-style';
 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 {
+        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')};
+        \`;
+      }
+    `,
+    `
+      class Mx {
+        set p1(val) {}
+        get p1() {
+          return '';
+        }
+      }
+    `,
+    `
+      let p1 = 'p1';
+      class Mx {
+        set [p1](val) {}
+        get [p1]() {
+          return '';
+        }
+      }
+    `,
+    `
+      let p1 = 'p1';
+      class Mx {
+        set [/* before set */ p1 /* after set */](val) {}
+        get [/* before get */ p1 /* after get */]() {
+          return '';
+        }
+      }
+    `,
+    `
+      class Mx {
+        set ['foo'](val) {}
+        get foo() {
+          return '';
+        }
+        set bar(val) {}
+        get ['bar']() {
+          return '';
+        }
+        set ['baz'](val) {}
+        get baz() {
+          return '';
+        }
+      }
+    `,
+    {
+      code: `
+        class Mx {
+          public get myButton() {
+            return styled.button\`
+              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+            \`;
+          }
+        }
+      `,
+      options: ['fields'],
+    },
+    {
+      code: `
+class Mx {
+  public declare 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'],
+    },
+    {
+      code: `
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            this.foo = foo;
+          }
+        }
+      `,
+      options: ['getters'],
+    },
+    {
+      code: `
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            this['foo'] = foo;
+          }
+        }
+      `,
+      options: ['getters'],
+    },
+    {
+      code: `
+        class A {
+          private readonly foo: string = 'bar';
+          constructor(foo: string) {
+            const bar = new (class {
+              private readonly foo: string = 'baz';
+              constructor() {
+                this.foo = 'qux';
+              }
+            })();
+            this['foo'] = foo;
+          }
+        }
+      `,
+      options: ['getters'],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -566,257 +819,4 @@ class A {
       options: ['getters'],
     },
   ],
-  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')};
-        \`;
-      }
-    `,
-    `
-      class Mx {
-        set p1(val) {}
-        get p1() {
-          return '';
-        }
-      }
-    `,
-    `
-      let p1 = 'p1';
-      class Mx {
-        set [p1](val) {}
-        get [p1]() {
-          return '';
-        }
-      }
-    `,
-    `
-      let p1 = 'p1';
-      class Mx {
-        set [/* before set */ p1 /* after set */](val) {}
-        get [/* before get */ p1 /* after get */]() {
-          return '';
-        }
-      }
-    `,
-    `
-      class Mx {
-        set ['foo'](val) {}
-        get foo() {
-          return '';
-        }
-        set bar(val) {}
-        get ['bar']() {
-          return '';
-        }
-        set ['baz'](val) {}
-        get baz() {
-          return '';
-        }
-      }
-    `,
-    {
-      code: `
-        class Mx {
-          public get myButton() {
-            return styled.button\`
-              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
-            \`;
-          }
-        }
-      `,
-      options: ['fields'],
-    },
-    {
-      code: `
-class Mx {
-  public declare 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'],
-    },
-    {
-      code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            this.foo = foo;
-          }
-        }
-      `,
-      options: ['getters'],
-    },
-    {
-      code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            this['foo'] = foo;
-          }
-        }
-      `,
-      options: ['getters'],
-    },
-    {
-      code: `
-        class A {
-          private readonly foo: string = 'bar';
-          constructor(foo: string) {
-            const bar = new (class {
-              private readonly foo: string = 'baz';
-              constructor() {
-                this.foo = 'qux';
-              }
-            })();
-            this['foo'] = foo;
-          }
-        }
-      `,
-      options: ['getters'],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts b/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
index ec8d13719751..bf49ce384a14 100644
--- a/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
@@ -5,6 +5,135 @@ import rule from '../../src/rules/consistent-generic-constructors';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-generic-constructors', rule, {
+  valid: [
+    // default: constructor
+    'const a = new Foo();',
+    'const a = new Foo<string>();',
+    'const a: Foo<string> = new Foo<string>();',
+    'const a: Foo = new Foo();',
+    'const a: Bar<string> = new Foo();',
+    'const a: Foo = new Foo<string>();',
+    'const a: Bar = new Foo<string>();',
+    'const a: Bar<string> = new Foo<string>();',
+    'const a: Foo<string> = Foo<string>();',
+    'const a: Foo<string> = Foo();',
+    'const a: Foo = Foo<string>();',
+    `
+class Foo {
+  a = new Foo<string>();
+}
+    `,
+    `
+function foo(a: Foo = new Foo<string>()) {}
+    `,
+    `
+function foo({ a }: Foo = new Foo<string>()) {}
+    `,
+    `
+function foo([a]: Foo = new Foo<string>()) {}
+    `,
+    `
+class A {
+  constructor(a: Foo = new Foo<string>()) {}
+}
+    `,
+    `
+const a = function (a: Foo = new Foo<string>()) {};
+    `,
+    // type-annotation
+    {
+      code: 'const a = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo = new Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Bar = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Bar<string> = new Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo<string> = Foo();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a: Foo = Foo<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: 'const a = new (class C<T> {})<string>();',
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+class Foo {
+  a: Foo<string> = new Foo();
+}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo(a: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo({ a }: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function foo([a]: Foo<string> = new Foo()) {}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+class A {
+  constructor(a: Foo<string> = new Foo()) {}
+}
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+const a = function (a: Foo<string> = new Foo()) {};
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+const [a = new Foo<string>()] = [];
+      `,
+      options: ['type-annotation'],
+    },
+    {
+      code: `
+function a([a = new Foo<string>()]) {}
+      `,
+      options: ['type-annotation'],
+    },
+  ],
   invalid: [
     {
       code: 'const a: Foo<string> = new Foo();',
@@ -389,133 +518,4 @@ const a = function (a: Foo<string> = new Foo()) {};
       `,
     },
   ],
-  valid: [
-    // default: constructor
-    'const a = new Foo();',
-    'const a = new Foo<string>();',
-    'const a: Foo<string> = new Foo<string>();',
-    'const a: Foo = new Foo();',
-    'const a: Bar<string> = new Foo();',
-    'const a: Foo = new Foo<string>();',
-    'const a: Bar = new Foo<string>();',
-    'const a: Bar<string> = new Foo<string>();',
-    'const a: Foo<string> = Foo<string>();',
-    'const a: Foo<string> = Foo();',
-    'const a: Foo = Foo<string>();',
-    `
-class Foo {
-  a = new Foo<string>();
-}
-    `,
-    `
-function foo(a: Foo = new Foo<string>()) {}
-    `,
-    `
-function foo({ a }: Foo = new Foo<string>()) {}
-    `,
-    `
-function foo([a]: Foo = new Foo<string>()) {}
-    `,
-    `
-class A {
-  constructor(a: Foo = new Foo<string>()) {}
-}
-    `,
-    `
-const a = function (a: Foo = new Foo<string>()) {};
-    `,
-    // type-annotation
-    {
-      code: 'const a = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo = new Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Bar = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Bar<string> = new Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo<string> = Foo();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a: Foo = Foo<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: 'const a = new (class C<T> {})<string>();',
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-class Foo {
-  a: Foo<string> = new Foo();
-}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo(a: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo({ a }: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function foo([a]: Foo<string> = new Foo()) {}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-class A {
-  constructor(a: Foo<string> = new Foo()) {}
-}
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-const a = function (a: Foo<string> = new Foo()) {};
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-const [a = new Foo<string>()] = [];
-      `,
-      options: ['type-annotation'],
-    },
-    {
-      code: `
-function a([a = new Foo<string>()]) {}
-      `,
-      options: ['type-annotation'],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts b/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
index cf0c5f8ba0fd..b6d4e8dff432 100644
--- a/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-indexed-object-style.test.ts
@@ -5,6 +5,143 @@ import rule from '../../src/rules/consistent-indexed-object-style';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-indexed-object-style', rule, {
+  valid: [
+    // 'record' (default)
+    // Record
+    'type Foo = Record<string, any>;',
+
+    // Interface
+    'interface Foo {}',
+    `
+interface Foo {
+  bar: string;
+}
+    `,
+    `
+interface Foo {
+  bar: string;
+  [key: string]: any;
+}
+    `,
+    `
+interface Foo {
+  [key: string]: any;
+  bar: string;
+}
+    `,
+    // circular
+    'type Foo = { [key: string]: string | Foo };',
+    'type Foo = { [key: string]: Foo };',
+    'type Foo = { [key: string]: Foo } | Foo;',
+    `
+interface Foo {
+  [key: string]: Foo;
+}
+    `,
+    `
+interface Foo<T> {
+  [key: string]: Foo<T>;
+}
+    `,
+    `
+interface Foo<T> {
+  [key: string]: Foo<T> | string;
+}
+    `,
+    // Type literal
+    'type Foo = {};',
+    `
+type Foo = {
+  bar: string;
+  [key: string]: any;
+};
+    `,
+    `
+type Foo = {
+  bar: string;
+};
+    `,
+    `
+type Foo = {
+  [key: string]: any;
+  bar: string;
+};
+    `,
+
+    // Generic
+    `
+type Foo = Generic<{
+  [key: string]: any;
+  bar: string;
+}>;
+    `,
+
+    // Function types
+    'function foo(arg: { [key: string]: any; bar: string }) {}',
+    'function foo(): { [key: string]: any; bar: string } {}',
+
+    // Invalid syntax allowed by the parser
+    'type Foo = { [key: string] };',
+    'type Foo = { [] };',
+    `
+interface Foo {
+  [key: string];
+}
+    `,
+    `
+interface Foo {
+  [];
+}
+    `,
+    // 'index-signature'
+    // Unhandled type
+    {
+      code: 'type Foo = Misc<string, unknown>;',
+      options: ['index-signature'],
+    },
+
+    // Invalid record
+    {
+      code: 'type Foo = Record;',
+      options: ['index-signature'],
+    },
+    {
+      code: 'type Foo = Record<string>;',
+      options: ['index-signature'],
+    },
+    {
+      code: 'type Foo = Record<string, number, unknown>;',
+      options: ['index-signature'],
+    },
+
+    // Type literal
+    {
+      code: 'type Foo = { [key: string]: any };',
+      options: ['index-signature'],
+    },
+
+    // Generic
+    {
+      code: 'type Foo = Generic<{ [key: string]: any }>;',
+      options: ['index-signature'],
+    },
+
+    // Function types
+    {
+      code: 'function foo(arg: { [key: string]: any }) {}',
+      options: ['index-signature'],
+    },
+    {
+      code: 'function foo(): { [key: string]: any } {}',
+      options: ['index-signature'],
+    },
+
+    // Namespace
+    {
+      code: 'type T = A.B;',
+      options: ['index-signature'],
+    },
+  ],
   invalid: [
     // Interface
     {
@@ -255,141 +392,4 @@ interface Foo {
       output: 'function foo(): { [key: string]: any } {}',
     },
   ],
-  valid: [
-    // 'record' (default)
-    // Record
-    'type Foo = Record<string, any>;',
-
-    // Interface
-    'interface Foo {}',
-    `
-interface Foo {
-  bar: string;
-}
-    `,
-    `
-interface Foo {
-  bar: string;
-  [key: string]: any;
-}
-    `,
-    `
-interface Foo {
-  [key: string]: any;
-  bar: string;
-}
-    `,
-    // circular
-    'type Foo = { [key: string]: string | Foo };',
-    'type Foo = { [key: string]: Foo };',
-    'type Foo = { [key: string]: Foo } | Foo;',
-    `
-interface Foo {
-  [key: string]: Foo;
-}
-    `,
-    `
-interface Foo<T> {
-  [key: string]: Foo<T>;
-}
-    `,
-    `
-interface Foo<T> {
-  [key: string]: Foo<T> | string;
-}
-    `,
-    // Type literal
-    'type Foo = {};',
-    `
-type Foo = {
-  bar: string;
-  [key: string]: any;
-};
-    `,
-    `
-type Foo = {
-  bar: string;
-};
-    `,
-    `
-type Foo = {
-  [key: string]: any;
-  bar: string;
-};
-    `,
-
-    // Generic
-    `
-type Foo = Generic<{
-  [key: string]: any;
-  bar: string;
-}>;
-    `,
-
-    // Function types
-    'function foo(arg: { [key: string]: any; bar: string }) {}',
-    'function foo(): { [key: string]: any; bar: string } {}',
-
-    // Invalid syntax allowed by the parser
-    'type Foo = { [key: string] };',
-    'type Foo = { [] };',
-    `
-interface Foo {
-  [key: string];
-}
-    `,
-    `
-interface Foo {
-  [];
-}
-    `,
-    // 'index-signature'
-    // Unhandled type
-    {
-      code: 'type Foo = Misc<string, unknown>;',
-      options: ['index-signature'],
-    },
-
-    // Invalid record
-    {
-      code: 'type Foo = Record;',
-      options: ['index-signature'],
-    },
-    {
-      code: 'type Foo = Record<string>;',
-      options: ['index-signature'],
-    },
-    {
-      code: 'type Foo = Record<string, number, unknown>;',
-      options: ['index-signature'],
-    },
-
-    // Type literal
-    {
-      code: 'type Foo = { [key: string]: any };',
-      options: ['index-signature'],
-    },
-
-    // Generic
-    {
-      code: 'type Foo = Generic<{ [key: string]: any }>;',
-      options: ['index-signature'],
-    },
-
-    // Function types
-    {
-      code: 'function foo(arg: { [key: string]: any }) {}',
-      options: ['index-signature'],
-    },
-    {
-      code: 'function foo(): { [key: string]: any } {}',
-      options: ['index-signature'],
-    },
-
-    // Namespace
-    {
-      code: 'type T = A.B;',
-      options: ['index-signature'],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-return.test.ts b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
index ce807a71175c..e62345932396 100644
--- a/packages/eslint-plugin/tests/rules/consistent-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
@@ -15,6 +15,201 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('consistent-return', rule, {
+  valid: [
+    // base rule
+    `
+      function foo() {
+        return;
+      }
+    `,
+    `
+      const foo = (flag: boolean) => {
+        if (flag) return true;
+        return false;
+      };
+    `,
+    `
+      class A {
+        foo() {
+          if (a) return true;
+          return false;
+        }
+      }
+    `,
+    {
+      code: `
+        const foo = (flag: boolean) => {
+          if (flag) return;
+          else return undefined;
+        };
+      `,
+      options: [{ treatUndefinedAsUnspecified: true }],
+    },
+    // void
+    `
+      declare function bar(): void;
+      function foo(flag: boolean): void {
+        if (flag) {
+          return bar();
+        }
+        return;
+      }
+    `,
+    `
+      declare function bar(): void;
+      const foo = (flag: boolean): void => {
+        if (flag) {
+          return;
+        }
+        return bar();
+      };
+    `,
+    `
+      function foo(flag?: boolean): number | void {
+        if (flag) {
+          return 42;
+        }
+        return;
+      }
+    `,
+    `
+      function foo(): boolean;
+      function foo(flag: boolean): void;
+      function foo(flag?: boolean): boolean | void {
+        if (flag) {
+          return;
+        }
+        return true;
+      }
+    `,
+    `
+      class Foo {
+        baz(): void {}
+        bar(flag: boolean): void {
+          if (flag) return baz();
+          return;
+        }
+      }
+    `,
+    `
+      declare function bar(): void;
+      function foo(flag: boolean): void {
+        function fn(): string {
+          return '1';
+        }
+        if (flag) {
+          return bar();
+        }
+        return;
+      }
+    `,
+    `
+      class Foo {
+        foo(flag: boolean): void {
+          const bar = (): void => {
+            if (flag) return;
+            return this.foo();
+          };
+          if (flag) {
+            return this.bar();
+          }
+          return;
+        }
+      }
+    `,
+    // async
+    `
+      declare function bar(): void;
+      async function foo(flag?: boolean): Promise<void> {
+        if (flag) {
+          return bar();
+        }
+        return;
+      }
+    `,
+    `
+      declare function bar(): Promise<void>;
+      async function foo(flag?: boolean): Promise<ReturnType<typeof bar>> {
+        if (flag) {
+          return bar();
+        }
+        return;
+      }
+    `,
+    `
+      async function foo(flag?: boolean): Promise<Promise<void | undefined>> {
+        if (flag) {
+          return undefined;
+        }
+        return;
+      }
+    `,
+    `
+      type PromiseVoidNumber = Promise<void | number>;
+      async function foo(flag?: boolean): PromiseVoidNumber {
+        if (flag) {
+          return 42;
+        }
+        return;
+      }
+    `,
+    `
+      class Foo {
+        baz(): void {}
+        async bar(flag: boolean): Promise<void> {
+          if (flag) return baz();
+          return;
+        }
+      }
+    `,
+    {
+      code: `
+        declare const undef: undefined;
+        function foo(flag: boolean) {
+          if (flag) {
+            return undef;
+          }
+          return 'foo';
+        }
+      `,
+      options: [
+        {
+          treatUndefinedAsUnspecified: false,
+        },
+      ],
+    },
+    {
+      code: `
+        function foo(flag: boolean): undefined {
+          if (flag) {
+            return undefined;
+          }
+          return;
+        }
+      `,
+      options: [
+        {
+          treatUndefinedAsUnspecified: true,
+        },
+      ],
+    },
+    {
+      code: `
+        declare const undef: undefined;
+        function foo(flag: boolean): undefined {
+          if (flag) {
+            return undef;
+          }
+          return;
+        }
+      `,
+      options: [
+        {
+          treatUndefinedAsUnspecified: true,
+        },
+      ],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -259,199 +454,4 @@ ruleTester.run('consistent-return', rule, {
       ],
     },
   ],
-  valid: [
-    // base rule
-    `
-      function foo() {
-        return;
-      }
-    `,
-    `
-      const foo = (flag: boolean) => {
-        if (flag) return true;
-        return false;
-      };
-    `,
-    `
-      class A {
-        foo() {
-          if (a) return true;
-          return false;
-        }
-      }
-    `,
-    {
-      code: `
-        const foo = (flag: boolean) => {
-          if (flag) return;
-          else return undefined;
-        };
-      `,
-      options: [{ treatUndefinedAsUnspecified: true }],
-    },
-    // void
-    `
-      declare function bar(): void;
-      function foo(flag: boolean): void {
-        if (flag) {
-          return bar();
-        }
-        return;
-      }
-    `,
-    `
-      declare function bar(): void;
-      const foo = (flag: boolean): void => {
-        if (flag) {
-          return;
-        }
-        return bar();
-      };
-    `,
-    `
-      function foo(flag?: boolean): number | void {
-        if (flag) {
-          return 42;
-        }
-        return;
-      }
-    `,
-    `
-      function foo(): boolean;
-      function foo(flag: boolean): void;
-      function foo(flag?: boolean): boolean | void {
-        if (flag) {
-          return;
-        }
-        return true;
-      }
-    `,
-    `
-      class Foo {
-        baz(): void {}
-        bar(flag: boolean): void {
-          if (flag) return baz();
-          return;
-        }
-      }
-    `,
-    `
-      declare function bar(): void;
-      function foo(flag: boolean): void {
-        function fn(): string {
-          return '1';
-        }
-        if (flag) {
-          return bar();
-        }
-        return;
-      }
-    `,
-    `
-      class Foo {
-        foo(flag: boolean): void {
-          const bar = (): void => {
-            if (flag) return;
-            return this.foo();
-          };
-          if (flag) {
-            return this.bar();
-          }
-          return;
-        }
-      }
-    `,
-    // async
-    `
-      declare function bar(): void;
-      async function foo(flag?: boolean): Promise<void> {
-        if (flag) {
-          return bar();
-        }
-        return;
-      }
-    `,
-    `
-      declare function bar(): Promise<void>;
-      async function foo(flag?: boolean): Promise<ReturnType<typeof bar>> {
-        if (flag) {
-          return bar();
-        }
-        return;
-      }
-    `,
-    `
-      async function foo(flag?: boolean): Promise<Promise<void | undefined>> {
-        if (flag) {
-          return undefined;
-        }
-        return;
-      }
-    `,
-    `
-      type PromiseVoidNumber = Promise<void | number>;
-      async function foo(flag?: boolean): PromiseVoidNumber {
-        if (flag) {
-          return 42;
-        }
-        return;
-      }
-    `,
-    `
-      class Foo {
-        baz(): void {}
-        async bar(flag: boolean): Promise<void> {
-          if (flag) return baz();
-          return;
-        }
-      }
-    `,
-    {
-      code: `
-        declare const undef: undefined;
-        function foo(flag: boolean) {
-          if (flag) {
-            return undef;
-          }
-          return 'foo';
-        }
-      `,
-      options: [
-        {
-          treatUndefinedAsUnspecified: false,
-        },
-      ],
-    },
-    {
-      code: `
-        function foo(flag: boolean): undefined {
-          if (flag) {
-            return undefined;
-          }
-          return;
-        }
-      `,
-      options: [
-        {
-          treatUndefinedAsUnspecified: true,
-        },
-      ],
-    },
-    {
-      code: `
-        declare const undef: undefined;
-        function foo(flag: boolean): undefined {
-          if (flag) {
-            return undef;
-          }
-          return;
-        }
-      `,
-      options: [
-        {
-          treatUndefinedAsUnspecified: true,
-        },
-      ],
-    },
-  ],
 });
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 435030e82982..67fe0a3b85e8 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
@@ -84,6 +84,68 @@ print\`\${<Foo>{ bar: 5 }}\`
 `;
 
 ruleTester.run('consistent-type-assertions', rule, {
+  valid: [
+    ...dedupeTestCases(
+      batchedSingleLineTests<Options>({
+        code: AS_TESTS,
+        options: [
+          { assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' },
+        ],
+      }),
+    ),
+    ...batchedSingleLineTests<Options>({
+      code: ANGLE_BRACKET_TESTS,
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow',
+        },
+      ],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: `${OBJECT_LITERAL_AS_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_AS_CASTS}`,
+      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' }],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: `${OBJECT_LITERAL_ANGLE_BRACKET_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS}`,
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow',
+        },
+      ],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: OBJECT_LITERAL_ARGUMENT_AS_CASTS,
+      options: [
+        {
+          assertionStyle: 'as',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
+        },
+      ],
+    }),
+    ...batchedSingleLineTests<Options>({
+      code: OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS,
+      options: [
+        {
+          assertionStyle: 'angle-bracket',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
+        },
+      ],
+    }),
+    { code: 'const x = <const>[1];', options: [{ assertionStyle: 'never' }] },
+    { code: 'const x = [1] as const;', options: [{ assertionStyle: 'never' }] },
+    {
+      code: 'const bar = <Foo style={{ bar: 5 } as Bar} />;',
+      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+      options: [
+        {
+          assertionStyle: 'as',
+          objectLiteralTypeAssertions: 'allow-as-parameter',
+        },
+      ],
+    },
+  ],
   invalid: [
     ...dedupeTestCases(
       (
@@ -598,66 +660,4 @@ const bs = (x <<= y) as any;
       output: 'const ternary = (true ? x : y) as any;',
     },
   ],
-  valid: [
-    ...dedupeTestCases(
-      batchedSingleLineTests<Options>({
-        code: AS_TESTS,
-        options: [
-          { assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' },
-        ],
-      }),
-    ),
-    ...batchedSingleLineTests<Options>({
-      code: ANGLE_BRACKET_TESTS,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: `${OBJECT_LITERAL_AS_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_AS_CASTS}`,
-      options: [{ assertionStyle: 'as', objectLiteralTypeAssertions: 'allow' }],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: `${OBJECT_LITERAL_ANGLE_BRACKET_CASTS.trimEnd()}${OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS}`,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: OBJECT_LITERAL_ARGUMENT_AS_CASTS,
-      options: [
-        {
-          assertionStyle: 'as',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    }),
-    ...batchedSingleLineTests<Options>({
-      code: OBJECT_LITERAL_ARGUMENT_ANGLE_BRACKET_CASTS,
-      options: [
-        {
-          assertionStyle: 'angle-bracket',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    }),
-    { code: 'const x = <const>[1];', options: [{ assertionStyle: 'never' }] },
-    { code: 'const x = [1] as const;', options: [{ assertionStyle: 'never' }] },
-    {
-      code: 'const bar = <Foo style={{ bar: 5 } as Bar} />;',
-      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
-      options: [
-        {
-          assertionStyle: 'as',
-          objectLiteralTypeAssertions: 'allow-as-parameter',
-        },
-      ],
-    },
-  ],
 });
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 1fbbf9cb7ba6..3735fca22ffa 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
@@ -5,6 +5,60 @@ import rule from '../../src/rules/consistent-type-definitions';
 const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-type-definitions', rule, {
+  valid: [
+    {
+      code: 'var foo = {};',
+      options: ['interface'],
+    },
+    {
+      code: 'interface A {}',
+      options: ['interface'],
+    },
+    {
+      code: `
+interface A extends B {
+  x: number;
+}
+      `,
+      options: ['interface'],
+    },
+    {
+      code: 'type U = string;',
+      options: ['interface'],
+    },
+    {
+      code: 'type V = { x: number } | { y: string };',
+      options: ['interface'],
+    },
+    {
+      code: `
+type Record<T, U> = {
+  [K in T]: U;
+};
+      `,
+      options: ['interface'],
+    },
+    {
+      code: 'type T = { x: number };',
+      options: ['type'],
+    },
+    {
+      code: 'type A = { x: number } & B & C;',
+      options: ['type'],
+    },
+    {
+      code: 'type A = { x: number } & B<T1> & C<T2>;',
+      options: ['type'],
+    },
+    {
+      code: `
+export type W<T> = {
+  x: T;
+};
+      `,
+      options: ['type'],
+    },
+  ],
   invalid: [
     {
       code: noFormat`type T = { x: number; };`,
@@ -297,58 +351,4 @@ export declare type Test = {
       `,
     },
   ],
-  valid: [
-    {
-      code: 'var foo = {};',
-      options: ['interface'],
-    },
-    {
-      code: 'interface A {}',
-      options: ['interface'],
-    },
-    {
-      code: `
-interface A extends B {
-  x: number;
-}
-      `,
-      options: ['interface'],
-    },
-    {
-      code: 'type U = string;',
-      options: ['interface'],
-    },
-    {
-      code: 'type V = { x: number } | { y: string };',
-      options: ['interface'],
-    },
-    {
-      code: `
-type Record<T, U> = {
-  [K in T]: U;
-};
-      `,
-      options: ['interface'],
-    },
-    {
-      code: 'type T = { x: number };',
-      options: ['type'],
-    },
-    {
-      code: 'type A = { x: number } & B & C;',
-      options: ['type'],
-    },
-    {
-      code: 'type A = { x: number } & B<T1> & C<T2>;',
-      options: ['type'],
-    },
-    {
-      code: `
-export type W<T> = {
-  x: T;
-};
-      `,
-      options: ['type'],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
index de0b57798c3f..c6d30df37a58 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
@@ -15,6 +15,45 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('consistent-type-exports', rule, {
+  valid: [
+    // unknown module should be ignored
+    "export { Foo } from 'foo';",
+
+    "export type { Type1 } from './consistent-type-exports';",
+    "export { value1 } from './consistent-type-exports';",
+    "export type { value1 } from './consistent-type-exports';",
+    `
+const variable = 1;
+class Class {}
+enum Enum {}
+function Func() {}
+namespace ValueNS {
+  export const x = 1;
+}
+
+export { variable, Class, Enum, Func, ValueNS };
+    `,
+    `
+type Alias = 1;
+interface IFace {}
+namespace TypeNS {
+  export type x = 1;
+}
+
+export type { Alias, IFace, TypeNS };
+    `,
+    `
+const foo = 1;
+export type { foo };
+    `,
+    `
+namespace NonTypeNS {
+  export const x = 1;
+}
+
+export { NonTypeNS };
+    `,
+  ],
   invalid: [
     {
       code: "export { Type1 } from './consistent-type-exports';",
@@ -348,43 +387,4 @@ export {
       `,
     },
   ],
-  valid: [
-    // unknown module should be ignored
-    "export { Foo } from 'foo';",
-
-    "export type { Type1 } from './consistent-type-exports';",
-    "export { value1 } from './consistent-type-exports';",
-    "export type { value1 } from './consistent-type-exports';",
-    `
-const variable = 1;
-class Class {}
-enum Enum {}
-function Func() {}
-namespace ValueNS {
-  export const x = 1;
-}
-
-export { variable, Class, Enum, Func, ValueNS };
-    `,
-    `
-type Alias = 1;
-interface IFace {}
-namespace TypeNS {
-  export type x = 1;
-}
-
-export type { Alias, IFace, TypeNS };
-    `,
-    `
-const foo = 1;
-export type { foo };
-    `,
-    `
-namespace NonTypeNS {
-  export const x = 1;
-}
-
-export { NonTypeNS };
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
index 86c952435afe..f881862c9688 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
@@ -23,175 +23,371 @@ for (const parserOptions of PARSER_OPTION_COMBOS) {
     });
 
     ruleTester.run('consistent-type-imports', rule, {
-      invalid: [
+      valid: [
+        `
+          import Foo from 'foo';
+          const foo: Foo = new Foo();
+        `,
+        `
+          import foo from 'foo';
+          const foo: foo.Foo = foo.fn();
+        `,
+        `
+          import { A, B } from 'foo';
+          const foo: A = B();
+          const bar = new A();
+        `,
+        `
+          import Foo from 'foo';
+        `,
+        `
+          import Foo from 'foo';
+          type T<Foo> = Foo; // shadowing
+        `,
+        `
+          import Foo from 'foo';
+          function fn() {
+            type Foo = {}; // shadowing
+            let foo: Foo;
+          }
+        `,
+        `
+          import { A, B } from 'foo';
+          const b = B;
+        `,
+        `
+          import { A, B, C as c } from 'foo';
+          const d = c;
+        `,
+        `
+          import {} from 'foo'; // empty
+        `,
         {
           code: `
-import Foo from 'foo';
-let foo: Foo;
-type Bar = Foo;
-interface Baz {
-  foo: Foo;
-}
-function fn(a: Foo): Foo {}
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
-type Bar = Foo;
-interface Baz {
-  foo: Foo;
-}
-function fn(a: Foo): Foo {}
+let foo: import('foo');
+let bar: import('foo').Bar;
           `,
+          options: [{ disallowTypeAnnotations: false }],
         },
         {
           code: `
 import Foo from 'foo';
 let foo: Foo;
           `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          options: [{ prefer: 'type-imports' }],
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
-          `,
+          options: [{ prefer: 'no-type-imports' }],
         },
+        // type queries
+        `
+          import type Type from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
+        `
+          import type { Type } from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
+        `
+          import type * as Type from 'foo';
+
+          type T = typeof Type;
+          type T = typeof Type.foo;
+        `,
         {
           code: `
-import Foo from 'foo';
-let foo: Foo;
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          options: [
-            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
-          ],
-          output: `
-import type Foo from 'foo';
-let foo: Foo;
+import Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { A, B } from 'foo';
-let foo: A;
-let bar: B;
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-import type { A, B } from 'foo';
-let foo: A;
-let bar: B;
+import { Type } from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { A as a, B as b } from 'foo';
-let foo: a;
-let bar: b;
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-import type { A as a, B as b } from 'foo';
-let foo: a;
-let bar: b;
+import * as Type from 'foo';
+
+type T = typeof Type;
+type T = typeof Type.foo;
           `,
+          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import Foo from 'foo';
-type Bar = typeof Foo; // TSTypeQuery
+import * as Type from 'foo' assert { type: 'json' };
+const a: typeof Type = Type;
           `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-import type Foo from 'foo';
-type Bar = typeof Foo; // TSTypeQuery
+          options: [{ prefer: 'no-type-imports' }],
+        },
+        `
+          import { type A } from 'foo';
+          type T = A;
+        `,
+        `
+          import { type A, B } from 'foo';
+          type T = A;
+          const b = B;
+        `,
+        `
+          import { type A, type B } from 'foo';
+          type T = A;
+          type Z = B;
+        `,
+        `
+          import { B } from 'foo';
+          import { type A } from 'foo';
+          type T = A;
+          const b = B;
+        `,
+        {
+          code: `
+import { B, type A } from 'foo';
+type T = A;
+const b = B;
           `,
+          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import foo from 'foo';
-type Bar = foo.Bar; // TSQualifiedName
+import { B } from 'foo';
+import type A from 'baz';
+type T = A;
+const b = B;
           `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-import type foo from 'foo';
-type Bar = foo.Bar; // TSQualifiedName
+          options: [{ fixStyle: 'inline-type-imports' }],
+        },
+        {
+          code: `
+import { type B } from 'foo';
+import type { A } from 'foo';
+type T = A;
+const b = B;
           `,
+          options: [{ fixStyle: 'inline-type-imports' }],
         },
         {
           code: `
-import foo from 'foo';
-type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
+import { B, type C } from 'foo';
+import type A from 'baz';
+type T = A;
+type Z = C;
+const b = B;
           `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
           ],
-          output: `
-import type foo from 'foo';
-type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
-          `,
         },
         {
           code: `
-import * as A from 'foo';
-let foo: A.Foo;
+import { B } from 'foo';
+import type { A } from 'foo';
+type T = A;
+const b = B;
           `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
           ],
-          output: `
-import type * as A from 'foo';
-let foo: A.Foo;
-          `,
         },
         {
-          // default and named
           code: `
-import A, { B } from 'foo';
-let foo: A;
-let bar: B;
+import { B } from 'foo';
+import { A } from 'foo';
+type T = A;
+const b = B;
+          `,
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'no-type-imports' },
+          ],
+        },
+        // exports
+        `
+          import Type from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type Type from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+        `
+          import { Type } from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type { Type } from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+        `
+          import * as Type from 'foo';
+
+          export { Type }; // is a value export
+          export default Type; // is a value export
+        `,
+        `
+          import type * as Type from 'foo';
+
+          export { Type }; // is a type-only export
+          export default Type; // is a type-only export
+          export type { Type }; // is a type-only export
+        `,
+
+        {
+          code: `
+import Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
+          options: [{ prefer: 'no-type-imports' }],
+        },
+        {
+          code: `
+import { Type } from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
+          options: [{ prefer: 'no-type-imports' }],
+        },
+        {
+          code: `
+import * as Type from 'foo';
+
+export { Type }; // is a type-only export
+export default Type; // is a type-only export
+export type { Type }; // is a type-only export
+          `,
+          options: [{ prefer: 'no-type-imports' }],
+        },
+        // https://github.com/typescript-eslint/typescript-eslint/issues/2455
+        {
+          code: `
+import React from 'react';
+
+export const ComponentFoo: React.FC = () => {
+  return <div>Foo Foo</div>;
+};
+          `,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+            },
+          },
+        },
+        {
+          code: `
+import { h } from 'some-other-jsx-lib';
+
+export const ComponentFoo: h.FC = () => {
+  return <div>Foo Foo</div>;
+};
+          `,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxPragma: 'h',
+            },
+          },
+        },
+        {
+          code: `
+import { Fragment } from 'react';
+
+export const ComponentFoo: Fragment = () => {
+  return <>Foo Foo</>;
+};
+          `,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxFragmentName: 'Fragment',
+            },
+          },
+        },
+        `
+          import Default, * as Rest from 'module';
+          const a: typeof Default = Default;
+          const b: typeof Rest = Rest;
+        `,
+
+        // https://github.com/typescript-eslint/typescript-eslint/issues/2989
+        `
+          import type * as constants from './constants';
+
+          export type Y = {
+            [constants.X]: ReadonlyArray<string>;
+          };
+        `,
+        `
+          import A from 'foo';
+          export = A;
+        `,
+        `
+          import type A from 'foo';
+          export = A;
+        `,
+        `
+          import type A from 'foo';
+          export = {} as A;
+        `,
+        `
+          import { type A } from 'foo';
+          export = {} as A;
+        `,
+
+        // semantically these are insane but syntactically they are valid
+        // we don't want to handle them because it means changing invalid code
+        // to valid code which is dangerous "undefined" behavior.
+        `
+import type T from 'mod';
+const x = T;
+        `,
+        `
+import type { T } from 'mod';
+const x = T;
+        `,
+        `
+import { type T } from 'mod';
+const x = T;
+        `,
+      ],
+      invalid: [
+        {
+          code: `
+import Foo from 'foo';
+let foo: Foo;
+type Bar = Foo;
+interface Baz {
+  foo: Foo;
+}
+function fn(a: Foo): Foo {}
           `,
           errors: [
             {
@@ -200,16 +396,19 @@ let bar: B;
             },
           ],
           output: `
-import type { B } from 'foo';
-import type A from 'foo';
-let foo: A;
-let bar: B;
+import type Foo from 'foo';
+let foo: Foo;
+type Bar = Foo;
+interface Baz {
+  foo: Foo;
+}
+function fn(a: Foo): Foo {}
           `,
         },
         {
-          code: noFormat`
-import A, {} from 'foo';
-let foo: A;
+          code: `
+import Foo from 'foo';
+let foo: Foo;
           `,
           errors: [
             {
@@ -217,67 +416,223 @@ let foo: A;
               messageId: 'typeOverValue',
             },
           ],
+          options: [{ prefer: 'type-imports' }],
           output: `
-import type A from 'foo';
-let foo: A;
+import type Foo from 'foo';
+let foo: Foo;
           `,
         },
         {
           code: `
-import { A, B } from 'foo';
-const foo: A = B();
+import Foo from 'foo';
+let foo: Foo;
           `,
           errors: [
             {
-              data: { typeImports: '"A"' },
               line: 2,
-              messageId: 'someImportsAreOnlyTypes',
+              messageId: 'typeOverValue',
             },
           ],
+          options: [
+            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
+          ],
           output: `
-import type { A} from 'foo';
-import { B } from 'foo';
-const foo: A = B();
+import type Foo from 'foo';
+let foo: Foo;
           `,
         },
         {
           code: `
-import { A, B, C } from 'foo';
-const foo: A = B();
-let bar: C;
+import { A, B } from 'foo';
+let foo: A;
+let bar: B;
           `,
           errors: [
             {
-              data: { typeImports: '"A" and "C"' },
               line: 2,
-              messageId: 'someImportsAreOnlyTypes',
+              messageId: 'typeOverValue',
             },
           ],
           output: `
-import type { A, C } from 'foo';
-import { B } from 'foo';
-const foo: A = B();
-let bar: C;
+import type { A, B } from 'foo';
+let foo: A;
+let bar: B;
           `,
         },
         {
           code: `
-import { A, B, C, D } from 'foo';
-const foo: A = B();
-type T = { bar: C; baz: D };
+import { A as a, B as b } from 'foo';
+let foo: a;
+let bar: b;
           `,
           errors: [
             {
-              data: { typeImports: '"A", "C" and "D"' },
               line: 2,
-              messageId: 'someImportsAreOnlyTypes',
+              messageId: 'typeOverValue',
             },
           ],
           output: `
-import type { A, C, D } from 'foo';
-import { B } from 'foo';
-const foo: A = B();
-type T = { bar: C; baz: D };
+import type { A as a, B as b } from 'foo';
+let foo: a;
+let bar: b;
+          `,
+        },
+        {
+          code: `
+import Foo from 'foo';
+type Bar = typeof Foo; // TSTypeQuery
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type Foo from 'foo';
+type Bar = typeof Foo; // TSTypeQuery
+          `,
+        },
+        {
+          code: `
+import foo from 'foo';
+type Bar = foo.Bar; // TSQualifiedName
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type foo from 'foo';
+type Bar = foo.Bar; // TSQualifiedName
+          `,
+        },
+        {
+          code: `
+import foo from 'foo';
+type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type foo from 'foo';
+type Baz = (typeof foo.bar)['Baz']; // TSQualifiedName & TSTypeQuery
+          `,
+        },
+        {
+          code: `
+import * as A from 'foo';
+let foo: A.Foo;
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type * as A from 'foo';
+let foo: A.Foo;
+          `,
+        },
+        {
+          // default and named
+          code: `
+import A, { B } from 'foo';
+let foo: A;
+let bar: B;
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type { B } from 'foo';
+import type A from 'foo';
+let foo: A;
+let bar: B;
+          `,
+        },
+        {
+          code: noFormat`
+import A, {} from 'foo';
+let foo: A;
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+import type A from 'foo';
+let foo: A;
+          `,
+        },
+        {
+          code: `
+import { A, B } from 'foo';
+const foo: A = B();
+          `,
+          errors: [
+            {
+              data: { typeImports: '"A"' },
+              line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+          ],
+          output: `
+import type { A} from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+          `,
+        },
+        {
+          code: `
+import { A, B, C } from 'foo';
+const foo: A = B();
+let bar: C;
+          `,
+          errors: [
+            {
+              data: { typeImports: '"A" and "C"' },
+              line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+          ],
+          output: `
+import type { A, C } from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+let bar: C;
+          `,
+        },
+        {
+          code: `
+import { A, B, C, D } from 'foo';
+const foo: A = B();
+type T = { bar: C; baz: D };
+          `,
+          errors: [
+            {
+              data: { typeImports: '"A", "C" and "D"' },
+              line: 2,
+              messageId: 'someImportsAreOnlyTypes',
+            },
+          ],
+          output: `
+import type { A, C, D } from 'foo';
+import { B } from 'foo';
+const foo: A = B();
+type T = { bar: C; baz: D };
           `,
         },
         {
@@ -1441,508 +1796,153 @@ export = {} as A;
         },
         {
           code: `
-            import Foo from 'foo';
-            class A {
-              foo(@deco foo: Foo) {}
-            }
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-            import type Foo from 'foo';
-            class A {
-              foo(@deco foo: Foo) {}
-            }
-          `,
-        },
-        {
-          code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              set foo(value: Foo) {}
-            }
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              set foo(value: Foo) {}
-            }
-          `,
-        },
-        {
-          code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set foo(value: Foo) {}
-            }
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set foo(value: Foo) {}
-            }
-          `,
-        },
-        {
-          code: `
-            import Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set ['foo'](value: Foo) {}
-            }
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-            import type Foo from 'foo';
-            class A {
-              @deco
-              get foo() {}
-
-              set ['foo'](value: Foo) {}
-            }
-          `,
-        },
-        {
-          code: `
-            import * as foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: foo.Foo) {}
-            }
-          `,
-          errors: [
-            {
-              line: 2,
-              messageId: 'typeOverValue',
-            },
-          ],
-          output: `
-            import type * as foo from 'foo';
-            @deco
-            class A {
-              constructor(foo: foo.Foo) {}
-            }
-          `,
-        },
-        // https://github.com/typescript-eslint/typescript-eslint/issues/7209
-        {
-          code: `
-import 'foo';
-import { Foo, Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-          errors: [
-            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
-          ],
-          output: `
-import 'foo';
-import type { Foo} from 'foo';
-import { Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-        },
-        {
-          code: `
-import {} from 'foo';
-import { Foo, Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-          errors: [
-            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
-          ],
-          output: `
-import {} from 'foo';
-import type { Foo} from 'foo';
-import { Bar } from 'foo';
-function test(foo: Foo) {}
-          `,
-        },
-      ],
-      valid: [
-        `
-          import Foo from 'foo';
-          const foo: Foo = new Foo();
-        `,
-        `
-          import foo from 'foo';
-          const foo: foo.Foo = foo.fn();
-        `,
-        `
-          import { A, B } from 'foo';
-          const foo: A = B();
-          const bar = new A();
-        `,
-        `
-          import Foo from 'foo';
-        `,
-        `
-          import Foo from 'foo';
-          type T<Foo> = Foo; // shadowing
-        `,
-        `
-          import Foo from 'foo';
-          function fn() {
-            type Foo = {}; // shadowing
-            let foo: Foo;
-          }
-        `,
-        `
-          import { A, B } from 'foo';
-          const b = B;
-        `,
-        `
-          import { A, B, C as c } from 'foo';
-          const d = c;
-        `,
-        `
-          import {} from 'foo'; // empty
-        `,
-        {
-          code: `
-let foo: import('foo');
-let bar: import('foo').Bar;
-          `,
-          options: [{ disallowTypeAnnotations: false }],
-        },
-        {
-          code: `
-import Foo from 'foo';
-let foo: Foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        // type queries
-        `
-          import type Type from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        `
-          import type { Type } from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        `
-          import type * as Type from 'foo';
-
-          type T = typeof Type;
-          type T = typeof Type.foo;
-        `,
-        {
-          code: `
-import Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        {
-          code: `
-import { Type } from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        {
-          code: `
-import * as Type from 'foo';
-
-type T = typeof Type;
-type T = typeof Type.foo;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        {
-          code: `
-import * as Type from 'foo' assert { type: 'json' };
-const a: typeof Type = Type;
-          `,
-          options: [{ prefer: 'no-type-imports' }],
-        },
-        `
-          import { type A } from 'foo';
-          type T = A;
-        `,
-        `
-          import { type A, B } from 'foo';
-          type T = A;
-          const b = B;
-        `,
-        `
-          import { type A, type B } from 'foo';
-          type T = A;
-          type Z = B;
-        `,
-        `
-          import { B } from 'foo';
-          import { type A } from 'foo';
-          type T = A;
-          const b = B;
-        `,
-        {
-          code: `
-import { B, type A } from 'foo';
-type T = A;
-const b = B;
-          `,
-          options: [{ fixStyle: 'inline-type-imports' }],
-        },
-        {
-          code: `
-import { B } from 'foo';
-import type A from 'baz';
-type T = A;
-const b = B;
-          `,
-          options: [{ fixStyle: 'inline-type-imports' }],
-        },
-        {
-          code: `
-import { type B } from 'foo';
-import type { A } from 'foo';
-type T = A;
-const b = B;
-          `,
-          options: [{ fixStyle: 'inline-type-imports' }],
-        },
-        {
-          code: `
-import { B, type C } from 'foo';
-import type A from 'baz';
-type T = A;
-type Z = C;
-const b = B;
-          `,
-          options: [
-            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
-          ],
-        },
-        {
-          code: `
-import { B } from 'foo';
-import type { A } from 'foo';
-type T = A;
-const b = B;
-          `,
-          options: [
-            { fixStyle: 'inline-type-imports', prefer: 'type-imports' },
-          ],
-        },
-        {
-          code: `
-import { B } from 'foo';
-import { A } from 'foo';
-type T = A;
-const b = B;
-          `,
-          options: [
-            { fixStyle: 'inline-type-imports', prefer: 'no-type-imports' },
-          ],
-        },
-        // exports
-        `
-          import Type from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type Type from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-        `
-          import { Type } from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type { Type } from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-        `
-          import * as Type from 'foo';
-
-          export { Type }; // is a value export
-          export default Type; // is a value export
-        `,
-        `
-          import type * as Type from 'foo';
-
-          export { Type }; // is a type-only export
-          export default Type; // is a type-only export
-          export type { Type }; // is a type-only export
-        `,
-
-        {
-          code: `
-import Type from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+            import Foo from 'foo';
+            class A {
+              foo(@deco foo: Foo) {}
+            }
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              foo(@deco foo: Foo) {}
+            }
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import { Type } from 'foo';
-
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+            import Foo from 'foo';
+            class A {
+              @deco
+              set foo(value: Foo) {}
+            }
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              set foo(value: Foo) {}
+            }
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
         {
           code: `
-import * as Type from 'foo';
+            import Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
 
-export { Type }; // is a type-only export
-export default Type; // is a type-only export
-export type { Type }; // is a type-only export
+              set foo(value: Foo) {}
+            }
+          `,
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
+            },
+          ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set foo(value: Foo) {}
+            }
           `,
-          options: [{ prefer: 'no-type-imports' }],
         },
-        // https://github.com/typescript-eslint/typescript-eslint/issues/2455
         {
           code: `
-import React from 'react';
+            import Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
 
-export const ComponentFoo: React.FC = () => {
-  return <div>Foo Foo</div>;
-};
+              set ['foo'](value: Foo) {}
+            }
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
             },
-          },
+          ],
+          output: `
+            import type Foo from 'foo';
+            class A {
+              @deco
+              get foo() {}
+
+              set ['foo'](value: Foo) {}
+            }
+          `,
         },
         {
           code: `
-import { h } from 'some-other-jsx-lib';
-
-export const ComponentFoo: h.FC = () => {
-  return <div>Foo Foo</div>;
-};
+            import * as foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: foo.Foo) {}
+            }
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
-              jsxPragma: 'h',
+          errors: [
+            {
+              line: 2,
+              messageId: 'typeOverValue',
             },
-          },
+          ],
+          output: `
+            import type * as foo from 'foo';
+            @deco
+            class A {
+              constructor(foo: foo.Foo) {}
+            }
+          `,
         },
+        // https://github.com/typescript-eslint/typescript-eslint/issues/7209
         {
           code: `
-import { Fragment } from 'react';
-
-export const ComponentFoo: Fragment = () => {
-  return <>Foo Foo</>;
-};
+import 'foo';
+import { Foo, Bar } from 'foo';
+function test(foo: Foo) {}
+          `,
+          errors: [
+            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
+          ],
+          output: `
+import 'foo';
+import type { Foo} from 'foo';
+import { Bar } from 'foo';
+function test(foo: Foo) {}
+          `,
+        },
+        {
+          code: `
+import {} from 'foo';
+import { Foo, Bar } from 'foo';
+function test(foo: Foo) {}
+          `,
+          errors: [
+            { column: 1, line: 3, messageId: 'someImportsAreOnlyTypes' },
+          ],
+          output: `
+import {} from 'foo';
+import type { Foo} from 'foo';
+import { Bar } from 'foo';
+function test(foo: Foo) {}
           `,
-          languageOptions: {
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
-              },
-              jsxFragmentName: 'Fragment',
-            },
-          },
         },
-        `
-          import Default, * as Rest from 'module';
-          const a: typeof Default = Default;
-          const b: typeof Rest = Rest;
-        `,
-
-        // https://github.com/typescript-eslint/typescript-eslint/issues/2989
-        `
-          import type * as constants from './constants';
-
-          export type Y = {
-            [constants.X]: ReadonlyArray<string>;
-          };
-        `,
-        `
-          import A from 'foo';
-          export = A;
-        `,
-        `
-          import type A from 'foo';
-          export = A;
-        `,
-        `
-          import type A from 'foo';
-          export = {} as A;
-        `,
-        `
-          import { type A } from 'foo';
-          export = {} as A;
-        `,
-
-        // semantically these are insane but syntactically they are valid
-        // we don't want to handle them because it means changing invalid code
-        // to valid code which is dangerous "undefined" behavior.
-        `
-import type T from 'mod';
-const x = T;
-        `,
-        `
-import type { T } from 'mod';
-const x = T;
-        `,
-        `
-import { type T } from 'mod';
-const x = T;
-        `,
       ],
     });
   });
@@ -1960,24 +1960,6 @@ describe('experimentalDecorators: true + emitDecoratorMetadata: true', () => {
   });
 
   ruleTester.run('consistent-type-imports', rule, {
-    invalid: [
-      {
-        code: `
-          import Foo from 'foo';
-          export type T = Foo;
-        `,
-        errors: [
-          {
-            line: 2,
-            messageId: 'typeOverValue',
-          },
-        ],
-        output: `
-          import type Foo from 'foo';
-          export type T = Foo;
-        `,
-      },
-    ],
     valid: [
       `
         import Foo from 'foo';
@@ -2122,5 +2104,23 @@ describe('experimentalDecorators: true + emitDecoratorMetadata: true', () => {
         }
       `,
     ],
+    invalid: [
+      {
+        code: `
+          import Foo from 'foo';
+          export type T = Foo;
+        `,
+        errors: [
+          {
+            line: 2,
+            messageId: 'typeOverValue',
+          },
+        ],
+        output: `
+          import type Foo from 'foo';
+          export type T = Foo;
+        `,
+      },
+    ],
   });
 });
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 ac95d9a51766..adda60c271b1 100644
--- a/packages/eslint-plugin/tests/rules/default-param-last.test.ts
+++ b/packages/eslint-plugin/tests/rules/default-param-last.test.ts
@@ -5,6 +5,112 @@ import rule from '../../src/rules/default-param-last';
 const ruleTester = new RuleTester();
 
 ruleTester.run('default-param-last', rule, {
+  valid: [
+    'function foo() {}',
+    'function foo(a: number) {}',
+    'function foo(a = 1) {}',
+    'function foo(a?: number) {}',
+    'function foo(a: number, b: number) {}',
+    'function foo(a: number, b: number, c?: number) {}',
+    'function foo(a: number, b = 1) {}',
+    'function foo(a: number, b = 1, c = 1) {}',
+    'function foo(a: number, b = 1, c?: number) {}',
+    '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 = () => {};',
+    '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) {}
+}
+    `,
+    `
+class Foo {
+  constructor(a: number, b?: number, c = 1) {}
+}
+    `,
+    `
+class Foo {
+  constructor(a: number, b = 1, c?: number) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b: number,
+    private c: number,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b?: number,
+    private c = 10,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public a: number,
+    protected b = 10,
+    private c?: number,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    protected b?: number,
+    private c = 0,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    b?: number,
+    private c = 0,
+  ) {}
+}
+    `,
+    `
+class Foo {
+  constructor(
+    a: number,
+    private b?: number,
+    c = 0,
+  ) {}
+}
+    `,
+  ],
   invalid: [
     {
       code: 'function foo(a = 1, b: number) {}',
@@ -594,110 +700,4 @@ class Foo {
       ],
     },
   ],
-  valid: [
-    'function foo() {}',
-    'function foo(a: number) {}',
-    'function foo(a = 1) {}',
-    'function foo(a?: number) {}',
-    'function foo(a: number, b: number) {}',
-    'function foo(a: number, b: number, c?: number) {}',
-    'function foo(a: number, b = 1) {}',
-    'function foo(a: number, b = 1, c = 1) {}',
-    'function foo(a: number, b = 1, c?: number) {}',
-    '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 = () => {};',
-    '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) {}
-}
-    `,
-    `
-class Foo {
-  constructor(a: number, b?: number, c = 1) {}
-}
-    `,
-    `
-class Foo {
-  constructor(a: number, b = 1, c?: number) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b: number,
-    private c: number,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b?: number,
-    private c = 10,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public a: number,
-    protected b = 10,
-    private c?: number,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    protected b?: number,
-    private c = 0,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    b?: number,
-    private c = 0,
-  ) {}
-}
-    `,
-    `
-class Foo {
-  constructor(
-    a: number,
-    private b?: number,
-    c = 0,
-  ) {}
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/dot-notation.test.ts b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
index 6b7f445e5d9f..9355a46750af 100644
--- a/packages/eslint-plugin/tests/rules/dot-notation.test.ts
+++ b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
@@ -23,6 +23,134 @@ function q(str: string): string {
 }
 
 ruleTester.run('dot-notation', rule, {
+  valid: [
+    //  baseRule
+    'a.b;',
+    'a.b.c;',
+    "a['12'];",
+    'a[b];',
+    'a[0];',
+    { code: 'a.b.c;', options: [{ allowKeywords: false }] },
+    { code: 'a.arguments;', options: [{ allowKeywords: false }] },
+    { code: 'a.let;', options: [{ allowKeywords: false }] },
+    { code: 'a.yield;', options: [{ allowKeywords: false }] },
+    { code: 'a.eval;', options: [{ allowKeywords: false }] },
+    { code: 'a[0];', options: [{ allowKeywords: false }] },
+    { code: "a['while'];", options: [{ allowKeywords: false }] },
+    { code: "a['true'];", options: [{ allowKeywords: false }] },
+    { code: "a['null'];", options: [{ allowKeywords: false }] },
+    { code: 'a[true];', options: [{ allowKeywords: false }] },
+    { code: 'a[null];', options: [{ allowKeywords: false }] },
+    { code: 'a.true;', options: [{ allowKeywords: true }] },
+    { code: 'a.null;', options: [{ allowKeywords: true }] },
+    {
+      code: "a['snake_case'];",
+      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
+    },
+    {
+      code: "a['lots_of_snake_case'];",
+      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
+    },
+    {
+      code: 'a[`time${range}`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'a[`while`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: [{ allowKeywords: false }],
+    },
+    {
+      code: 'a[`time range`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    'a.true;',
+    'a.null;',
+    'a[undefined];',
+    'a[void 0];',
+    'a[b()];',
+    {
+      code: 'a[/(?<zero>0)/];',
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+    },
+
+    {
+      code: `
+class X {
+  private priv_prop = 123;
+}
+
+const x = new X();
+x['priv_prop'] = 123;
+      `,
+      options: [{ allowPrivateClassPropertyAccess: true }],
+    },
+
+    {
+      code: `
+class X {
+  protected protected_prop = 123;
+}
+
+const x = new X();
+x['protected_prop'] = 123;
+      `,
+      options: [{ allowProtectedClassPropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  prop: string;
+  [key: string]: number;
+}
+
+const x = new X();
+x['hello'] = 3;
+      `,
+      options: [{ allowIndexSignaturePropertyAccess: true }],
+    },
+    {
+      code: `
+interface Nested {
+  property: string;
+  [key: string]: number | string;
+}
+
+class Dingus {
+  nested: Nested;
+}
+
+let dingus: Dingus | undefined;
+
+dingus?.nested.property;
+dingus?.nested['hello'];
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
+      options: [{ allowIndexSignaturePropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  private priv_prop = 123;
+}
+
+let x: X | undefined;
+console.log(x?.['priv_prop']);
+      `,
+      options: [{ allowPrivateClassPropertyAccess: true }],
+    },
+    {
+      code: `
+class X {
+  protected priv_prop = 123;
+}
+
+let x: X | undefined;
+console.log(x?.['priv_prop']);
+      `,
+      options: [{ allowProtectedClassPropertyAccess: true }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -257,132 +385,4 @@ x.prop = 'hello';
       `,
     },
   ],
-  valid: [
-    //  baseRule
-    'a.b;',
-    'a.b.c;',
-    "a['12'];",
-    'a[b];',
-    'a[0];',
-    { code: 'a.b.c;', options: [{ allowKeywords: false }] },
-    { code: 'a.arguments;', options: [{ allowKeywords: false }] },
-    { code: 'a.let;', options: [{ allowKeywords: false }] },
-    { code: 'a.yield;', options: [{ allowKeywords: false }] },
-    { code: 'a.eval;', options: [{ allowKeywords: false }] },
-    { code: 'a[0];', options: [{ allowKeywords: false }] },
-    { code: "a['while'];", options: [{ allowKeywords: false }] },
-    { code: "a['true'];", options: [{ allowKeywords: false }] },
-    { code: "a['null'];", options: [{ allowKeywords: false }] },
-    { code: 'a[true];', options: [{ allowKeywords: false }] },
-    { code: 'a[null];', options: [{ allowKeywords: false }] },
-    { code: 'a.true;', options: [{ allowKeywords: true }] },
-    { code: 'a.null;', options: [{ allowKeywords: true }] },
-    {
-      code: "a['snake_case'];",
-      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-    },
-    {
-      code: "a['lots_of_snake_case'];",
-      options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
-    },
-    {
-      code: 'a[`time${range}`];',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: 'a[`while`];',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: [{ allowKeywords: false }],
-    },
-    {
-      code: 'a[`time range`];',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    'a.true;',
-    'a.null;',
-    'a[undefined];',
-    'a[void 0];',
-    'a[b()];',
-    {
-      code: 'a[/(?<zero>0)/];',
-      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
-    },
-
-    {
-      code: `
-class X {
-  private priv_prop = 123;
-}
-
-const x = new X();
-x['priv_prop'] = 123;
-      `,
-      options: [{ allowPrivateClassPropertyAccess: true }],
-    },
-
-    {
-      code: `
-class X {
-  protected protected_prop = 123;
-}
-
-const x = new X();
-x['protected_prop'] = 123;
-      `,
-      options: [{ allowProtectedClassPropertyAccess: true }],
-    },
-    {
-      code: `
-class X {
-  prop: string;
-  [key: string]: number;
-}
-
-const x = new X();
-x['hello'] = 3;
-      `,
-      options: [{ allowIndexSignaturePropertyAccess: true }],
-    },
-    {
-      code: `
-interface Nested {
-  property: string;
-  [key: string]: number | string;
-}
-
-class Dingus {
-  nested: Nested;
-}
-
-let dingus: Dingus | undefined;
-
-dingus?.nested.property;
-dingus?.nested['hello'];
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
-      options: [{ allowIndexSignaturePropertyAccess: true }],
-    },
-    {
-      code: `
-class X {
-  private priv_prop = 123;
-}
-
-let x: X | undefined;
-console.log(x?.['priv_prop']);
-      `,
-      options: [{ allowPrivateClassPropertyAccess: true }],
-    },
-    {
-      code: `
-class X {
-  protected priv_prop = 123;
-}
-
-let x: X | undefined;
-console.log(x?.['priv_prop']);
-      `,
-      options: [{ allowProtectedClassPropertyAccess: true }],
-    },
-  ],
 });
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 151b7e3f4c42..ab235fce3d39 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
@@ -5,264 +5,94 @@ import rule from '../../src/rules/explicit-function-return-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-function-return-type', rule, {
-  invalid: [
-    {
-      code: `
-function test(a: number, b: number) {
-  return;
-}
-      `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 14,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-    },
+  valid: [
+    'return;',
     {
       code: `
-function test() {
+function test(): void {
   return;
 }
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 14,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-var fn = function () {
+var fn = function (): number {
   return 1;
 };
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 19,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-var arrowFn = () => 'test';
+var arrowFn = (): string => 'test';
       `,
-      errors: [
-        {
-          column: 18,
-          endColumn: 20,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
 class Test {
   constructor() {}
-  get prop() {
+  get prop(): number {
     return 1;
   }
   set prop() {}
-  method() {
-    return;
-  }
-  arrow = () => 'arrow';
-  private method() {
+  method(): void {
     return;
   }
+  arrow = (): string => 'arrow';
 }
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 11,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 11,
-          endLine: 11,
-          line: 11,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 17,
-          endLine: 12,
-          line: 12,
-          messageId: 'missingReturnType',
-        },
-      ],
-    },
-    {
-      code: `
-function test() {
-  return;
-}
-      `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 14,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: 'const foo = () => {};',
-      errors: [
+      code: 'fn(() => {});',
+      options: [
         {
-          column: 16,
-          endColumn: 18,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: 'const foo = function () {};',
-      errors: [
+      code: 'fn(function () {});',
+      options: [
         {
-          column: 13,
-          endColumn: 22,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: 'export default () => {};',
-      errors: [
+      code: '[function () {}, () => {}];',
+      options: [
         {
-          column: 19,
-          endColumn: 21,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: 'export default function () {}',
-      errors: [
+      code: '(function () {});',
+      options: [
         {
-          column: 16,
-          endColumn: 25,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: `
-class Foo {
-  public a = () => {};
-  public b = function () {};
-  public c = function test() {};
-
-  static d = () => {};
-  static e = function () {};
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 14,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 23,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 27,
-          endLine: 5,
-          line: 5,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 14,
-          endLine: 7,
-          line: 7,
-          messageId: 'missingReturnType',
-        },
+      code: '(() => {})();',
+      options: [
         {
-          column: 3,
-          endColumn: 23,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowExpressions: true }],
     },
     {
-      code: "var arrowFn = () => 'test';",
-      errors: [
+      code: 'export default (): void => {};',
+      options: [
         {
-          column: 18,
-          endColumn: 20,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowExpressions: true,
         },
       ],
-      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-function foo(): any {
-  const bar = () => () => console.log('aa');
-}
+var arrowFn: Foo = () => 'test';
       `,
-      errors: [
-        {
-          column: 24,
-          endColumn: 26,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -271,129 +101,87 @@ function foo(): any {
     },
     {
       code: `
-let anyValue: any;
-function foo(): any {
-  anyValue = () => () => console.log('aa');
-}
+var funcExpr: Foo = function () {
+  return 'test';
+};
       `,
-      errors: [
-        {
-          column: 23,
-          endColumn: 25,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [
         {
           allowTypedFunctionExpressions: true,
         },
       ],
     },
+    {
+      code: 'const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: 'const x = <Foo>(() => {});',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
     {
       code: `
-class Foo {
-  foo(): any {
-    const bar = () => () => {
-      return console.log('foo');
-    };
-  }
-}
-      `,
-      errors: [
-        {
-          column: 26,
-          endColumn: 28,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowTypedFunctionExpressions: true,
-        },
-      ],
+const x = {
+  foo: () => {},
+} as Foo;
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-var funcExpr = function () {
-  return 'test';
+const x = <Foo>{
+  foo: () => {},
 };
       `,
-      errors: [
-        {
-          column: 16,
-          endColumn: 25,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowTypedFunctionExpressions: true }],
     },
-
     {
-      code: 'const x = (() => {}) as Foo;',
-      errors: [
-        {
-          column: 15,
-          endColumn: 17,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowTypedFunctionExpressions: false }],
+      code: `
+const x: Foo = {
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
     {
       code: `
-interface Foo {}
 const x = {
-  foo: () => {},
+  foo: { bar: () => {} },
 } as Foo;
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 8,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+const x = <Foo>{
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-interface Foo {}
 const x: Foo = {
-  foo: () => {},
+  foo: { bar: () => {} },
 };
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 8,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/484
+    {
+      code: `
+type MethodType = () => void;
+
+class App {
+  private method: MethodType = () => {};
+}
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/7552
     {
       code: 'const foo = <button onClick={() => {}} />;',
-      errors: [
-        {
-          column: 33,
-          endColumn: 35,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -401,19 +189,10 @@ const x: Foo = {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
-      errors: [
-        {
-          column: 27,
-          endColumn: 34,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -421,19 +200,10 @@ const x: Foo = {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
-      errors: [
-        {
-          column: 22,
-          endColumn: 24,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -441,19 +211,10 @@ const x: Foo = {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
-      errors: [
-        {
-          column: 21,
-          endColumn: 25,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -461,19 +222,10 @@ const x: Foo = {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
-      errors: [
-        {
-          column: 27,
-          endColumn: 36,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -481,162 +233,97 @@ const x: Foo = {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/525
     {
       code: `
-function foo(): any {
-  class Foo {
-    foo = () => () => {
-      return console.log('foo');
-    };
-  }
-}
+const myObj = {
+  set myProp(val) {
+    this.myProp = val;
+  },
+};
       `,
-      errors: [
-        {
-          column: 20,
-          endColumn: 22,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowTypedFunctionExpressions: true,
-        },
-      ],
     },
     {
-      code: '() => () => {};',
-      errors: [
-        {
-          column: 10,
-          endColumn: 12,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
+      code: `
+() => (): void => {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: '() => function () {};',
-      errors: [
-        {
-          column: 7,
-          endColumn: 16,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
+      code: `
+() => function (): void {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  return () => {};
+  return (): void => {};
 };
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  return function () {};
+  return function (): void {};
+};
+      `,
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: `
+() => {
+  const foo = 'foo';
+  return function (): string {
+    return foo;
+  };
 };
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 19,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return () => {};
+  return (): void => {};
 }
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return function () {};
+  return function (): void {};
 }
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 19,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
   const bar = () => (): number => 1;
-  const baz = () => () => 'baz';
   return function (): void {};
 }
       `,
-      errors: [
-        {
-          column: 24,
-          endColumn: 26,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn(arg: boolean) {
-  if (arg) return 'string';
+  if (arg) {
+    return () => (): number => 1;
+  } else {
+    return function (): string {
+      return 'foo';
+    };
+  }
+
   return function (): void {};
 }
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 12,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -648,41 +335,23 @@ function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          () =>
+          (): number =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
-      errors: [
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 9,
-          line: 9,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => () => {
-  return () => {
+  return (): void => {
     return;
   };
 };
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/679
@@ -695,138 +364,235 @@ foo(() => null);
 foo(() => true);
 foo(() => '');
       `,
-      errors: [
+      options: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      code: `
+declare function foo(arg: () => void): void;
+foo?.(() => 1);
+foo?.bar(() => {});
+foo?.bar?.(() => null);
+foo.bar?.(() => true);
+foo?.(() => '');
+      `,
+      options: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      code: `
+class Accumulator {
+  private count: number = 0;
+
+  public accumulate(fn: () => number): void {
+    this.count += fn();
+  }
+}
+
+new Accumulator().accumulate(() => 1);
+      `,
+      options: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 5,
-          line: 5,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      code: `
+declare function foo(arg: { meth: () => number }): void;
+foo({
+  meth() {
+    return 1;
+  },
+});
+foo({
+  meth: function () {
+    return 1;
+  },
+});
+foo({
+  meth: () => {
+    return 1;
+  },
+});
+      `,
+      options: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 6,
-          line: 6,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      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) => x as const;
+      `,
+      options: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 7,
-          line: 7,
-          messageId: 'missingReturnType',
+          allowDirectConstAssertionInArrowFunctions: true,
         },
       ],
+    },
+    {
+      code: `
+new Promise(resolve => {});
+new Foo(1, () => {});
+      `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
+    {
+      code: 'const log = (message: string) => void console.log(message);',
+      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
+    },
+    {
+      code: 'const log = (a: string) => a;',
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: 'const log = <A,>(a: A): A => a;',
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
     {
       code: `
-class Accumulator {
-  private count: number = 0;
-
-  public accumulate(fn: () => number): void {
-    this.count += fn();
-  }
+function log<A>(a: A): A {
+  return a;
+}
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+function log(a: string) {
+  return a;
+}
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+const log = function <A>(a: A): A {
+  return a;
+};
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+const log = function (a: A): string {
+  return a;
+};
+      `,
+      options: [{ allowFunctionsWithoutTypeParameters: true }],
+    },
+    {
+      code: `
+function test1() {
+  return;
 }
 
-new Accumulator().accumulate(() => 1);
+const foo = function test2() {
+  return;
+};
       `,
-      errors: [
+      options: [
         {
-          column: 33,
-          endColumn: 35,
-          endLine: 10,
-          line: 10,
-          messageId: 'missingReturnType',
+          allowedNames: ['test1', 'test2'],
         },
       ],
+    },
+    {
+      code: `
+const test1 = function () {
+  return;
+};
+const foo = function () {
+  return function test2() {};
+};
+      `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
+          allowedNames: ['test1', 'test2'],
         },
       ],
     },
     {
-      code: '(() => true)();',
-      errors: [
+      code: `
+const test1 = () => {
+  return;
+};
+export const foo = {
+  test2() {
+    return 0;
+  },
+};
+      `,
+      options: [
         {
-          column: 5,
-          endColumn: 7,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowedNames: ['test1', 'test2'],
         },
       ],
+    },
+    {
+      code: `
+class Test {
+  constructor() {}
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
+    return;
+  }
+  arrow = () => 'arrow';
+  private method() {
+    return;
+  }
+}
+      `,
+      options: [
+        {
+          allowedNames: ['prop', 'method', 'arrow'],
+        },
+      ],
+    },
+    {
+      code: `
+const x = {
+  arrowFn: () => {
+    return;
+  },
+  fn: function () {
+    return;
+  },
+};
+      `,
       options: [
         {
-          allowTypedFunctionExpressions: false,
+          allowedNames: ['arrowFn', 'fn'],
         },
       ],
     },
     {
       code: `
-declare function foo(arg: { meth: () => number }): void;
-foo({
-  meth() {
-    return 1;
-  },
-});
-foo({
-  meth: function () {
-    return 1;
-  },
-});
-foo({
-  meth: () => {
-    return 1;
-  },
-});
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 18,
-          endLine: 9,
-          line: 9,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 14,
-          line: 14,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [
         {
-          allowTypedFunctionExpressions: false,
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
@@ -835,182 +601,214 @@ foo({
 type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
 const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
-      errors: [
+      options: [
         {
-          column: 47,
-          endColumn: 49,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
+          allowHigherOrderFunctions: false,
+          allowTypedFunctionExpressions: true,
         },
       ],
+    },
+    {
+      code: `
+interface Foo {
+  foo: string;
+  arrowFn: () => string;
+}
+
+function foo(): Foo {
+  return {
+    foo: 'foo',
+    arrowFn: () => 'test',
+  };
+}
+      `,
       options: [
         {
           allowHigherOrderFunctions: true,
-          allowTypedFunctionExpressions: false,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
+type Foo = (arg1: string) => string;
+type Bar<T> = (arg2: string) => T;
+const x: Bar<Foo> = arg1 => arg2 => arg1 + arg2;
       `,
-      errors: [
-        {
-          column: 31,
-          endColumn: 33,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
+      options: [
         {
-          column: 39,
-          endColumn: 41,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: true,
         },
+      ],
+    },
+    {
+      code: `
+let foo = function (): number {
+  return 1;
+};
+      `,
+      options: [
         {
-          column: 47,
-          endColumn: 49,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
+          allowIIFEs: true,
         },
       ],
+    },
+    {
+      code: `
+const foo = (function () {
+  return 1;
+})();
+      `,
       options: [
         {
-          allowHigherOrderFunctions: false,
-          allowTypedFunctionExpressions: false,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-const func = (value: number) => ({ type: 'X', value }) as any;
-const func = (value: number) => ({ type: 'X', value }) as Action;
+const foo = (() => {
+  return 1;
+})();
       `,
-      errors: [
+      options: [
         {
-          column: 30,
-          endColumn: 32,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
+          allowIIFEs: true,
         },
+      ],
+    },
+    {
+      code: `
+const foo = ((arg: number): number => {
+  return arg;
+})(0);
+      `,
+      options: [
         {
-          column: 30,
-          endColumn: 32,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
+          allowIIFEs: true,
         },
       ],
+    },
+    {
+      code: `
+const foo = (() => (() => 'foo')())();
+      `,
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: true,
+          allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-const func = (value: number) => ({ type: 'X', value }) as const;
+let foo = (() => (): string => {
+  return 'foo';
+})()();
       `,
-      errors: [
+      options: [
         {
-          column: 30,
-          endColumn: 32,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
+          allowIIFEs: true,
         },
       ],
+    },
+    {
+      code: `
+let foo = (() => (): string => {
+  return 'foo';
+})();
+      `,
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: false,
+          allowHigherOrderFunctions: false,
+          allowIIFEs: true,
         },
       ],
     },
     {
-      code: 'const log = (message: string) => void console.log(message);',
-      errors: [
+      code: `
+let foo = (() => (): string => {
+  return 'foo';
+})()();
+      `,
+      options: [
         {
-          column: 31,
-          endColumn: 33,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowHigherOrderFunctions: true,
+          allowIIFEs: true,
         },
       ],
+    },
+    {
+      code: `
+let foo = (() => (): void => {})()();
+      `,
       options: [
-        { allowConciseArrowFunctionExpressionsStartingWithVoid: false },
+        {
+          allowIIFEs: true,
+        },
       ],
     },
     {
       code: `
-        const log = (message: string) => {
-          void console.log(message);
-        };
+let foo = (() => (() => {})())();
       `,
-      errors: [
+      options: [
         {
-          column: 39,
-          endColumn: 41,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
+          allowIIFEs: true,
         },
       ],
-      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
     },
     {
-      code: 'const log = <A,>(a: A) => a;',
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      code: `
+class Bar {
+  bar: Foo = {
+    foo: x => x + 1,
+  };
+}
+      `,
     },
     {
       code: `
-function log<A>(a: A) {
-  return a;
+class Bar {
+  bar: Foo[] = [
+    {
+      foo: x => x + 1,
+    },
+  ];
 }
       `,
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-const log = function <A>(a: A) {
-  return a;
-};
+type CallBack = () => void;
+
+function f(gotcha: CallBack = () => {}): void {}
       `,
-      errors: [{ messageId: 'missingReturnType' }],
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+type CallBack = () => void;
+
+const f = (gotcha: CallBack = () => {}): void => {};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+type ObjectWithCallback = { callback: () => void };
+
+const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
+  ],
+  invalid: [
     {
       code: `
-function hoge() {
-  return;
-}
-const foo = () => {
-  return;
-};
-const baz = function () {
-  return;
-};
-let [test, test] = function () {
+function test(a: number, b: number) {
   return;
-};
-class X {
-  [test] = function () {
-    return;
-  };
 }
-const x = {
-  1: function () {
-    reutrn;
-  },
-};
       `,
       errors: [
         {
@@ -1020,309 +818,296 @@ const x = {
           line: 2,
           messageId: 'missingReturnType',
         },
-        {
-          column: 16,
-          endColumn: 18,
-          endLine: 5,
-          line: 5,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 13,
-          endColumn: 22,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 20,
-          endColumn: 29,
-          endLine: 11,
-          line: 11,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 21,
-          endLine: 15,
-          line: 15,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 15,
-          endLine: 20,
-          line: 20,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowedNames: ['test', '1'],
-        },
       ],
     },
     {
       code: `
-const ignoredName = 'notIgnoredName';
-class Foo {
-  [ignoredName]() {}
+function test() {
+  return;
 }
       `,
       errors: [
         {
-          column: 3,
-          endColumn: 16,
-          endLine: 4,
-          line: 4,
+          column: 1,
+          endColumn: 14,
+          endLine: 2,
+          line: 2,
           messageId: 'missingReturnType',
         },
       ],
-      options: [{ allowedNames: ['ignoredName'] }],
     },
     {
       code: `
-class Bar {
-  bar = [
-    {
-      foo: x => x + 1,
-    },
-  ];
-}
+var fn = function () {
+  return 1;
+};
       `,
       errors: [
         {
-          column: 7,
-          endColumn: 12,
-          endLine: 5,
-          line: 5,
+          column: 10,
+          endColumn: 19,
+          endLine: 2,
+          line: 2,
           messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-const foo = (function () {
-  return 'foo';
-})();
+var arrowFn = () => 'test';
       `,
       errors: [
         {
-          column: 14,
-          endColumn: 23,
+          column: 18,
+          endColumn: 20,
           endLine: 2,
           line: 2,
           messageId: 'missingReturnType',
         },
       ],
-      options: [
-        {
-          allowIIFEs: false,
-        },
-      ],
     },
     {
       code: `
-const foo = (function () {
-  return () => {
+class Test {
+  constructor() {}
+  get prop() {
     return 1;
-  };
-})();
+  }
+  set prop() {}
+  method() {
+    return;
+  }
+  arrow = () => 'arrow';
+  private method() {
+    return;
+  }
+}
       `,
       errors: [
         {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
+          column: 3,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
           messageId: 'missingReturnType',
         },
-      ],
-      options: [
         {
-          allowIIFEs: true,
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 17,
+          endLine: 12,
+          line: 12,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-let foo = function () {
-  return 'foo';
-};
+function test() {
+  return;
+}
       `,
       errors: [
         {
-          column: 11,
-          endColumn: 20,
+          column: 1,
+          endColumn: 14,
           endLine: 2,
           line: 2,
           messageId: 'missingReturnType',
         },
       ],
-      options: [
+      options: [{ allowExpressions: true }],
+    },
+    {
+      code: 'const foo = () => {};',
+      errors: [
         {
-          allowIIFEs: true,
+          column: 16,
+          endColumn: 18,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: `
-let foo = (() => () => {})()();
-      `,
+      code: 'const foo = function () {};',
       errors: [
         {
-          column: 21,
-          endColumn: 23,
-          endLine: 2,
-          line: 2,
+          column: 13,
+          endColumn: 22,
+          endLine: 1,
+          line: 1,
           messageId: 'missingReturnType',
         },
       ],
-      options: [
+      options: [{ allowExpressions: true }],
+    },
+    {
+      code: 'export default () => {};',
+      errors: [
         {
-          allowIIFEs: true,
+          column: 19,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: `
-type CallBack = () => void;
-
-function f(gotcha: CallBack = () => {}): void {}
-      `,
+      code: 'export default function () {}',
       errors: [
         {
-          column: 34,
-          endColumn: 36,
-          endLine: 4,
-          line: 4,
+          column: 16,
+          endColumn: 25,
+          endLine: 1,
+          line: 1,
           messageId: 'missingReturnType',
         },
       ],
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowExpressions: true }],
     },
     {
       code: `
-type CallBack = () => void;
+class Foo {
+  public a = () => {};
+  public b = function () {};
+  public c = function test() {};
 
-const f = (gotcha: CallBack = () => {}): void => {};
+  static d = () => {};
+  static e = function () {};
+}
       `,
       errors: [
         {
-          column: 34,
-          endColumn: 36,
-          endLine: 4,
-          line: 4,
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 27,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 8,
+          line: 8,
           messageId: 'missingReturnType',
         },
       ],
-      options: [{ allowTypedFunctionExpressions: false }],
+      options: [{ allowExpressions: true }],
     },
     {
-      code: `
-type ObjectWithCallback = { callback: () => void };
-
-const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
-      `,
+      code: "var arrowFn = () => 'test';",
       errors: [
         {
-          column: 43,
-          line: 4,
+          column: 18,
+          endColumn: 20,
+          endLine: 1,
+          line: 1,
           messageId: 'missingReturnType',
         },
       ],
-      options: [{ allowTypedFunctionExpressions: false }],
-    },
-  ],
-
-  valid: [
-    'return;',
-    {
-      code: `
-function test(): void {
-  return;
-}
-      `,
-    },
-    {
-      code: `
-var fn = function (): number {
-  return 1;
-};
-      `,
-    },
-    {
-      code: `
-var arrowFn = (): string => 'test';
-      `,
+      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-class Test {
-  constructor() {}
-  get prop(): number {
-    return 1;
-  }
-  set prop() {}
-  method(): void {
-    return;
-  }
-  arrow = (): string => 'arrow';
+function foo(): any {
+  const bar = () => () => console.log('aa');
 }
       `,
-    },
-    {
-      code: 'fn(() => {});',
-      options: [
-        {
-          allowExpressions: true,
-        },
-      ],
-    },
-    {
-      code: 'fn(function () {});',
-      options: [
+      errors: [
         {
-          allowExpressions: true,
+          column: 24,
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: '[function () {}, () => {}];',
       options: [
         {
-          allowExpressions: true,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
-      code: '(function () {});',
-      options: [
+      code: `
+let anyValue: any;
+function foo(): any {
+  anyValue = () => () => console.log('aa');
+}
+      `,
+      errors: [
         {
-          allowExpressions: true,
+          column: 23,
+          endColumn: 25,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: '(() => {})();',
       options: [
         {
-          allowExpressions: true,
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
-      code: 'export default (): void => {};',
-      options: [
+      code: `
+class Foo {
+  foo(): any {
+    const bar = () => () => {
+      return console.log('foo');
+    };
+  }
+}
+      `,
+      errors: [
         {
-          allowExpressions: true,
+          column: 26,
+          endColumn: 28,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-var arrowFn: Foo = () => 'test';
-      `,
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -1331,87 +1116,82 @@ var arrowFn: Foo = () => 'test';
     },
     {
       code: `
-var funcExpr: Foo = function () {
+var funcExpr = function () {
   return 'test';
 };
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 16,
+          endColumn: 25,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: 'const x = (() => {}) as Foo;',
       options: [{ allowTypedFunctionExpressions: true }],
     },
+
     {
-      code: 'const x = <Foo>(() => {});',
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: 'const x = (() => {}) as Foo;',
+      errors: [
+        {
+          column: 15,
+          endColumn: 17,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
+interface Foo {}
 const x = {
   foo: () => {},
 } as Foo;
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-const x = <Foo>{
-  foo: () => {},
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
+interface Foo {}
 const x: Foo = {
   foo: () => {},
 };
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
-    {
-      code: `
-const x = {
-  foo: { bar: () => {} },
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-const x = <Foo>{
-  foo: { bar: () => {} },
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-const x: Foo = {
-  foo: { bar: () => {} },
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/484
-    {
-      code: `
-type MethodType = () => void;
-
-class App {
-  private method: MethodType = () => {};
-}
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/7552
     {
       code: 'const foo = <button onClick={() => {}} />;',
+      errors: [
+        {
+          column: 33,
+          endColumn: 35,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1419,10 +1199,19 @@ class App {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: true }],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
+      errors: [
+        {
+          column: 27,
+          endColumn: 34,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1430,10 +1219,19 @@ class App {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: true }],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
+      errors: [
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1441,10 +1239,19 @@ class App {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: true }],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
+      errors: [
+        {
+          column: 21,
+          endColumn: 25,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1452,10 +1259,19 @@ class App {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: true }],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
+      errors: [
+        {
+          column: 27,
+          endColumn: 36,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1463,97 +1279,162 @@ class App {
           },
         },
       },
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/525
-    {
-      code: `
-const myObj = {
-  set myProp(val) {
-    this.myProp = val;
-  },
-};
-      `,
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
-() => (): void => {};
+function foo(): any {
+  class Foo {
+    foo = () => () => {
+      return console.log('foo');
+    };
+  }
+}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 20,
+          endColumn: 22,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowTypedFunctionExpressions: true,
+        },
+      ],
     },
     {
-      code: `
-() => function (): void {};
-      `,
+      code: '() => () => {};',
+      errors: [
+        {
+          column: 10,
+          endColumn: 12,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: `
-() => {
-  return (): void => {};
-};
-      `,
+      code: '() => function () {};',
+      errors: [
+        {
+          column: 7,
+          endColumn: 16,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  return function (): void {};
+  return () => {};
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => {
-  const foo = 'foo';
-  return function (): string {
-    return foo;
-  };
+  return function () {};
 };
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return (): void => {};
+  return () => {};
 }
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
-  return function (): void {};
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn() {
   const bar = () => (): number => 1;
+  const baz = () => () => 'baz';
   return function (): void {};
 }
       `,
+      errors: [
+        {
+          column: 24,
+          endColumn: 26,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 function fn(arg: boolean) {
-  if (arg) {
-    return () => (): number => 1;
-  } else {
-    return function (): string {
-      return 'foo';
-    };
-  }
-
+  if (arg) return 'string';
   return function (): void {};
 }
       `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 12,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -1565,23 +1446,41 @@ function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number =>
+          () =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 () => () => {
-  return (): void => {
+  return () => {
     return;
   };
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/679
@@ -1594,42 +1493,90 @@ foo(() => null);
 foo(() => true);
 foo(() => '');
       `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
       code: `
-declare function foo(arg: () => void): void;
-foo?.(() => 1);
-foo?.bar(() => {});
-foo?.bar?.(() => null);
-foo.bar?.(() => true);
-foo?.(() => '');
+class Accumulator {
+  private count: number = 0;
+
+  public accumulate(fn: () => number): void {
+    this.count += fn();
+  }
+}
+
+new Accumulator().accumulate(() => 1);
       `,
+      errors: [
+        {
+          column: 33,
+          endColumn: 35,
+          endLine: 10,
+          line: 10,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
+        },
+      ],
+    },
+    {
+      code: '(() => true)();',
+      errors: [
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-class Accumulator {
-  private count: number = 0;
-
-  public accumulate(fn: () => number): void {
-    this.count += fn();
-  }
-}
-
-new Accumulator().accumulate(() => 1);
-      `,
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
@@ -1652,290 +1599,343 @@ foo({
   },
 });
       `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 18,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 14,
+          line: 14,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
       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) => x as const;
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
+      errors: [
+        {
+          column: 47,
+          endColumn: 49,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowDirectConstAssertionInArrowFunctions: true,
+          allowHigherOrderFunctions: true,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
       code: `
-new Promise(resolve => {});
-new Foo(1, () => {});
+type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
+const x: HigherOrderType = () => arg1 => arg2 => 'foo';
       `,
+      errors: [
+        {
+          column: 31,
+          endColumn: 33,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 39,
+          endColumn: 41,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 47,
+          endColumn: 49,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [
         {
-          allowTypedFunctionExpressions: true,
+          allowHigherOrderFunctions: false,
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
     {
-      code: 'const log = (message: string) => void console.log(message);',
-      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
+      code: `
+const func = (value: number) => ({ type: 'X', value }) as any;
+const func = (value: number) => ({ type: 'X', value }) as Action;
+      `,
+      errors: [
+        {
+          column: 30,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 30,
+          endColumn: 32,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowDirectConstAssertionInArrowFunctions: true,
+        },
+      ],
     },
     {
-      code: 'const log = (a: string) => a;',
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      code: `
+const func = (value: number) => ({ type: 'X', value }) as const;
+      `,
+      errors: [
+        {
+          column: 30,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowDirectConstAssertionInArrowFunctions: false,
+        },
+      ],
     },
     {
-      code: 'const log = <A,>(a: A): A => a;',
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      code: 'const log = (message: string) => void console.log(message);',
+      errors: [
+        {
+          column: 31,
+          endColumn: 33,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        { allowConciseArrowFunctionExpressionsStartingWithVoid: false },
+      ],
     },
     {
       code: `
-function log<A>(a: A): A {
-  return a;
-}
+        const log = (message: string) => {
+          void console.log(message);
+        };
       `,
-      options: [{ allowFunctionsWithoutTypeParameters: true }],
+      errors: [
+        {
+          column: 39,
+          endColumn: 41,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }],
     },
     {
-      code: `
-function log(a: string) {
-  return a;
-}
-      `,
+      code: 'const log = <A,>(a: A) => a;',
+      errors: [{ messageId: 'missingReturnType' }],
       options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-const log = function <A>(a: A): A {
+function log<A>(a: A) {
   return a;
-};
+}
       `,
+      errors: [{ messageId: 'missingReturnType' }],
       options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-const log = function (a: A): string {
+const log = function <A>(a: A) {
   return a;
 };
       `,
+      errors: [{ messageId: 'missingReturnType' }],
       options: [{ allowFunctionsWithoutTypeParameters: true }],
     },
     {
       code: `
-function test1() {
+function hoge() {
   return;
 }
-
-const foo = function test2() {
+const foo = () => {
   return;
 };
-      `,
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-    },
-    {
-      code: `
-const test1 = function () {
+const baz = function () {
   return;
 };
-const foo = function () {
-  return function test2() {};
-};
-      `,
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-    },
-    {
-      code: `
-const test1 = () => {
+let [test, test] = function () {
   return;
 };
-export const foo = {
-  test2() {
-    return 0;
-  },
-};
-      `,
-      options: [
-        {
-          allowedNames: ['test1', 'test2'],
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  constructor() {}
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  arrow = () => 'arrow';
-  private method() {
-    return;
-  }
-}
-      `,
-      options: [
-        {
-          allowedNames: ['prop', 'method', 'arrow'],
-        },
-      ],
-    },
-    {
-      code: `
-const x = {
-  arrowFn: () => {
-    return;
-  },
-  fn: function () {
+class X {
+  [test] = function () {
     return;
+  };
+}
+const x = {
+  1: function () {
+    reutrn;
   },
 };
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['arrowFn', 'fn'],
+          column: 1,
+          endColumn: 14,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
-      `,
-      options: [
         {
-          allowHigherOrderFunctions: true,
-          allowTypedFunctionExpressions: true,
+          column: 16,
+          endColumn: 18,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-type HigherOrderType = () => (arg1: string) => (arg2: number) => string;
-const x: HigherOrderType = () => arg1 => arg2 => 'foo';
-      `,
-      options: [
         {
-          allowHigherOrderFunctions: false,
-          allowTypedFunctionExpressions: true,
+          column: 13,
+          endColumn: 22,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
         },
-      ],
-    },
-    {
-      code: `
-interface Foo {
-  foo: string;
-  arrowFn: () => string;
-}
-
-function foo(): Foo {
-  return {
-    foo: 'foo',
-    arrowFn: () => 'test',
-  };
-}
-      `,
-      options: [
         {
-          allowHigherOrderFunctions: true,
-          allowTypedFunctionExpressions: true,
+          column: 20,
+          endColumn: 29,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 21,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 15,
+          endLine: 20,
+          line: 20,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-type Foo = (arg1: string) => string;
-type Bar<T> = (arg2: string) => T;
-const x: Bar<Foo> = arg1 => arg2 => arg1 + arg2;
-      `,
       options: [
         {
-          allowHigherOrderFunctions: true,
-          allowTypedFunctionExpressions: true,
+          allowedNames: ['test', '1'],
         },
       ],
     },
     {
       code: `
-let foo = function (): number {
-  return 1;
-};
+const ignoredName = 'notIgnoredName';
+class Foo {
+  [ignoredName]() {}
+}
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 3,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
         },
       ],
+      options: [{ allowedNames: ['ignoredName'] }],
     },
     {
       code: `
-const foo = (function () {
-  return 1;
-})();
+class Bar {
+  bar = [
+    {
+      foo: x => x + 1,
+    },
+  ];
+}
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 7,
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-const foo = (() => {
-  return 1;
+const foo = (function () {
+  return 'foo';
 })();
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 14,
+          endColumn: 23,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-const foo = ((arg: number): number => {
-  return arg;
-})(0);
-      `,
       options: [
         {
-          allowIIFEs: true,
+          allowIIFEs: false,
         },
       ],
     },
     {
       code: `
-const foo = (() => (() => 'foo')())();
+const foo = (function () {
+  return () => {
+    return 1;
+  };
+})();
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-let foo = (() => (): string => {
-  return 'foo';
-})()();
-      `,
       options: [
         {
           allowIIFEs: true,
@@ -1944,44 +1944,38 @@ let foo = (() => (): string => {
     },
     {
       code: `
-let foo = (() => (): string => {
+let foo = function () {
   return 'foo';
-})();
+};
       `,
-      options: [
+      errors: [
         {
-          allowHigherOrderFunctions: false,
-          allowIIFEs: true,
+          column: 11,
+          endColumn: 20,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-let foo = (() => (): string => {
-  return 'foo';
-})()();
-      `,
       options: [
         {
-          allowHigherOrderFunctions: true,
           allowIIFEs: true,
         },
       ],
     },
     {
       code: `
-let foo = (() => (): void => {})()();
+let foo = (() => () => {})()();
       `,
-      options: [
+      errors: [
         {
-          allowIIFEs: true,
+          column: 21,
+          endColumn: 23,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
-    },
-    {
-      code: `
-let foo = (() => (() => {})())();
-      `,
       options: [
         {
           allowIIFEs: true,
@@ -1990,31 +1984,20 @@ let foo = (() => (() => {})())();
     },
     {
       code: `
-class Bar {
-  bar: Foo = {
-    foo: x => x + 1,
-  };
-}
-      `,
-    },
-    {
-      code: `
-class Bar {
-  bar: Foo[] = [
-    {
-      foo: x => x + 1,
-    },
-  ];
-}
-      `,
-    },
-    {
-      code: `
 type CallBack = () => void;
 
 function f(gotcha: CallBack = () => {}): void {}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 34,
+          endColumn: 36,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
@@ -2022,7 +2005,16 @@ type CallBack = () => void;
 
 const f = (gotcha: CallBack = () => {}): void => {};
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 34,
+          endColumn: 36,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
@@ -2030,7 +2022,14 @@ type ObjectWithCallback = { callback: () => void };
 
 const f = (gotcha: ObjectWithCallback = { callback: () => {} }): void => {};
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 43,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
   ],
 });
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 d02c8ea8c7ea..133ce5671e21 100644
--- a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
@@ -5,162 +5,71 @@ import rule from '../../src/rules/explicit-member-accessibility';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-member-accessibility', rule, {
-  invalid: [
+  valid: [
     {
       code: `
-export class XXXX {
-  public constructor(readonly value: string) {}
+class Test {
+  public constructor(private foo: string) {}
 }
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 36,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(public readonly value: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(private readonly value: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(protected readonly value: string) {}
-}
-      `,
-            },
-          ],
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'explicit' },
         },
       ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(private readonly foo: string) {}
+}
+      `,
       options: [
         {
-          accessibility: 'off',
-          overrides: {
-            parameterProperties: 'explicit',
-          },
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'explicit' },
         },
       ],
-      output: null,
     },
     {
       code: `
-export class WithParameterProperty {
-  public constructor(readonly value: string) {}
+class Test {
+  public constructor(private foo: string) {}
 }
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 36,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class WithParameterProperty {
-  public constructor(public readonly value: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class WithParameterProperty {
-  public constructor(private readonly value: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class WithParameterProperty {
-  public constructor(protected readonly value: string) {}
-}
-      `,
-            },
-          ],
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
         },
       ],
-      options: [{ accessibility: 'explicit' }],
-      output: null,
     },
     {
       code: `
-export class XXXX {
-  public constructor(readonly samosa: string) {}
+class Test {
+  public constructor(protected foo: string) {}
 }
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 37,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(public readonly samosa: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(private readonly samosa: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-export class XXXX {
-  public constructor(protected readonly samosa: string) {}
-}
-      `,
-            },
-          ],
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
         },
       ],
+    },
+    {
+      code: `
+class Test {
+  public constructor(public foo: string) {}
+}
+      `,
       options: [
         {
-          accessibility: 'off',
-          overrides: {
-            constructors: 'explicit',
-            parameterProperties: 'explicit',
-          },
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
         },
       ],
-      output: null,
     },
     {
       code: `
@@ -168,258 +77,269 @@ class Test {
   public constructor(readonly foo: string) {}
 }
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 34,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  public constructor(public readonly foo: string) {}
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      code: `
 class Test {
   public constructor(private readonly foo: string) {}
 }
       `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  public constructor(protected readonly foo: string) {}
-}
-      `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
+          overrides: { parameterProperties: 'off' },
         },
       ],
-      output: null,
     },
     {
       code: `
 class Test {
-  x: number;
+  protected name: string;
+  private x: number;
   public getX() {
     return this.x;
   }
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'x',
-            type: 'class property',
-          },
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-
-              output: `
+    },
+    {
+      code: `
 class Test {
-  public x: number;
-  public getX() {
-    return this.x;
-  }
+  protected name: string;
+  protected foo?: string;
+  public 'foo-bar'?: string;
 }
       `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-
-              output: `
+    },
+    {
+      code: `
 class Test {
-  private x: number;
+  public constructor({ x, y }: { x: number; y: number }) {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  protected name: string;
+  protected foo?: string;
   public getX() {
     return this.x;
   }
 }
       `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-
-              output: `
+      options: [{ accessibility: 'explicit' }],
+    },
+    {
+      code: `
 class Test {
-  protected x: number;
-  public getX() {
+  protected name: string;
+  protected foo?: string;
+  getX() {
     return this.x;
   }
 }
       `,
-            },
-          ],
-        },
-      ],
-      output: null,
+      options: [{ accessibility: 'no-public' }],
     },
     {
       code: `
 class Test {
-  private x: number;
+  name: string;
+  foo?: string;
   getX() {
     return this.x;
   }
+  get fooName(): string {
+    return this.foo + ' ' + this.name;
+  }
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'getX',
-            type: 'method definition',
-          },
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
 class Test {
   private x: number;
-  public getX() {
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
     return this.x;
   }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
+  public square(): number {
+    return this.x * this.x;
+  }
 }
       `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ overrides: { accessors: 'off', constructors: 'off' } }],
+    },
+    {
+      code: `
 class Test {
   private x: number;
-  private getX() {
+  public constructor(x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
     return this.x;
   }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
+  public square(): number {
+    return this.x * this.x;
+  }
+  half(): number {
+    return this.x / 2;
+  }
 }
       `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ overrides: { methods: 'off' } }],
+    },
+    {
+      code: `
 class Test {
-  private x: number;
-  protected getX() {
-    return this.x;
-  }
+  constructor(private x: number) {}
 }
       `,
-            },
-          ],
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  constructor(public x: number) {}
+}
+      `,
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'off' },
         },
       ],
-      output: null,
     },
     {
       code: `
 class Test {
-  x?: number;
-  getX?() {
+  constructor(public foo: number) {}
+}
+      `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      code: `
+class Test {
+  public getX() {
     return this.x;
   }
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'x',
-            type: 'class property',
-          },
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
 class Test {
-  public x?: number;
-  getX?() {
+  public static getX() {
     return this.x;
   }
 }
       `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
 class Test {
-  private x?: number;
-  getX?() {
+  get getX() {
     return this.x;
   }
 }
       `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
 class Test {
-  protected x?: number;
-  getX?() {
+  getX() {
     return this.x;
   }
 }
       `,
-            },
-          ],
-        },
+      options: [{ ignoredMethodNames: ['getX'] }],
+    },
+    {
+      code: `
+class Test {
+  x = 2;
+}
+      `,
+      options: [{ overrides: { properties: 'off' } }],
+    },
+    {
+      code: `
+class Test {
+  private x = 2;
+}
+      `,
+      options: [{ overrides: { properties: 'explicit' } }],
+    },
+    {
+      code: `
+class Test {
+  x = 2;
+  private x = 2;
+}
+      `,
+      options: [{ overrides: { properties: 'no-public' } }],
+    },
+    {
+      code: `
+class Test {
+  constructor(private { x }: any[]) {}
+}
+      `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    // private members
+    {
+      code: `
+class Test {
+  #foo = 1;
+  #bar() {}
+}
+      `,
+      options: [{ accessibility: 'explicit' }],
+    },
+  ],
+  invalid: [
+    {
+      code: `
+export class XXXX {
+  public constructor(readonly value: string) {}
+}
+      `,
+      errors: [
         {
-          column: 3,
-          data: {
-            name: 'getX',
-            type: 'method definition',
-          },
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
+          column: 22,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
           messageId: 'missingAccessibility',
           suggestions: [
             {
               data: { type: 'public' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  x?: number;
-  public getX?() {
-    return this.x;
-  }
+export class XXXX {
+  public constructor(public readonly value: string) {}
 }
       `,
             },
@@ -427,11 +347,8 @@ class Test {
               data: { type: 'private' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  x?: number;
-  private getX?() {
-    return this.x;
-  }
+export class XXXX {
+  public constructor(private readonly value: string) {}
 }
       `,
             },
@@ -439,160 +356,91 @@ class Test {
               data: { type: 'protected' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  x?: number;
-  protected getX?() {
-    return this.x;
-  }
+export class XXXX {
+  public constructor(protected readonly value: string) {}
 }
       `,
             },
           ],
         },
       ],
-      output: null,
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  public getX() {
-    return this.x;
-  }
-}
-      `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'getX',
-            type: 'method definition',
+          accessibility: 'off',
+          overrides: {
+            parameterProperties: 'explicit',
           },
-          endColumn: 9,
-          endLine: 5,
-          line: 5,
-          messageId: 'unwantedPublicAccessibility',
         },
       ],
-      options: [{ accessibility: 'no-public' }],
-      output: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  getX() {
-    return this.x;
-  }
-}
-      `,
+      output: null,
     },
     {
       code: `
-class Test {
-  protected name: string;
-  public foo?: string;
-  getX() {
-    return this.x;
-  }
+export class WithParameterProperty {
+  public constructor(readonly value: string) {}
 }
       `,
       errors: [
         {
-          column: 3,
-          data: {
-            name: 'foo',
-            type: 'class property',
-          },
-          endColumn: 9,
-          endLine: 4,
-          line: 4,
-          messageId: 'unwantedPublicAccessibility',
-        },
-      ],
-      options: [{ accessibility: 'no-public' }],
-      output: `
-class Test {
-  protected name: string;
-  foo?: string;
-  getX() {
-    return this.x;
-  }
+          column: 22,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(public readonly value: string) {}
 }
       `,
-    },
-    {
-      code: `
-class Test {
-  public x: number;
-  public getX() {
-    return this.x;
-  }
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(private readonly value: string) {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 3,
-          line: 3,
-          messageId: 'unwantedPublicAccessibility',
-        },
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 4,
-          line: 4,
-          messageId: 'unwantedPublicAccessibility',
-        },
-      ],
-      options: [{ accessibility: 'no-public' }],
-      output: `
-class Test {
-  x: number;
-  getX() {
-    return this.x;
-  }
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+export class WithParameterProperty {
+  public constructor(protected readonly value: string) {}
 }
       `,
+            },
+          ],
+        },
+      ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
     },
     {
       code: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+export class XXXX {
+  public constructor(readonly samosa: string) {}
 }
       `,
       errors: [
         {
-          column: 3,
-          endColumn: 20,
-          endLine: 7,
-          line: 7,
+          column: 22,
+          endColumn: 37,
+          endLine: 3,
+          line: 3,
           messageId: 'missingAccessibility',
           suggestions: [
             {
               data: { type: 'public' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+export class XXXX {
+  public constructor(public readonly samosa: string) {}
 }
       `,
             },
@@ -600,17 +448,8 @@ class Test {
               data: { type: 'private' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  private get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+export class XXXX {
+  public constructor(private readonly samosa: string) {}
 }
       `,
             },
@@ -618,27 +457,37 @@ class Test {
               data: { type: 'protected' },
               messageId: 'addExplicitAccessibility',
               output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  protected get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
+export class XXXX {
+  public constructor(protected readonly samosa: string) {}
 }
       `,
             },
           ],
         },
+      ],
+      options: [
         {
-          column: 3,
-          endColumn: 20,
-          endLine: 10,
-          line: 10,
+          accessibility: 'off',
+          overrides: {
+            constructors: 'explicit',
+            parameterProperties: 'explicit',
+          },
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+class Test {
+  public constructor(readonly foo: string) {}
+}
+      `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 34,
+          endLine: 3,
+          line: 3,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -646,16 +495,7 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
+  public constructor(public readonly foo: string) {}
 }
       `,
             },
@@ -664,16 +504,7 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  private set internalValue(value: number) {
-    this.x = value;
-  }
+  public constructor(private readonly foo: string) {}
 }
       `,
             },
@@ -682,172 +513,105 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
-    return this.x;
-  }
-  protected set internalValue(value: number) {
-    this.x = value;
-  }
+  public constructor(protected readonly foo: string) {}
 }
       `,
             },
           ],
         },
       ],
-      options: [{ overrides: { constructors: 'no-public' } }],
+      options: [
+        {
+          accessibility: 'explicit',
+          overrides: { parameterProperties: 'explicit' },
+        },
+      ],
       output: null,
     },
     {
       code: `
 class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  x: number;
+  public getX() {
     return this.x;
   }
-  set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
       errors: [
         {
           column: 3,
-          endColumn: 14,
-          endLine: 4,
-          line: 4,
+          data: {
+            name: 'x',
+            type: 'class property',
+          },
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
           messageId: 'missingAccessibility',
           suggestions: [
             {
               data: { type: 'public' },
               messageId: 'addExplicitAccessibility',
+
               output: `
 class Test {
-  private x: number;
-  public constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  public x: number;
+  public getX() {
     return this.x;
   }
-  set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
             {
               data: { type: 'private' },
               messageId: 'addExplicitAccessibility',
+
               output: `
 class Test {
   private x: number;
-  private constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  public getX() {
     return this.x;
   }
-  set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
             {
               data: { type: 'protected' },
               messageId: 'addExplicitAccessibility',
+
               output: `
 class Test {
-  private x: number;
-  protected constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  protected x: number;
+  public getX() {
     return this.x;
   }
-  set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
           ],
         },
-        {
-          column: 3,
-          endColumn: 20,
-          endLine: 7,
-          line: 7,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  private get internalValue() {
-    return this.x;
-  }
-  set internalValue(value: number) {
-    this.x = value;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+      ],
+      output: null,
+    },
+    {
+      code: `
 class Test {
   private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  protected get internalValue() {
+  getX() {
     return this.x;
   }
-  set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
-            },
-          ],
-        },
+      errors: [
         {
           column: 3,
-          endColumn: 20,
-          endLine: 10,
-          line: 10,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -856,15 +620,9 @@ class Test {
               output: `
 class Test {
   private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  public getX() {
     return this.x;
   }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
@@ -874,15 +632,9 @@ class Test {
               output: `
 class Test {
   private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  private getX() {
     return this.x;
   }
-  private set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
@@ -892,15 +644,9 @@ class Test {
               output: `
 class Test {
   private x: number;
-  constructor(x: number) {
-    this.x = x;
-  }
-  get internalValue() {
+  protected getX() {
     return this.x;
   }
-  protected set internalValue(value: number) {
-    this.x = value;
-  }
 }
       `,
             },
@@ -912,16 +658,20 @@ class Test {
     {
       code: `
 class Test {
-  constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
+  x?: number;
+  getX?() {
+    return this.x;
   }
 }
       `,
       errors: [
         {
           column: 3,
-          endColumn: 14,
+          data: {
+            name: 'x',
+            type: 'class property',
+          },
+          endColumn: 4,
           endLine: 3,
           line: 3,
           messageId: 'missingAccessibility',
@@ -931,9 +681,9 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
+  public x?: number;
+  getX?() {
+    return this.x;
   }
 }
       `,
@@ -943,9 +693,9 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
+  private x?: number;
+  getX?() {
+    return this.x;
   }
 }
       `,
@@ -955,35 +705,24 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  protected constructor(public x: number) {}
-  public foo(): string {
-    return 'foo';
+  protected x?: number;
+  getX?() {
+    return this.x;
   }
 }
       `,
             },
           ],
         },
-      ],
-      options: [
-        {
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
-      output: null,
-    },
-    {
-      code: `
-class Test {
-  constructor(public x: number) {}
-}
-      `,
-      errors: [
         {
           column: 3,
-          endColumn: 14,
-          endLine: 3,
-          line: 3,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 7,
+          endLine: 4,
+          line: 4,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -991,7 +730,10 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(public x: number) {}
+  x?: number;
+  public getX?() {
+    return this.x;
+  }
 }
       `,
             },
@@ -1000,7 +742,10 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private constructor(public x: number) {}
+  x?: number;
+  private getX?() {
+    return this.x;
+  }
 }
       `,
             },
@@ -1009,7 +754,10 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  protected constructor(public x: number) {}
+  x?: number;
+  protected getX?() {
+    return this.x;
+  }
 }
       `,
             },
@@ -1021,87 +769,78 @@ class Test {
     {
       code: `
 class Test {
-  constructor(public readonly x: number) {}
+  protected name: string;
+  protected foo?: string;
+  public getX() {
+    return this.x;
+  }
 }
       `,
       errors: [
         {
-          column: 15,
-          endColumn: 21,
-          endLine: 3,
-          line: 3,
+          column: 3,
+          data: {
+            name: 'getX',
+            type: 'method definition',
+          },
+          endColumn: 9,
+          endLine: 5,
+          line: 5,
           messageId: 'unwantedPublicAccessibility',
         },
       ],
-      options: [
-        {
-          accessibility: 'off',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
+      options: [{ accessibility: 'no-public' }],
       output: `
 class Test {
-  constructor(readonly x: number) {}
+  protected name: string;
+  protected foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
     },
     {
       code: `
 class Test {
-  x = 2;
+  protected name: string;
+  public foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
       errors: [
         {
           column: 3,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  public x = 2;
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class Test {
-  private x = 2;
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
+          data: {
+            name: 'foo',
+            type: 'class property',
+          },
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [{ accessibility: 'no-public' }],
+      output: `
 class Test {
-  protected x = 2;
+  protected name: string;
+  foo?: string;
+  getX() {
+    return this.x;
+  }
 }
       `,
-            },
-          ],
-        },
-      ],
-      options: [
-        {
-          accessibility: 'off',
-          overrides: { properties: 'explicit' },
-        },
-      ],
-      output: null,
     },
     {
       code: `
 class Test {
-  public x = 2;
-  private x = 2;
+  public x: number;
+  public getX() {
+    return this.x;
+  }
 }
       `,
       errors: [
@@ -1112,32 +851,45 @@ class Test {
           line: 3,
           messageId: 'unwantedPublicAccessibility',
         },
-      ],
-      options: [
         {
-          accessibility: 'off',
-          overrides: { properties: 'no-public' },
+          column: 3,
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
         },
       ],
+      options: [{ accessibility: 'no-public' }],
       output: `
 class Test {
-  x = 2;
-  private x = 2;
+  x: number;
+  getX() {
+    return this.x;
+  }
 }
       `,
     },
     {
       code: `
 class Test {
-  constructor(public x: any[]) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
       errors: [
         {
           column: 3,
-          endColumn: 14,
-          endLine: 3,
-          line: 3,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -1145,7 +897,16 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  public constructor(public x: any[]) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
@@ -1154,7 +915,16 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  private constructor(public x: any[]) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  private get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
@@ -1163,96 +933,640 @@ class Test {
               messageId: 'addExplicitAccessibility',
               output: `
 class Test {
-  protected constructor(public x: any[]) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  protected get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
             },
           ],
         },
-      ],
-      options: [{ accessibility: 'explicit' }],
-      output: null,
-    },
-    {
-      code: noFormat`
-class Test {
-  public /*public*/constructor(private foo: string) {}
-}
-      `,
-      errors: [
         {
           column: 3,
-          endColumn: 9,
-          endLine: 3,
-          line: 3,
-          messageId: 'unwantedPublicAccessibility',
-        },
-      ],
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
-      output: `
+          endColumn: 20,
+          endLine: 10,
+          line: 10,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  /*public*/constructor(private foo: string) {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
-    },
-    {
-      code: `
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  @public
-  public foo() {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 4,
-          line: 4,
-          messageId: 'unwantedPublicAccessibility',
-        },
-      ],
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
-      output: `
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  @public
-  foo() {}
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  protected set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
+            },
+          ],
+        },
+      ],
+      options: [{ overrides: { constructors: 'no-public' } }],
+      output: null,
     },
     {
       code: `
 class Test {
-  @public
-  public foo;
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
 }
       `,
       errors: [
         {
           column: 3,
-          endColumn: 9,
+          endColumn: 14,
           endLine: 4,
           line: 4,
-          messageId: 'unwantedPublicAccessibility',
-        },
-      ],
-      options: [
-        {
-          accessibility: 'no-public',
-        },
-      ],
-      output: `
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
 class Test {
-  @public
-  foo;
-}
+  private x: number;
+  public constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  private constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  protected constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 3,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  private get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  protected get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 3,
+          endColumn: 20,
+          endLine: 10,
+          line: 10,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x: number;
+  constructor(x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  protected set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+class Test {
+  constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
+  }
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
+  }
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  protected constructor(public x: number) {}
+  public foo(): string {
+    return 'foo';
+  }
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [
+        {
+          overrides: { parameterProperties: 'no-public' },
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+class Test {
+  constructor(public x: number) {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(public x: number) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private constructor(public x: number) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  protected constructor(public x: number) {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+class Test {
+  constructor(public readonly x: number) {}
+}
+      `,
+      errors: [
+        {
+          column: 15,
+          endColumn: 21,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { parameterProperties: 'no-public' },
+        },
+      ],
+      output: `
+class Test {
+  constructor(readonly x: number) {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  x = 2;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public x = 2;
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private x = 2;
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  protected x = 2;
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { properties: 'explicit' },
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+class Test {
+  public x = 2;
+  private x = 2;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'off',
+          overrides: { properties: 'no-public' },
+        },
+      ],
+      output: `
+class Test {
+  x = 2;
+  private x = 2;
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  constructor(public x: any[]) {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  public constructor(public x: any[]) {}
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  private constructor(public x: any[]) {}
+}
+      `,
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class Test {
+  protected constructor(public x: any[]) {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ accessibility: 'explicit' }],
+      output: null,
+    },
+    {
+      code: noFormat`
+class Test {
+  public /*public*/constructor(private foo: string) {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 3,
+          line: 3,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+      output: `
+class Test {
+  /*public*/constructor(private foo: string) {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  @public
+  public foo() {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+      output: `
+class Test {
+  @public
+  foo() {}
+}
+      `,
+    },
+    {
+      code: `
+class Test {
+  @public
+  public foo;
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 4,
+          line: 4,
+          messageId: 'unwantedPublicAccessibility',
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+      output: `
+class Test {
+  @public
+  foo;
+}
       `,
     },
     {
@@ -1676,152 +1990,8 @@ class DecoratedClass {
               messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  protected constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-          ],
-        },
-        {
-          column: 27,
-          endColumn: 39,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() public readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() private readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() protected readonly arg: string) {}
-  @foo @bar() x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-          ],
-        },
-        {
-          column: 15,
-          endColumn: 16,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingAccessibility',
-          suggestions: [
-            {
-              data: { type: 'public' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() public x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() private x: string;
-  @foo @bar() getX() {
-    return this.x;
-  }
-  @foo
-  @bar()
-  get y() {
-    return this.x;
-  }
-  @foo @bar() set z(@foo @bar() value: x) {
-    this.x = x;
-  }
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() protected x: string;
+  protected constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
   @foo @bar() getX() {
     return this.x;
   }
@@ -1839,10 +2009,10 @@ class DecoratedClass {
           ],
         },
         {
-          column: 15,
-          endColumn: 19,
-          endLine: 5,
-          line: 5,
+          column: 27,
+          endColumn: 39,
+          endLine: 3,
+          line: 3,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -1850,9 +2020,9 @@ class DecoratedClass {
               messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
+  constructor(@foo @bar() public readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() public getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -1871,9 +2041,9 @@ class DecoratedClass {
               messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
+  constructor(@foo @bar() private readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() private getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -1892,9 +2062,9 @@ class DecoratedClass {
               messageId: 'addExplicitAccessibility',
               output: `
 class DecoratedClass {
-  constructor(@foo @bar() readonly arg: string) {}
+  constructor(@foo @bar() protected readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() protected getX() {
+  @foo @bar() getX() {
     return this.x;
   }
   @foo
@@ -1911,10 +2081,10 @@ class DecoratedClass {
           ],
         },
         {
-          column: 3,
-          endColumn: 8,
-          endLine: 10,
-          line: 10,
+          column: 15,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -1923,13 +2093,13 @@ class DecoratedClass {
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
+  @foo @bar() public x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  public get y() {
+  get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -1944,13 +2114,13 @@ class DecoratedClass {
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
+  @foo @bar() private x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  private get y() {
+  get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -1965,13 +2135,13 @@ class DecoratedClass {
               output: `
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
-  @foo @bar() x: string;
+  @foo @bar() protected x: string;
   @foo @bar() getX() {
     return this.x;
   }
   @foo
   @bar()
-  protected get y() {
+  get y() {
     return this.x;
   }
   @foo @bar() set z(@foo @bar() value: x) {
@@ -1984,9 +2154,9 @@ class DecoratedClass {
         },
         {
           column: 15,
-          endColumn: 20,
-          endLine: 13,
-          line: 13,
+          endColumn: 19,
+          endLine: 5,
+          line: 5,
           messageId: 'missingAccessibility',
           suggestions: [
             {
@@ -1996,7 +2166,7 @@ class DecoratedClass {
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() getX() {
+  @foo @bar() public getX() {
     return this.x;
   }
   @foo
@@ -2004,7 +2174,7 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() public set z(@foo @bar() value: x) {
+  @foo @bar() set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
@@ -2017,7 +2187,7 @@ class DecoratedClass {
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() getX() {
+  @foo @bar() private getX() {
     return this.x;
   }
   @foo
@@ -2025,7 +2195,7 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() private set z(@foo @bar() value: x) {
+  @foo @bar() set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
@@ -2038,7 +2208,7 @@ class DecoratedClass {
 class DecoratedClass {
   constructor(@foo @bar() readonly arg: string) {}
   @foo @bar() x: string;
-  @foo @bar() getX() {
+  @foo @bar() protected getX() {
     return this.x;
   }
   @foo
@@ -2046,7 +2216,7 @@ class DecoratedClass {
   get y() {
     return this.x;
   }
-  @foo @bar() protected set z(@foo @bar() value: x) {
+  @foo @bar() set z(@foo @bar() value: x) {
     this.x = x;
   }
 }
@@ -2054,369 +2224,199 @@ class DecoratedClass {
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      code: `
-abstract class SomeClass {
-  abstract ['computed-method-name'](): string;
-}
-      `,
-      errors: [
         {
           column: 3,
-          endColumn: 36,
-          endLine: 3,
-          line: 3,
+          endColumn: 8,
+          endLine: 10,
+          line: 10,
           messageId: 'missingAccessibility',
           suggestions: [
             {
               data: { type: 'public' },
               messageId: 'addExplicitAccessibility',
               output: `
-abstract class SomeClass {
-  public abstract ['computed-method-name'](): string;
-}
-      `,
-            },
-            {
-              data: { type: 'private' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-abstract class SomeClass {
-  private abstract ['computed-method-name'](): string;
-}
-      `,
-            },
-            {
-              data: { type: 'protected' },
-              messageId: 'addExplicitAccessibility',
-              output: `
-abstract class SomeClass {
-  protected abstract ['computed-method-name'](): string;
-}
-      `,
-            },
-          ],
-        },
-      ],
-      options: [{ accessibility: 'explicit' }],
-      output: null,
-    },
-  ],
-  valid: [
-    {
-      code: `
-class Test {
-  public constructor(private foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(private readonly foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'explicit' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(private foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(protected foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(public foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(readonly foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  public constructor(private readonly foo: string) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'explicit',
-          overrides: { parameterProperties: 'off' },
-        },
-      ],
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  private x: number;
-  public getX() {
-    return this.x;
-  }
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  public 'foo-bar'?: string;
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  public constructor({ x, y }: { x: number; y: number }) {}
-}
-      `,
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  public getX() {
-    return this.x;
-  }
-}
-      `,
-      options: [{ accessibility: 'explicit' }],
-    },
-    {
-      code: `
-class Test {
-  protected name: string;
-  protected foo?: string;
-  getX() {
-    return this.x;
-  }
-}
-      `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
-class Test {
-  name: string;
-  foo?: string;
-  getX() {
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
     return this.x;
   }
-  get fooName(): string {
-    return this.foo + ' ' + this.name;
+  @foo
+  @bar()
+  public get y() {
+    return this.x;
   }
-}
-      `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
-class Test {
-  private x: number;
-  constructor(x: number) {
+  @foo @bar() set z(@foo @bar() value: x) {
     this.x = x;
   }
-  get internalValue() {
+}
+      `,
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
     return this.x;
   }
-  private set internalValue(value: number) {
-    this.x = value;
+  @foo
+  @bar()
+  private get y() {
+    return this.x;
   }
-  public square(): number {
-    return this.x * this.x;
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
   }
 }
       `,
-      options: [{ overrides: { accessors: 'off', constructors: 'off' } }],
-    },
-    {
-      code: `
-class Test {
-  private x: number;
-  public constructor(x: number) {
-    this.x = x;
-  }
-  public get internalValue() {
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
     return this.x;
   }
-  public set internalValue(value: number) {
-    this.x = value;
-  }
-  public square(): number {
-    return this.x * this.x;
+  @foo
+  @bar()
+  protected get y() {
+    return this.x;
   }
-  half(): number {
-    return this.x / 2;
+  @foo @bar() set z(@foo @bar() value: x) {
+    this.x = x;
   }
 }
       `,
-      options: [{ overrides: { methods: 'off' } }],
-    },
-    {
-      code: `
-class Test {
-  constructor(private x: number) {}
-}
-      `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
-class Test {
-  constructor(public x: number) {}
-}
-      `,
-      options: [
-        {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'off' },
+            },
+          ],
         },
-      ],
-    },
-    {
-      code: `
-class Test {
-  constructor(public foo: number) {}
-}
-      `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    {
-      code: `
-class Test {
-  public getX() {
+        {
+          column: 15,
+          endColumn: 20,
+          endLine: 13,
+          line: 13,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
     return this.x;
   }
-}
-      `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
-class Test {
-  public static getX() {
+  @foo
+  @bar()
+  get y() {
     return this.x;
   }
+  @foo @bar() public set z(@foo @bar() value: x) {
+    this.x = x;
+  }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
-class Test {
-  get getX() {
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
     return this.x;
   }
-}
-      `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
-class Test {
-  getX() {
+  @foo
+  @bar()
+  get y() {
     return this.x;
   }
+  @foo @bar() private set z(@foo @bar() value: x) {
+    this.x = x;
+  }
 }
       `,
-      options: [{ ignoredMethodNames: ['getX'] }],
-    },
-    {
-      code: `
-class Test {
-  x = 2;
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+class DecoratedClass {
+  constructor(@foo @bar() readonly arg: string) {}
+  @foo @bar() x: string;
+  @foo @bar() getX() {
+    return this.x;
+  }
+  @foo
+  @bar()
+  get y() {
+    return this.x;
+  }
+  @foo @bar() protected set z(@foo @bar() value: x) {
+    this.x = x;
+  }
 }
       `,
-      options: [{ overrides: { properties: 'off' } }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-class Test {
-  private x = 2;
+abstract class SomeClass {
+  abstract ['computed-method-name'](): string;
 }
       `,
-      options: [{ overrides: { properties: 'explicit' } }],
-    },
-    {
-      code: `
-class Test {
-  x = 2;
-  private x = 2;
+      errors: [
+        {
+          column: 3,
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingAccessibility',
+          suggestions: [
+            {
+              data: { type: 'public' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+abstract class SomeClass {
+  public abstract ['computed-method-name'](): string;
 }
       `,
-      options: [{ overrides: { properties: 'no-public' } }],
-    },
-    {
-      code: `
-class Test {
-  constructor(private { x }: any[]) {}
+            },
+            {
+              data: { type: 'private' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+abstract class SomeClass {
+  private abstract ['computed-method-name'](): string;
 }
       `,
-      options: [{ accessibility: 'no-public' }],
-    },
-    // private members
-    {
-      code: `
-class Test {
-  #foo = 1;
-  #bar() {}
+            },
+            {
+              data: { type: 'protected' },
+              messageId: 'addExplicitAccessibility',
+              output: `
+abstract class SomeClass {
+  protected abstract ['computed-method-name'](): string;
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [{ accessibility: 'explicit' }],
+      output: null,
     },
   ],
 });
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 35be0f278525..e03e7fe71c86 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
@@ -5,349 +5,283 @@ import rule from '../../src/rules/explicit-module-boundary-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-module-boundary-types', rule, {
-  invalid: [
+  valid: [
     {
       code: `
-export function test(a: number, b: number) {
+function test(): void {
   return;
 }
       `,
-      errors: [
-        {
-          column: 8,
-          endColumn: 21,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-export function test() {
+export function test(): void {
   return;
 }
       `,
-      errors: [
-        {
-          column: 8,
-          endColumn: 21,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-export var fn = function () {
+export var fn = function (): number {
   return 1;
 };
       `,
-      errors: [
-        {
-          column: 17,
-          endColumn: 26,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-export var arrowFn = () => 'test';
+export var arrowFn = (): string => 'test';
       `,
-      errors: [
-        {
-          column: 25,
-          endColumn: 27,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
+      // not exported
       code: `
-export class Test {
-  constructor() {}
-  get prop() {
+class Test {
+  constructor(one) {}
+  get prop(one) {
     return 1;
   }
-  set prop(value) {}
-  method() {
+  set prop(one) {}
+  method(one) {
     return;
   }
-  arrow = arg => 'arrow';
-  private method() {
+  arrow = one => 'arrow';
+  abstract abs(one);
+}
+      `,
+    },
+    {
+      code: `
+export class Test {
+  constructor(one: string) {}
+  get prop(one: string): void {
+    return 1;
+  }
+  set prop(one: string): void {}
+  method(one: string): void {
     return;
   }
-  abstract abs(arg);
+  arrow = (one: string): string => 'arrow';
+  abstract abs(one: string): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 11,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 12,
-          data: {
-            name: 'value',
-          },
-          endColumn: 17,
-          endLine: 7,
-          line: 7,
-          messageId: 'missingArgType',
-        },
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 11,
-          endLine: 11,
-          line: 11,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 11,
-          data: {
-            name: 'arg',
-          },
-          endColumn: 14,
-          endLine: 11,
-          line: 11,
-          messageId: 'missingArgType',
-        },
-        {
-          column: 15,
-          endColumn: 21,
-          endLine: 15,
-          line: 15,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 16,
-          data: {
-            name: 'arg',
-          },
-          endColumn: 19,
-          endLine: 15,
-          line: 15,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-export class Foo {
-  public a = () => {};
-  public b = function () {};
-  public c = function test() {};
-
-  static d = () => {};
-  static e = function () {};
+export class Test {
+  private constructor(one) {}
+  private get prop(one) {
+    return 1;
+  }
+  private set prop(one) {}
+  private method(one) {
+    return;
+  }
+  private arrow = one => 'arrow';
+  private abstract abs(one);
 }
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 14,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 23,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 27,
-          endLine: 5,
-          line: 5,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 14,
-          endLine: 7,
-          line: 7,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 23,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
+    `
+export class PrivateProperty {
+  #property = () => null;
+}
+    `,
+    `
+export class PrivateMethod {
+  #method() {}
+}
+    `,
     {
-      code: 'export default () => (true ? () => {} : (): void => {});',
-      errors: [
-        {
-          column: 19,
-          endColumn: 21,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/2150
+      code: `
+export class Test {
+  constructor();
+  constructor(value?: string) {
+    console.log(value);
+  }
+}
+      `,
     },
     {
-      code: "export var arrowFn = () => 'test';",
-      errors: [
-        {
-          column: 25,
-          endColumn: 27,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: `
+declare class MyClass {
+  constructor(options?: MyClass.Options);
+}
+export { MyClass };
+      `,
     },
     {
       code: `
-export var funcExpr = function () {
-  return 'test';
-};
+export function test(): void {
+  nested();
+  return;
+
+  function nested() {}
+}
       `,
-      errors: [
-        {
-          column: 23,
-          endColumn: 32,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
-interface Foo {}
-export const x: Foo = {
-  foo: () => {},
-};
+export function test(): string {
+  const nested = () => 'value';
+  return nested();
+}
       `,
-      errors: [
+    },
+    {
+      code: `
+export function test(): string {
+  class Nested {
+    public method() {
+      return 'value';
+    }
+  }
+  return new Nested().method();
+}
+      `,
+    },
+    {
+      code: `
+export var arrowFn: Foo = () => 'test';
+      `,
+      options: [
         {
-          column: 3,
-          endColumn: 8,
-          endLine: 4,
-          line: 4,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
       ],
-      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
-      code: 'export default () => () => {};',
-      errors: [
+      code: `
+export var funcExpr: Foo = function () {
+  return 'test';
+};
+      `,
+      options: [
         {
-          column: 25,
-          endColumn: 27,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
       ],
+    },
+    {
+      code: 'const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: 'const x = <Foo>(() => {});',
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x = {
+  foo: () => {},
+} as Foo;
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x = <Foo>{
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x: Foo = {
+  foo: () => {},
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
+    {
+      code: `
+export const x = {
+  foo: { bar: () => {} },
+} as Foo;
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x = <Foo>{
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    {
+      code: `
+export const x: Foo = {
+  foo: { bar: () => {} },
+};
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/484
+    {
+      code: `
+type MethodType = () => void;
+
+export class App {
+  public method: MethodType = () => {};
+}
+      `,
+      options: [{ allowTypedFunctionExpressions: true }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/525
+    {
+      code: `
+export const myObj = {
+  set myProp(val: number) {
+    this.myProp = val;
+  },
+};
+      `,
+    },
+    {
+      code: `
+export default () => (): void => {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: 'export default () => function () {};',
-      errors: [
-        {
-          column: 22,
-          endColumn: 31,
-          endLine: 1,
-          line: 1,
-          messageId: 'missingReturnType',
-        },
-      ],
+      code: `
+export default () => function (): void {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return () => {};
+  return (): void => {};
 };
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return function () {};
+  return function (): void {};
 };
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 19,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return () => {};
+  return (): void => {};
 }
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return function () {};
+  return function (): void {};
 }
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 19,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -359,1114 +293,820 @@ export function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          () =>
+          (): number =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
-      errors: [
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 9,
-          line: 9,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => () => {
-  return () => {
+  return (): void => {
     return;
   };
 };
       `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export const func1 = (value: number) => ({ type: 'X', value }) as any;
-export const func2 = (value: number) => ({ type: 'X', value }) as Action;
+export default () => () => {
+  const foo = 'foo';
+  return (): void => {
+    return;
+  };
+};
       `,
-      errors: [
-        {
-          column: 38,
-          endColumn: 40,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 38,
-          endColumn: 40,
-          endLine: 3,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowDirectConstAssertionInArrowFunctions: true,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export const func = (value: number) => ({ type: 'X', value }) as const;
+export default () => () => {
+  const foo = () => (): string => 'foo';
+  return (): void => {
+    return;
+  };
+};
       `,
-      errors: [
-        {
-          column: 37,
-          endColumn: 39,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowDirectConstAssertionInArrowFunctions: false,
-        },
-      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export class Test {
-  constructor() {}
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
+export class Accumulator {
+  private count: number = 0;
+
+  public accumulate(fn: () => number): void {
+    this.count += fn();
   }
-  arrow = (): string => 'arrow';
-  foo = () => 'bar';
 }
+
+new Accumulator().accumulate(() => 1);
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 8,
-          line: 8,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 9,
-          endLine: 12,
-          line: 12,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [
         {
-          allowedNames: ['prop'],
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-export class Test {
-  constructor(
-    public foo,
-    private ...bar,
-  ) {}
-}
+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;
       `,
-      errors: [
-        {
-          column: 12,
-          data: {
-            name: 'foo',
-          },
-          line: 4,
-          messageId: 'missingArgType',
-        },
+      options: [
         {
-          column: 5,
-          data: {
-            name: 'bar',
-          },
-          line: 5,
-          messageId: 'missingArgType',
+          allowDirectConstAssertionInArrowFunctions: true,
         },
       ],
     },
     {
       code: `
-export const func1 = (value: number) => value;
-export const func2 = (value: number) => value;
+export const func1 = (value: string) => value;
+export const func2 = (value: number) => ({ type: 'X', value });
       `,
-      errors: [
-        {
-          column: 38,
-          endColumn: 40,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [
         {
-          allowedNames: ['func2'],
+          allowedNames: ['func1', 'func2'],
         },
       ],
     },
     {
       code: `
-export function fn(test): string {
-  return '123';
+export function func1() {
+  return 0;
 }
+export const foo = {
+  func2() {
+    return 0;
+  },
+};
       `,
-      errors: [
+      options: [
         {
-          column: 20,
-          data: {
-            name: 'test',
-          },
-          endColumn: 24,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingArgType',
+          allowedNames: ['func1', 'func2'],
         },
       ],
     },
     {
       code: `
-export const fn = (one: number, two): string => '123';
+export class Test {
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
+    return;
+  }
+  // prettier-ignore
+  'method'() {}
+  ['prop']() {}
+  [\`prop\`]() {}
+  [\`\${v}\`](): void {}
+
+  foo = () => {
+    bar: 5;
+  };
+}
       `,
-      errors: [
+      options: [
         {
-          column: 33,
-          data: {
-            name: 'two',
-          },
-          endColumn: 36,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingArgType',
+          allowedNames: ['prop', 'method', 'foo'],
         },
       ],
     },
     {
       code: `
-export function foo(outer) {
-  return function (inner) {};
-}
+        export function foo(outer: string) {
+          return function (inner: string): void {};
+        }
       `,
-      errors: [
-        {
-          data: {
-            name: 'outer',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'inner',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
-      options: [{ allowHigherOrderFunctions: true }],
-    },
-    {
-      code: 'export const baz = arg => arg as const;',
-      errors: [
+      options: [
         {
-          data: {
-            name: 'arg',
-          },
-          line: 1,
-          messageId: 'missingArgType',
+          allowHigherOrderFunctions: true,
         },
       ],
-      options: [{ allowDirectConstAssertionInArrowFunctions: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1552
     {
       code: `
-const foo = arg => arg;
-export default foo;
+        export type Ensurer = (blocks: TFBlock[]) => TFBlock[];
+
+        export const myEnsurer: Ensurer = blocks => {
+          return blocks;
+        };
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
+      options: [
         {
-          line: 2,
-          messageId: 'missingReturnType',
+          allowTypedFunctionExpressions: true,
         },
       ],
     },
     {
       code: `
-const foo = arg => arg;
-export = foo;
+export const Foo: FC = () => (
+  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
+);
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 2,
-          messageId: 'missingReturnType',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
         },
-      ],
+      },
     },
     {
       code: `
-let foo = (arg: number): number => arg;
-foo = arg => arg;
-export default foo;
+export const Foo: JSX.Element = (
+  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
+);
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 3,
-          messageId: 'missingReturnType',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
         },
-      ],
+      },
     },
     {
       code: `
-const foo = arg => arg;
-export default [foo];
+const test = (): void => {
+  return;
+};
+export default test;
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-const foo = arg => arg;
-export default { foo };
+function test(): void {
+  return;
+}
+export default test;
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
-}
-export default foo;
+const test = (): void => {
+  return;
+};
+export default [test];
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
+function test(): void {
+  return;
 }
-export default [foo];
+export default [test];
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-function foo(arg) {
-  return arg;
-}
-export default { foo };
+const test = (): void => {
+  return;
+};
+export default { test };
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-const bar = function foo(arg) {
-  return arg;
-};
-export default { bar };
+function test(): void {
+  return;
+}
+export default { test };
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-class Foo {
-  bool(arg) {
-    return arg;
-  }
-}
-export default Foo;
+const foo = (arg => arg) as Foo;
+export default foo;
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-class Foo {
-  bool = arg => {
-    return arg;
-  };
-}
-export default Foo;
+let foo = (arg => arg) as Foo;
+foo = 3;
+export default foo;
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
 class Foo {
-  bool = function (arg) {
-    return arg;
-  };
+  bar = (arg: string): string => arg;
 }
-export default Foo;
+export default { Foo };
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
 class Foo {
-  bool = function (arg) {
-    return arg;
-  };
+  bar(): void {
+    return;
+  }
 }
-export default [Foo];
+export default { Foo };
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
     },
     {
       code: `
-let test = arg => argl;
-test = (): void => {
-  return;
-};
-export default test;
+export function foo(): (n: number) => string {
+  return n => String(n);
+}
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-let test = arg => argl;
-test = (): void => {
-  return;
+export const foo = (a: string): ((n: number) => string) => {
+  return function (n) {
+    return String(n);
+  };
 };
-export { test };
       `,
-      errors: [
-        {
-          data: {
-            name: 'arg',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
     },
     {
       code: `
-export const foo =
-  () =>
-  (a: string): ((n: number) => string) => {
-    return function (n) {
-      return String(n);
-    };
-  };
+export function a(): void {
+  function b() {}
+  const x = () => {};
+  (function () {});
+
+  function c() {
+    return () => {};
+  }
+
+  return;
+}
       `,
-      errors: [
-        {
-          column: 6,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowHigherOrderFunctions: false }],
     },
     {
       code: `
-export var arrowFn = () => () => {};
-      `,
-      errors: [
-        {
-          column: 31,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowHigherOrderFunctions: true }],
+export function a(): void {
+  function b() {
+    function c() {}
+  }
+  const x = () => {
+    return () => 100;
+  };
+  (function () {
+    (function () {});
+  });
+
+  function c() {
+    return () => {
+      (function () {});
+    };
+  }
+
+  return;
+}
+      `,
     },
     {
       code: `
-export function fn() {
-  return function () {};
+export function a() {
+  return function b(): () => void {
+    return function c() {};
+  };
 }
       `,
-      errors: [
-        {
-          column: 10,
-          line: 3,
-          messageId: 'missingReturnType',
-        },
-      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function foo(outer) {
-  return function (inner): void {};
-}
+export var arrowFn = () => (): void => {};
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            name: 'outer',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-        {
-          column: 20,
-          data: {
-            name: 'inner',
-          },
-          line: 3,
-          messageId: 'missingArgType',
-        },
-      ],
-      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function foo(outer: boolean) {
-  if (outer) {
-    return 'string';
-  }
-  return function (inner): void {};
+export function fn() {
+  return function (): void {};
 }
       `,
-      errors: [
-        {
-          column: 8,
-          data: {
-            name: 'inner',
-          },
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [{ allowHigherOrderFunctions: true }],
     },
-    // test a few different argument patterns
     {
       code: `
-export function foo({ foo }): void {}
+export function foo(outer: string) {
+  return function (inner: string): void {};
+}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            type: 'Object pattern',
-          },
-          line: 2,
-          messageId: 'missingArgTypeUnnamed',
-        },
-      ],
     },
+    // shouldn't check functions that aren't directly exported - https://github.com/typescript-eslint/typescript-eslint/issues/2134
+    `
+export function foo(): unknown {
+  return new Proxy(apiInstance, {
+    get: (target, property) => {
+      // implementation
+    },
+  });
+}
+    `,
     {
-      code: `
-export function foo([bar]): void {}
-      `,
-      errors: [
+      code: 'export default (() => true)();',
+      options: [
         {
-          column: 21,
-          data: {
-            type: 'Array pattern',
-          },
-          line: 2,
-          messageId: 'missingArgTypeUnnamed',
+          allowTypedFunctionExpressions: false,
         },
       ],
     },
+    // explicit assertions are allowed
     {
-      code: `
-export function foo(...bar): void {}
-      `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            name: 'bar',
-          },
-          line: 2,
-          messageId: 'missingArgType',
-        },
-      ],
+      code: 'export const x = (() => {}) as Foo;',
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
       code: `
-export function foo(...[a]): void {}
+interface Foo {}
+export const x = {
+  foo: () => {},
+} as Foo;
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            type: 'Rest',
-          },
-          line: 2,
-          messageId: 'missingArgTypeUnnamed',
-        },
-      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     // allowArgumentsExplicitlyTypedAsAny
     {
       code: `
 export function foo(foo: any): void {}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            name: 'foo',
-          },
-          line: 2,
-          messageId: 'anyTypedArg',
-        },
-      ],
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo({ foo }: any): void {}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            type: 'Object pattern',
-          },
-          line: 2,
-          messageId: 'anyTypedArgUnnamed',
-        },
-      ],
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo([bar]: any): void {}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            type: 'Array pattern',
-          },
-          line: 2,
-          messageId: 'anyTypedArgUnnamed',
-        },
-      ],
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo(...bar: any): void {}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            name: 'bar',
-          },
-          line: 2,
-          messageId: 'anyTypedArg',
-        },
-      ],
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
     {
       code: `
 export function foo(...[a]: any): void {}
       `,
-      errors: [
-        {
-          column: 21,
-          data: {
-            type: 'Rest',
-          },
-          line: 2,
-          messageId: 'anyTypedArgUnnamed',
-        },
-      ],
-      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
-    },
-    {
-      code: `
-export function func1() {
-  return 0;
-}
-export const foo = {
-  func2() {
-    return 0;
-  },
-};
-      `,
-      errors: [
-        {
-          column: 8,
-          endColumn: 22,
-          endLine: 2,
-          line: 2,
-          messageId: 'missingReturnType',
-        },
-        {
-          column: 3,
-          endColumn: 8,
-          endLine: 6,
-          line: 6,
-          messageId: 'missingReturnType',
-        },
-      ],
-      options: [
-        {
-          allowedNames: [],
-        },
-      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
     },
-  ],
-  valid: [
+    // assignment patterns are ignored
+    `
+export function foo(arg = 1): void {}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2161
     {
       code: `
-function test(): void {
-  return;
-}
+export const foo = (): ((n: number) => string) => n => String(n);
       `,
     },
-    {
-      code: `
-export function test(): void {
-  return;
-}
-      `,
-    },
-    {
-      code: `
-export var fn = function (): number {
-  return 1;
-};
-      `,
-    },
-    {
-      code: `
-export var arrowFn = (): string => 'test';
-      `,
-    },
-    {
-      // not exported
-      code: `
-class Test {
-  constructor(one) {}
-  get prop(one) {
-    return 1;
-  }
-  set prop(one) {}
-  method(one) {
-    return;
-  }
-  arrow = one => 'arrow';
-  abstract abs(one);
-}
-      `,
-    },
-    {
-      code: `
-export class Test {
-  constructor(one: string) {}
-  get prop(one: string): void {
-    return 1;
-  }
-  set prop(one: string): void {}
-  method(one: string): void {
-    return;
-  }
-  arrow = (one: string): string => 'arrow';
-  abstract abs(one: string): void;
-}
-      `,
-    },
-    {
-      code: `
-export class Test {
-  private constructor(one) {}
-  private get prop(one) {
-    return 1;
-  }
-  private set prop(one) {}
-  private method(one) {
-    return;
-  }
-  private arrow = one => 'arrow';
-  private abstract abs(one);
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2173
+    `
+export function foo(): (n: number) => (m: number) => string {
+  return function (n) {
+    return function (m) {
+      return String(n + m);
+    };
+  };
 }
-      `,
-    },
+    `,
     `
-export class PrivateProperty {
-  #property = () => null;
+export const foo = (): ((n: number) => (m: number) => string) => n => m =>
+  String(n + m);
+    `,
+    `
+export const bar: () => (n: number) => string = () => n => String(n);
+    `,
+    `
+type Buz = () => (n: number) => string;
+
+export const buz: Buz = () => n => String(n);
+    `,
+    `
+export abstract class Foo<T> {
+  abstract set value(element: T);
 }
     `,
     `
-export class PrivateMethod {
-  #method() {}
+export declare class Foo {
+  set time(seconds: number);
 }
     `,
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/2150
-      code: `
-export class Test {
-  constructor();
-  constructor(value?: string) {
-    console.log(value);
-  }
+    `
+export class A {
+  b = A;
 }
-      `,
-    },
-    {
-      code: `
-declare class MyClass {
-  constructor(options?: MyClass.Options);
+    `,
+    `
+interface Foo {
+  f: (x: boolean) => boolean;
 }
-export { MyClass };
-      `,
-    },
-    {
-      code: `
-export function test(): void {
-  nested();
-  return;
 
-  function nested() {}
+export const a: Foo[] = [
+  {
+    f: (x: boolean) => x,
+  },
+];
+    `,
+    `
+interface Foo {
+  f: (x: boolean) => boolean;
 }
-      `,
-    },
+
+export const a: Foo = {
+  f: (x: boolean) => x,
+};
+    `,
+  ],
+  invalid: [
     {
       code: `
-export function test(): string {
-  const nested = () => 'value';
-  return nested();
+export function test(a: number, b: number) {
+  return;
 }
       `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 21,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export function test(): string {
-  class Nested {
-    public method() {
-      return 'value';
-    }
-  }
-  return new Nested().method();
+export function test() {
+  return;
 }
       `,
-    },
-    {
-      code: `
-export var arrowFn: Foo = () => 'test';
-      `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 8,
+          endColumn: 21,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-export var funcExpr: Foo = function () {
-  return 'test';
+export var fn = function () {
+  return 1;
 };
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 17,
+          endColumn: 26,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
     },
-    {
-      code: 'const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: 'const x = <Foo>(() => {});',
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
     {
       code: `
-export const x = {
-  foo: () => {},
-} as Foo;
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
-    },
-    {
-      code: `
-export const x = <Foo>{
-  foo: () => {},
-};
+export var arrowFn = () => 'test';
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 25,
+          endColumn: 27,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export const x: Foo = {
-  foo: () => {},
-};
+export class Test {
+  constructor() {}
+  get prop() {
+    return 1;
+  }
+  set prop(value) {}
+  method() {
+    return;
+  }
+  arrow = arg => 'arrow';
+  private method() {
+    return;
+  }
+  abstract abs(arg);
+}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 12,
+          data: {
+            name: 'value',
+          },
+          endColumn: 17,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 11,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 11,
+          data: {
+            name: 'arg',
+          },
+          endColumn: 14,
+          endLine: 11,
+          line: 11,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 15,
+          endColumn: 21,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 16,
+          data: {
+            name: 'arg',
+          },
+          endColumn: 19,
+          endLine: 15,
+          line: 15,
+          messageId: 'missingArgType',
+        },
+      ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2864
     {
       code: `
-export const x = {
-  foo: { bar: () => {} },
-} as Foo;
+export class Foo {
+  public a = () => {};
+  public b = function () {};
+  public c = function test() {};
+
+  static d = () => {};
+  static e = function () {};
+}
       `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 27,
+          endLine: 5,
+          line: 5,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 23,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
-      code: `
-export const x = <Foo>{
-  foo: { bar: () => {} },
-};
-      `,
-      options: [{ allowTypedFunctionExpressions: true }],
+      code: 'export default () => (true ? () => {} : (): void => {});',
+      errors: [
+        {
+          column: 19,
+          endColumn: 21,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
-      code: `
-export const x: Foo = {
-  foo: { bar: () => {} },
-};
-      `,
+      code: "export var arrowFn = () => 'test';",
+      errors: [
+        {
+          column: 25,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowTypedFunctionExpressions: true }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/484
     {
       code: `
-type MethodType = () => void;
-
-export class App {
-  public method: MethodType = () => {};
-}
+export var funcExpr = function () {
+  return 'test';
+};
       `,
+      errors: [
+        {
+          column: 23,
+          endColumn: 32,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowTypedFunctionExpressions: true }],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/525
     {
       code: `
-export const myObj = {
-  set myProp(val: number) {
-    this.myProp = val;
-  },
+interface Foo {}
+export const x: Foo = {
+  foo: () => {},
 };
       `,
+      errors: [
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 4,
+          line: 4,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowTypedFunctionExpressions: false }],
     },
     {
-      code: `
-export default () => (): void => {};
-      `,
+      code: 'export default () => () => {};',
+      errors: [
+        {
+          column: 25,
+          endColumn: 27,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
-      code: `
-export default () => function (): void {};
-      `,
+      code: 'export default () => function () {};',
+      errors: [
+        {
+          column: 22,
+          endColumn: 31,
+          endLine: 1,
+          line: 1,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return (): void => {};
+  return () => {};
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => {
-  return function (): void {};
+  return function () {};
 };
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return (): void => {};
+  return () => {};
 }
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export function fn() {
-  return function (): void {};
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -1478,475 +1118,835 @@ export function FunctionDeclaration() {
         // ArrowFunctionExpression_Within_FunctionExpression
         return () =>
           // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number =>
+          () =>
             1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
       };
     };
   };
 }
       `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 9,
+          line: 9,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
 export default () => () => {
-  return (): void => {
+  return () => {
     return;
   };
 };
       `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => () => {
-  const foo = 'foo';
-  return (): void => {
+export const func1 = (value: number) => ({ type: 'X', value }) as any;
+export const func2 = (value: number) => ({ type: 'X', value }) as Action;
+      `,
+      errors: [
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 3,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowDirectConstAssertionInArrowFunctions: true,
+        },
+      ],
+    },
+    {
+      code: `
+export const func = (value: number) => ({ type: 'X', value }) as const;
+      `,
+      errors: [
+        {
+          column: 37,
+          endColumn: 39,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowDirectConstAssertionInArrowFunctions: false,
+        },
+      ],
+    },
+    {
+      code: `
+export class Test {
+  constructor() {}
+  get prop() {
+    return 1;
+  }
+  set prop() {}
+  method() {
     return;
-  };
-};
+  }
+  arrow = (): string => 'arrow';
+  foo = () => 'bar';
+}
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 8,
+          line: 8,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 9,
+          endLine: 12,
+          line: 12,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowedNames: ['prop'],
+        },
+      ],
+    },
+    {
+      code: `
+export class Test {
+  constructor(
+    public foo,
+    private ...bar,
+  ) {}
+}
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            name: 'foo',
+          },
+          line: 4,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 5,
+          data: {
+            name: 'bar',
+          },
+          line: 5,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-export default () => () => {
-  const foo = () => (): string => 'foo';
-  return (): void => {
-    return;
-  };
-};
+export const func1 = (value: number) => value;
+export const func2 = (value: number) => value;
       `,
-      options: [{ allowHigherOrderFunctions: true }],
+      errors: [
+        {
+          column: 38,
+          endColumn: 40,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowedNames: ['func2'],
+        },
+      ],
     },
     {
       code: `
-export class Accumulator {
-  private count: number = 0;
-
-  public accumulate(fn: () => number): void {
-    this.count += fn();
-  }
+export function fn(test): string {
+  return '123';
 }
-
-new Accumulator().accumulate(() => 1);
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          column: 20,
+          data: {
+            name: 'test',
+          },
+          endColumn: 24,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingArgType',
         },
       ],
     },
     {
       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 func4 = (value: number) => x as const;
+export const fn = (one: number, two): string => '123';
       `,
-      options: [
+      errors: [
         {
-          allowDirectConstAssertionInArrowFunctions: true,
+          column: 33,
+          data: {
+            name: 'two',
+          },
+          endColumn: 36,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingArgType',
         },
       ],
     },
     {
       code: `
-export const func1 = (value: string) => value;
-export const func2 = (value: number) => ({ type: 'X', value });
+export function foo(outer) {
+  return function (inner) {};
+}
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['func1', 'func2'],
+          data: {
+            name: 'outer',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'inner',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
+    },
+    {
+      code: 'export const baz = arg => arg as const;',
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 1,
+          messageId: 'missingArgType',
         },
       ],
+      options: [{ allowDirectConstAssertionInArrowFunctions: true }],
     },
     {
       code: `
-export function func1() {
-  return 0;
-}
-export const foo = {
-  func2() {
-    return 0;
-  },
-};
+const foo = arg => arg;
+export default foo;
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['func1', 'func2'],
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-export class Test {
-  get prop() {
-    return 1;
-  }
-  set prop() {}
-  method() {
-    return;
-  }
-  // prettier-ignore
-  'method'() {}
-  ['prop']() {}
-  [\`prop\`]() {}
-  [\`\${v}\`](): void {}
-
-  foo = () => {
-    bar: 5;
-  };
-}
+const foo = arg => arg;
+export = foo;
       `,
-      options: [
+      errors: [
         {
-          allowedNames: ['prop', 'method', 'foo'],
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-        export function foo(outer: string) {
-          return function (inner: string): void {};
-        }
+let foo = (arg: number): number => arg;
+foo = arg => arg;
+export default foo;
       `,
-      options: [
+      errors: [
         {
-          allowHigherOrderFunctions: true,
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 3,
+          messageId: 'missingReturnType',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1552
     {
       code: `
-        export type Ensurer = (blocks: TFBlock[]) => TFBlock[];
-
-        export const myEnsurer: Ensurer = blocks => {
-          return blocks;
-        };
+const foo = arg => arg;
+export default [foo];
       `,
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: true,
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
         },
       ],
     },
     {
       code: `
-export const Foo: FC = () => (
-  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
-);
+const foo = arg => arg;
+export default { foo };
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { jsx: true },
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
         },
-      },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export const Foo: JSX.Element = (
-  <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
-);
+function foo(arg) {
+  return arg;
+}
+export default foo;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { jsx: true },
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
         },
-      },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-const test = (): void => {
-  return;
-};
-export default test;
+function foo(arg) {
+  return arg;
+}
+export default [foo];
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-function test(): void {
-  return;
+function foo(arg) {
+  return arg;
 }
-export default test;
+export default { foo };
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-const test = (): void => {
-  return;
+const bar = function foo(arg) {
+  return arg;
 };
-export default [test];
+export default { bar };
       `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-function test(): void {
-  return;
+class Foo {
+  bool(arg) {
+    return arg;
+  }
 }
-export default [test];
-      `,
-    },
-    {
-      code: `
-const test = (): void => {
-  return;
-};
-export default { test };
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-function test(): void {
-  return;
+class Foo {
+  bool = arg => {
+    return arg;
+  };
 }
-export default { test };
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-const foo = (arg => arg) as Foo;
-export default foo;
+class Foo {
+  bool = function (arg) {
+    return arg;
+  };
+}
+export default Foo;
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-let foo = (arg => arg) as Foo;
-foo = 3;
-export default foo;
+class Foo {
+  bool = function (arg) {
+    return arg;
+  };
+}
+export default [Foo];
       `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
     },
     {
       code: `
-class Foo {
-  bar = (arg: string): string => arg;
-}
-export default { Foo };
+let test = arg => argl;
+test = (): void => {
+  return;
+};
+export default test;
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-class Foo {
-  bar(): void {
-    return;
-  }
-}
-export default { Foo };
+let test = arg => argl;
+test = (): void => {
+  return;
+};
+export { test };
       `,
+      errors: [
+        {
+          data: {
+            name: 'arg',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
     },
     {
       code: `
-export function foo(): (n: number) => string {
-  return n => String(n);
-}
+export const foo =
+  () =>
+  (a: string): ((n: number) => string) => {
+    return function (n) {
+      return String(n);
+    };
+  };
       `,
+      errors: [
+        {
+          column: 6,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: false }],
     },
     {
       code: `
-export const foo = (a: string): ((n: number) => string) => {
-  return function (n) {
-    return String(n);
-  };
-};
+export var arrowFn = () => () => {};
       `,
+      errors: [
+        {
+          column: 31,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function a(): void {
-  function b() {}
-  const x = () => {};
-  (function () {});
-
-  function c() {
-    return () => {};
-  }
-
-  return;
+export function fn() {
+  return function () {};
 }
       `,
+      errors: [
+        {
+          column: 10,
+          line: 3,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function a(): void {
-  function b() {
-    function c() {}
-  }
-  const x = () => {
-    return () => 100;
-  };
-  (function () {
-    (function () {});
-  });
-
-  function c() {
-    return () => {
-      (function () {});
-    };
-  }
-
-  return;
+export function foo(outer) {
+  return function (inner): void {};
 }
       `,
+      errors: [
+        {
+          column: 21,
+          data: {
+            name: 'outer',
+          },
+          line: 2,
+          messageId: 'missingArgType',
+        },
+        {
+          column: 20,
+          data: {
+            name: 'inner',
+          },
+          line: 3,
+          messageId: 'missingArgType',
+        },
+      ],
+      options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function a() {
-  return function b(): () => void {
-    return function c() {};
-  };
+export function foo(outer: boolean) {
+  if (outer) {
+    return 'string';
+  }
+  return function (inner): void {};
 }
       `,
+      errors: [
+        {
+          column: 8,
+          data: {
+            name: 'inner',
+          },
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+      ],
       options: [{ allowHigherOrderFunctions: true }],
     },
+    // test a few different argument patterns
     {
       code: `
-export var arrowFn = () => (): void => {};
+export function foo({ foo }): void {}
       `,
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Object pattern',
+          },
+          line: 2,
+          messageId: 'missingArgTypeUnnamed',
+        },
+      ],
     },
     {
       code: `
-export function fn() {
-  return function (): void {};
-}
+export function foo([bar]): void {}
       `,
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Array pattern',
+          },
+          line: 2,
+          messageId: 'missingArgTypeUnnamed',
+        },
+      ],
     },
     {
       code: `
-export function foo(outer: string) {
-  return function (inner: string): void {};
-}
+export function foo(...bar): void {}
       `,
-    },
-    // shouldn't check functions that aren't directly exported - https://github.com/typescript-eslint/typescript-eslint/issues/2134
-    `
-export function foo(): unknown {
-  return new Proxy(apiInstance, {
-    get: (target, property) => {
-      // implementation
-    },
-  });
-}
-    `,
-    {
-      code: 'export default (() => true)();',
-      options: [
+      errors: [
         {
-          allowTypedFunctionExpressions: false,
+          column: 21,
+          data: {
+            name: 'bar',
+          },
+          line: 2,
+          messageId: 'missingArgType',
         },
       ],
     },
-    // explicit assertions are allowed
-    {
-      code: 'export const x = (() => {}) as Foo;',
-      options: [{ allowTypedFunctionExpressions: false }],
-    },
     {
       code: `
-interface Foo {}
-export const x = {
-  foo: () => {},
-} as Foo;
+export function foo(...[a]): void {}
       `,
-      options: [{ allowTypedFunctionExpressions: false }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Rest',
+          },
+          line: 2,
+          messageId: 'missingArgTypeUnnamed',
+        },
+      ],
     },
     // allowArgumentsExplicitlyTypedAsAny
     {
       code: `
 export function foo(foo: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            name: 'foo',
+          },
+          line: 2,
+          messageId: 'anyTypedArg',
+        },
+      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
 export function foo({ foo }: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Object pattern',
+          },
+          line: 2,
+          messageId: 'anyTypedArgUnnamed',
+        },
+      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
 export function foo([bar]: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Array pattern',
+          },
+          line: 2,
+          messageId: 'anyTypedArgUnnamed',
+        },
+      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
 export function foo(...bar: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            name: 'bar',
+          },
+          line: 2,
+          messageId: 'anyTypedArg',
+        },
+      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
     {
       code: `
 export function foo(...[a]: any): void {}
       `,
-      options: [{ allowArgumentsExplicitlyTypedAsAny: true }],
+      errors: [
+        {
+          column: 21,
+          data: {
+            type: 'Rest',
+          },
+          line: 2,
+          messageId: 'anyTypedArgUnnamed',
+        },
+      ],
+      options: [{ allowArgumentsExplicitlyTypedAsAny: false }],
     },
-    // assignment patterns are ignored
-    `
-export function foo(arg = 1): void {}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2161
     {
       code: `
-export const foo = (): ((n: number) => string) => n => String(n);
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2173
-    `
-export function foo(): (n: number) => (m: number) => string {
-  return function (n) {
-    return function (m) {
-      return String(n + m);
-    };
-  };
-}
-    `,
-    `
-export const foo = (): ((n: number) => (m: number) => string) => n => m =>
-  String(n + m);
-    `,
-    `
-export const bar: () => (n: number) => string = () => n => String(n);
-    `,
-    `
-type Buz = () => (n: number) => string;
-
-export const buz: Buz = () => n => String(n);
-    `,
-    `
-export abstract class Foo<T> {
-  abstract set value(element: T);
-}
-    `,
-    `
-export declare class Foo {
-  set time(seconds: number);
-}
-    `,
-    `
-export class A {
-  b = A;
-}
-    `,
-    `
-interface Foo {
-  f: (x: boolean) => boolean;
+export function func1() {
+  return 0;
 }
-
-export const a: Foo[] = [
-  {
-    f: (x: boolean) => x,
+export const foo = {
+  func2() {
+    return 0;
   },
-];
-    `,
-    `
-interface Foo {
-  f: (x: boolean) => boolean;
-}
-
-export const a: Foo = {
-  f: (x: boolean) => x,
 };
-    `,
+      `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 22,
+          endLine: 2,
+          line: 2,
+          messageId: 'missingReturnType',
+        },
+        {
+          column: 3,
+          endColumn: 8,
+          endLine: 6,
+          line: 6,
+          messageId: 'missingReturnType',
+        },
+      ],
+      options: [
+        {
+          allowedNames: [],
+        },
+      ],
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/init-declarations.test.ts b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
index ae5ff0264df8..3d02f77a2f18 100644
--- a/packages/eslint-plugin/tests/rules/init-declarations.test.ts
+++ b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
@@ -5,272 +5,138 @@ import rule from '../../src/rules/init-declarations';
 const ruleTester = new RuleTester();
 
 ruleTester.run('init-declarations', rule, {
-  invalid: [
+  valid: [
     // checking compatibility with base rule
-    {
-      code: 'var foo;',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'foo' },
-          endColumn: 8,
-          endLine: 1,
-          line: 1,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
-    },
-    {
-      code: 'for (var a in []) var foo;',
-      errors: [
-        {
-          column: 23,
-          data: { idName: 'foo' },
-          endColumn: 26,
-          endLine: 1,
-          line: 1,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
-    },
-    {
-      code: `
-var foo,
+    'var foo = null;',
+    'foo = true;',
+    `
+var foo = 1,
   bar = false,
-  baz;
-      `,
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'foo' },
-          endColumn: 8,
-          endLine: 2,
-          line: 2,
-          messageId: 'initialized',
-        },
-        {
-          column: 3,
-          data: { idName: 'baz' },
-          endColumn: 6,
-          endLine: 4,
-          line: 4,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
-    },
-    {
-      code: `
+  baz = {};
+    `,
+    `
 function foo() {
   var foo = 0;
-  var bar;
+  var bar = [];
 }
-      `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'bar' },
-          endColumn: 10,
-          endLine: 4,
-          line: 4,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
-    },
+    `,
+    'var fn = function () {};',
+    'var foo = (bar = 2);',
+    'for (var i = 0; i < 1; i++) {}',
+    `
+for (var foo in []) {
+}
+    `,
     {
       code: `
-function foo() {
-  var foo;
-  var bar = foo;
+for (var foo of []) {
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'foo' },
-          endColumn: 10,
-          endLine: 3,
-          line: 3,
-          messageId: 'initialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'let a = true;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
     {
-      code: 'let a;',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'a' },
-          endColumn: 6,
-          endLine: 1,
-          line: 1,
-          messageId: 'initialized',
-        },
-      ],
+      code: 'const a = {};',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
     {
       code: `
 function foo() {
   let a = 1,
-    b;
+    b = false;
   if (a) {
     let c = 3,
       d = null;
   }
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'b' },
-          endColumn: 6,
-          endLine: 4,
-          line: 4,
-          messageId: 'initialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
     {
       code: `
 function foo() {
-  let a;
-  const b = false;
-  var c;
+  const a = 1,
+    b = true;
+  if (a) {
+    const c = 3,
+      d = null;
+  }
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'a' },
-          endColumn: 8,
-          endLine: 3,
-          line: 3,
-          messageId: 'initialized',
-        },
-        {
-          column: 7,
-          data: { idName: 'c' },
-          endColumn: 8,
-          endLine: 5,
-          line: 5,
-          messageId: 'initialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
     {
-      code: 'var foo = (bar = 2);',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'foo' },
-          endColumn: 20,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
+      code: `
+function foo() {
+  let a = 1;
+  const b = false;
+  var c = true;
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['always'],
     },
     {
-      code: 'var foo = true;',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'foo' },
-          endColumn: 15,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
+      code: 'var foo;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: `
-var foo,
-  bar = 5,
-  baz = 3;
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { idName: 'bar' },
-          endColumn: 10,
-          endLine: 3,
-          line: 3,
-          messageId: 'notInitialized',
-        },
-        {
-          column: 3,
-          data: { idName: 'baz' },
-          endColumn: 10,
-          endLine: 4,
-          line: 4,
-          messageId: 'notInitialized',
-        },
-      ],
+      code: 'var foo, bar, baz;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
       code: `
 function foo() {
   var foo;
-  var bar = foo;
+  var bar;
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'bar' },
-          endColumn: 16,
-          endLine: 4,
-          line: 4,
-          messageId: 'notInitialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: 'let a = 1;',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'a' },
-          endColumn: 10,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
+      code: 'let a;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
+    },
+    {
+      code: 'const a = 1;',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
       code: `
 function foo() {
-  let a = 'foo',
-    b;
+  let a, b;
   if (a) {
     let c, d;
   }
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'a' },
-          endColumn: 16,
-          endLine: 3,
-          line: 3,
-          messageId: 'notInitialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
+    },
+    {
+      code: `
+function foo() {
+  const a = 1,
+    b = true;
+  if (a) {
+    const c = 3,
+      d = null;
+  }
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
@@ -278,486 +144,608 @@ function foo() {
 function foo() {
   let a;
   const b = false;
-  var c = 1;
+  var c;
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'c' },
-          endColumn: 12,
-          endLine: 5,
-          line: 5,
-          messageId: 'notInitialized',
-        },
-      ],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
       code: 'for (var i = 0; i < 1; i++) {}',
-      errors: [
-        {
-          column: 10,
-          data: { idName: 'i' },
-          endColumn: 15,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
 for (var foo in []) {
 }
       `,
-      errors: [
-        {
-          column: 10,
-          data: { idName: 'foo' },
-          endColumn: 13,
-          endLine: 2,
-          line: 2,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
 for (var foo of []) {
 }
       `,
-      errors: [
-        {
-          column: 10,
-          data: { idName: 'foo' },
-          endColumn: 13,
-          endLine: 2,
-          line: 2,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never', { ignoreForLoopInit: true }],
     },
     {
       code: `
 function foo() {
-  var bar;
+  var bar = 1;
+  let baz = 2;
+  const qux = 3;
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'bar' },
-          endColumn: 10,
-          endLine: 3,
-          line: 3,
-          messageId: 'initialized',
-        },
-      ],
       options: ['always'],
     },
 
     // typescript-eslint
     {
-      code: "let arr: string[] = ['arr', 'ar'];",
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'arr' },
-          endColumn: 34,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
+      code: 'declare const foo: number;',
+      options: ['always'],
     },
     {
-      code: 'let arr: string = function () {};',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'arr' },
-          endColumn: 33,
-          endLine: 1,
-          line: 1,
-          messageId: 'notInitialized',
-        },
-      ],
+      code: 'declare const foo: number;',
       options: ['never'],
     },
     {
       code: `
-const class1 = class NAME {
-  constructor() {
-    var name1: string = 'hello';
-  }
-};
+declare namespace myLib {
+  let numberOfGreetings: number;
+}
       `,
-      errors: [
-        {
-          column: 9,
-          data: { idName: 'name1' },
-          endColumn: 32,
-          endLine: 4,
-          line: 4,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
-    },
-    {
-      code: 'let arr: string;',
-      errors: [
-        {
-          column: 5,
-          data: { idName: 'arr' },
-          endColumn: 8,
-          endLine: 1,
-          line: 1,
-          messageId: 'initialized',
-        },
-      ],
       options: ['always'],
     },
     {
       code: `
-namespace myLib {
+declare namespace myLib {
   let numberOfGreetings: number;
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'numberOfGreetings' },
-          endColumn: 24,
-          endLine: 3,
-          line: 3,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
+      options: ['never'],
     },
     {
       code: `
-namespace myLib {
-  let numberOfGreetings: number = 2;
+interface GreetingSettings {
+  greeting: string;
+  duration?: number;
+  color?: string;
 }
       `,
-      errors: [
-        {
-          column: 7,
-          data: { idName: 'numberOfGreetings' },
-          endColumn: 36,
-          endLine: 3,
-          line: 3,
-          messageId: 'notInitialized',
-        },
-      ],
-      options: ['never'],
     },
     {
       code: `
-namespace myLib1 {
-  const foo: number;
-  namespace myLib2 {
-    let bar: string;
-    namespace myLib3 {
-      let baz: object;
-    }
-  }
+interface GreetingSettings {
+  greeting: string;
+  duration?: number;
+  color?: string;
 }
       `,
-      errors: [
-        {
-          column: 9,
-          data: { idName: 'foo' },
-          endColumn: 12,
-          endLine: 3,
-          line: 3,
-          messageId: 'initialized',
-        },
-        {
-          column: 9,
-          data: { idName: 'bar' },
-          endColumn: 12,
-          endLine: 5,
-          line: 5,
-          messageId: 'initialized',
-        },
-        {
-          column: 11,
-          data: { idName: 'baz' },
-          endColumn: 14,
-          endLine: 7,
-          line: 7,
-          messageId: 'initialized',
-        },
-      ],
-      options: ['always'],
+      options: ['never'],
+    },
+    'type GreetingLike = string | (() => string) | Greeter;',
+    {
+      code: 'type GreetingLike = string | (() => string) | Greeter;',
+      options: ['never'],
     },
-  ],
-  valid: [
-    // checking compatibility with base rule
-    'var foo = null;',
-    'foo = true;',
-    `
-var foo = 1,
-  bar = false,
-  baz = {};
-    `,
-    `
-function foo() {
-  var foo = 0;
-  var bar = [];
-}
-    `,
-    'var fn = function () {};',
-    'var foo = (bar = 2);',
-    'for (var i = 0; i < 1; i++) {}',
-    `
-for (var foo in []) {
-}
-    `,
     {
       code: `
-for (var foo of []) {
+function foo() {
+  var bar: string;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      options: ['never'],
     },
     {
-      code: 'let a = true;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['always'],
+      code: 'var bar: string;',
+      options: ['never'],
     },
     {
-      code: 'const a = {};',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['always'],
+      code: `
+var bar: string = function (): string {
+  return 'string';
+};
+      `,
+      options: ['always'],
     },
     {
       code: `
-function foo() {
-  let a = 1,
-    b = false;
-  if (a) {
-    let c = 3,
-      d = null;
-  }
-}
+var bar: string = function (arg1: stirng): string {
+  return 'string';
+};
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['always'],
     },
+    {
+      code: "function foo(arg1: string = 'string'): void {}",
+      options: ['never'],
+    },
+    {
+      code: "const foo: string = 'hello';",
+      options: ['never'],
+    },
     {
       code: `
-function foo() {
-  const a = 1,
-    b = true;
-  if (a) {
-    const c = 3,
-      d = null;
+const class1 = class NAME {
+  constructor() {
+    var name1: string = 'hello';
   }
-}
+};
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['always'],
     },
     {
       code: `
-function foo() {
-  let a = 1;
-  const b = false;
-  var c = true;
-}
+const class1 = class NAME {
+  static pi: number = 3.14;
+};
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['always'],
     },
     {
-      code: 'var foo;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: `
+const class1 = class NAME {
+  static pi: number = 3.14;
+};
+      `,
       options: ['never'],
     },
     {
-      code: 'var foo, bar, baz;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['never'],
+      code: `
+interface IEmployee {
+  empCode: number;
+  empName: string;
+  getSalary: (number) => number; // arrow function
+  getManagerName(number): string;
+}
+      `,
     },
     {
       code: `
-function foo() {
-  var foo;
-  var bar;
+interface IEmployee {
+  empCode: number;
+  empName: string;
+  getSalary: (number) => number; // arrow function
+  getManagerName(number): string;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
-      code: 'let a;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['never'],
+      code: "const foo: number = 'asd';",
+      options: ['always'],
     },
     {
-      code: 'const a = 1;',
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+      code: 'const foo: number;',
       options: ['never'],
     },
     {
       code: `
-function foo() {
-  let a, b;
-  if (a) {
-    let c, d;
-  }
+namespace myLib {
+  let numberOfGreetings: number;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
     {
       code: `
-function foo() {
-  const a = 1,
-    b = true;
-  if (a) {
-    const c = 3,
-      d = null;
+namespace myLib {
+  let numberOfGreetings: number = 2;
+}
+      `,
+      options: ['always'],
+    },
+    {
+      code: `
+declare namespace myLib1 {
+  const foo: number;
+  namespace myLib2 {
+    let bar: string;
+    namespace myLib3 {
+      let baz: object;
+    }
   }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['never'],
+      options: ['always'],
     },
+
     {
       code: `
-function foo() {
-  let a;
-  const b = false;
-  var c;
+declare namespace myLib1 {
+  const foo: number;
+  namespace myLib2 {
+    let bar: string;
+    namespace myLib3 {
+      let baz: object;
+    }
+  }
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: ['never'],
     },
+  ],
+  invalid: [
+    // checking compatibility with base rule
     {
-      code: 'for (var i = 0; i < 1; i++) {}',
-      options: ['never', { ignoreForLoopInit: true }],
+      code: 'var foo;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 8,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
+    },
+    {
+      code: 'for (var a in []) var foo;',
+      errors: [
+        {
+          column: 23,
+          data: { idName: 'foo' },
+          endColumn: 26,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
-for (var foo in []) {
-}
+var foo,
+  bar = false,
+  baz;
       `,
-      options: ['never', { ignoreForLoopInit: true }],
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 8,
+          endLine: 2,
+          line: 2,
+          messageId: 'initialized',
+        },
+        {
+          column: 3,
+          data: { idName: 'baz' },
+          endColumn: 6,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
-for (var foo of []) {
+function foo() {
+  var foo = 0;
+  var bar;
 }
       `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-      options: ['never', { ignoreForLoopInit: true }],
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
 function foo() {
-  var bar = 1;
-  let baz = 2;
-  const qux = 3;
+  var foo;
+  var bar = foo;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'foo' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
-
-    // typescript-eslint
     {
-      code: 'declare const foo: number;',
+      code: 'let a;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'a' },
+          endColumn: 6,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
     {
-      code: 'declare const foo: number;',
-      options: ['never'],
+      code: `
+function foo() {
+  let a = 1,
+    b;
+  if (a) {
+    let c = 3,
+      d = null;
+  }
+}
+      `,
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'b' },
+          endColumn: 6,
+          endLine: 4,
+          line: 4,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
-declare namespace myLib {
-  let numberOfGreetings: number;
+function foo() {
+  let a;
+  const b = false;
+  var c;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'a' },
+          endColumn: 8,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+        {
+          column: 7,
+          data: { idName: 'c' },
+          endColumn: 8,
+          endLine: 5,
+          line: 5,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
+    {
+      code: 'var foo = (bar = 2);',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 20,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
+    },
+    {
+      code: 'var foo = true;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'foo' },
+          endColumn: 15,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
+    },
     {
       code: `
-declare namespace myLib {
-  let numberOfGreetings: number;
+var foo,
+  bar = 5,
+  baz = 3;
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+        {
+          column: 3,
+          data: { idName: 'baz' },
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
+    },
+    {
+      code: `
+function foo() {
+  var foo;
+  var bar = foo;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
+    },
+    {
+      code: 'let a = 1;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'a' },
+          endColumn: 10,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
       code: `
-interface GreetingSettings {
-  greeting: string;
-  duration?: number;
-  color?: string;
+function foo() {
+  let a = 'foo',
+    b;
+  if (a) {
+    let c, d;
+  }
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'a' },
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
-interface GreetingSettings {
-  greeting: string;
-  duration?: number;
-  color?: string;
+function foo() {
+  let a;
+  const b = false;
+  var c = 1;
 }
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'c' },
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
-    'type GreetingLike = string | (() => string) | Greeter;',
     {
-      code: 'type GreetingLike = string | (() => string) | Greeter;',
+      code: 'for (var i = 0; i < 1; i++) {}',
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'i' },
+          endColumn: 15,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
       code: `
-function foo() {
-  var bar: string;
+for (var foo in []) {
 }
       `,
-      options: ['never'],
-    },
-    {
-      code: 'var bar: string;',
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'foo' },
+          endColumn: 13,
+          endLine: 2,
+          line: 2,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
       code: `
-var bar: string = function (): string {
-  return 'string';
-};
+for (var foo of []) {
+}
       `,
-      options: ['always'],
+      errors: [
+        {
+          column: 10,
+          data: { idName: 'foo' },
+          endColumn: 13,
+          endLine: 2,
+          line: 2,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
-var bar: string = function (arg1: stirng): string {
-  return 'string';
-};
+function foo() {
+  var bar;
+}
       `,
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'bar' },
+          endColumn: 10,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
+
+    // typescript-eslint
     {
-      code: "function foo(arg1: string = 'string'): void {}",
+      code: "let arr: string[] = ['arr', 'ar'];",
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 34,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
-      code: "const foo: string = 'hello';",
+      code: 'let arr: string = function () {};',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 33,
+          endLine: 1,
+          line: 1,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
@@ -768,58 +756,49 @@ const class1 = class NAME {
   }
 };
       `,
-    },
-    {
-      code: `
-const class1 = class NAME {
-  static pi: number = 3.14;
-};
-      `,
-    },
-    {
-      code: `
-const class1 = class NAME {
-  static pi: number = 3.14;
-};
-      `,
-      options: ['never'],
-    },
-    {
-      code: `
-interface IEmployee {
-  empCode: number;
-  empName: string;
-  getSalary: (number) => number; // arrow function
-  getManagerName(number): string;
-}
-      `,
-    },
-    {
-      code: `
-interface IEmployee {
-  empCode: number;
-  empName: string;
-  getSalary: (number) => number; // arrow function
-  getManagerName(number): string;
-}
-      `,
+      errors: [
+        {
+          column: 9,
+          data: { idName: 'name1' },
+          endColumn: 32,
+          endLine: 4,
+          line: 4,
+          messageId: 'notInitialized',
+        },
+      ],
       options: ['never'],
     },
     {
-      code: "const foo: number = 'asd';",
+      code: 'let arr: string;',
+      errors: [
+        {
+          column: 5,
+          data: { idName: 'arr' },
+          endColumn: 8,
+          endLine: 1,
+          line: 1,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
-    {
-      code: 'const foo: number;',
-      options: ['never'],
-    },
     {
       code: `
 namespace myLib {
   let numberOfGreetings: number;
 }
       `,
-      options: ['never'],
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'numberOfGreetings' },
+          endColumn: 24,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+      ],
+      options: ['always'],
     },
     {
       code: `
@@ -827,11 +806,21 @@ namespace myLib {
   let numberOfGreetings: number = 2;
 }
       `,
-      options: ['always'],
+      errors: [
+        {
+          column: 7,
+          data: { idName: 'numberOfGreetings' },
+          endColumn: 36,
+          endLine: 3,
+          line: 3,
+          messageId: 'notInitialized',
+        },
+      ],
+      options: ['never'],
     },
     {
       code: `
-declare namespace myLib1 {
+namespace myLib1 {
   const foo: number;
   namespace myLib2 {
     let bar: string;
@@ -841,22 +830,33 @@ declare namespace myLib1 {
   }
 }
       `,
+      errors: [
+        {
+          column: 9,
+          data: { idName: 'foo' },
+          endColumn: 12,
+          endLine: 3,
+          line: 3,
+          messageId: 'initialized',
+        },
+        {
+          column: 9,
+          data: { idName: 'bar' },
+          endColumn: 12,
+          endLine: 5,
+          line: 5,
+          messageId: 'initialized',
+        },
+        {
+          column: 11,
+          data: { idName: 'baz' },
+          endColumn: 14,
+          endLine: 7,
+          line: 7,
+          messageId: 'initialized',
+        },
+      ],
       options: ['always'],
     },
-
-    {
-      code: `
-declare namespace myLib1 {
-  const foo: number;
-  namespace myLib2 {
-    let bar: string;
-    namespace myLib3 {
-      let baz: object;
-    }
-  }
-}
-      `,
-      options: ['never'],
-    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/max-params.test.ts b/packages/eslint-plugin/tests/rules/max-params.test.ts
index 88bc13124a55..0bbbdcdc92be 100644
--- a/packages/eslint-plugin/tests/rules/max-params.test.ts
+++ b/packages/eslint-plugin/tests/rules/max-params.test.ts
@@ -5,47 +5,6 @@ import rule from '../../src/rules/max-params';
 const ruleTester = new RuleTester();
 
 ruleTester.run('max-params', rule, {
-  invalid: [
-    { code: 'function foo(a, b, c, d) {}', errors: [{ messageId: 'exceed' }] },
-    {
-      code: 'const foo = function (a, b, c, d) {};',
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: 'const foo = (a, b, c, d) => {};',
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: 'const foo = a => {};',
-      errors: [{ messageId: 'exceed' }],
-      options: [{ max: 0 }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: void, a, b, c, d) {}
-}
-      `,
-      errors: [{ messageId: 'exceed' }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: void, a) {}
-}
-      `,
-      errors: [{ messageId: 'exceed' }],
-      options: [{ countVoidThis: true, max: 1 }],
-    },
-    {
-      code: `
-class Foo {
-  method(this: Foo, a, b, c) {}
-}
-      `,
-      errors: [{ messageId: 'exceed' }],
-    },
-  ],
   valid: [
     'function foo() {}',
     'const foo = function () {};',
@@ -99,4 +58,45 @@ class Foo {
       options: [{ countVoidThis: true, max: 2 }],
     },
   ],
+  invalid: [
+    { code: 'function foo(a, b, c, d) {}', errors: [{ messageId: 'exceed' }] },
+    {
+      code: 'const foo = function (a, b, c, d) {};',
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: 'const foo = (a, b, c, d) => {};',
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: 'const foo = a => {};',
+      errors: [{ messageId: 'exceed' }],
+      options: [{ max: 0 }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: void, a, b, c, d) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: void, a) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+      options: [{ countVoidThis: true, max: 1 }],
+    },
+    {
+      code: `
+class Foo {
+  method(this: Foo, a, b, c) {}
+}
+      `,
+      errors: [{ messageId: 'exceed' }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/member-ordering.test.ts b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
index f5b41826e8a7..3660a040b468 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
@@ -9,9 +9,8 @@ import rule from '../../src/rules/member-ordering';
 const ruleTester = new RuleTester();
 
 const grouped: RunTests<MessageIds, Options> = {
-  invalid: [
-    {
-      code: `
+  valid: [
+    `
 // no accessibility === public
 interface Foo {
   [Z: string]: any;
@@ -21,252 +20,119 @@ interface Foo {
   D: string;
   E: string;
   F: string;
+  new ();
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
 }
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'method',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-    },
+    `,
     {
       code: `
-interface X {
-  a: unknown;
-  (): void;
-  b(): void;
+// no accessibility === public
+interface Foo {
+  A: string;
+  J();
+  K();
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  G();
+  H();
+  [Z: string]: any;
+  B: string;
+  C: string;
+  I();
+  L();
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'call',
-            rank: 'field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['call-signature', 'field', 'method'] }],
+      options: [{ default: 'never' }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
+  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+  new ();
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
-  [Z: string]: any;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+interface X {
+  (): void;
+  a: unknown;
+  b(): void;
+}
+      `,
+      options: [{ default: ['call-signature', 'field', 'method'] }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
   A: string;
-  B: string;
-  C: string;
+  J();
+  K();
   D: string;
+  [Z: string]: any;
   E: string;
   F: string;
+  new ();
   G();
+  B: string;
+  C: string;
   H();
   I();
-  J();
-  K();
   L();
-  new ();
-  [Z: string]: any;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        { interfaces: ['method', 'signature', 'constructor', 'field'] },
-      ],
+      options: [{ interfaces: 'never' }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
+  [Z: string]: any;
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+  new ();
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+}
+      `,
+      options: [
+        { interfaces: ['signature', 'method', 'constructor', 'field'] },
+      ],
+    },
+    {
+      code: `
+// no accessibility === public
+interface Foo {
   G();
   H();
   I();
@@ -274,87 +140,19 @@ interface Foo {
   K();
   L();
   new ();
-  [Z: string]: any;
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  [Z: string]: any;
+}
+      `,
       options: [
         {
-          default: ['field', 'method', 'constructor', 'signature'],
-          interfaces: ['method', 'signature', 'constructor', 'field'],
+          default: ['signature', 'field', 'constructor', 'method'],
+          interfaces: ['method', 'constructor', 'field', 'signature'],
         },
       ],
     },
@@ -362,111 +160,104 @@ interface Foo {
       code: `
 // no accessibility === public
 interface Foo {
-  [Z: string]: any;
-  new ();
-  A: string;
   G();
-  B: string;
   H();
-  C: string;
   I();
+  new ();
+  [Z: string]: any;
   D: string;
-  J();
   E: string;
-  K();
   F: string;
+  G?: string;
+  J();
+  K();
   L();
+  A: string;
+  B: string;
+  C: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'method',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'method',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'E',
-            rank: 'method',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'method',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
+          default: [
+            'private-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
+    },
+    {
+      code: `
+// no accessibility === public
+interface Foo {
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+  [Z: string]: any;
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  A: string;
+  B: string;
+  C: string;
+}
+      `,
       options: [
         {
-          interfaces: ['signature', 'constructor', 'field', 'method'],
+          default: ['method', 'public-constructor', 'protected-static-field'],
         },
       ],
     },
+    `
+// no accessibility === public
+type Foo = {
+  [Z: string]: any;
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  new ();
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
+};
+    `,
     {
       code: `
 // no accessibility === public
 type Foo = {
-  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+  [Z: string]: any;
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'method',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
+      options: [{ default: 'never' }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
+  [Z: string]: any;
   A: string;
   B: string;
   C: string;
@@ -479,273 +270,120 @@ type Foo = {
   J();
   K();
   L();
+};
+      `,
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+// no accessibility === public
+type Foo = {
   [Z: string]: any;
   new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
+      options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
+  G();
+  H();
   [Z: string]: any;
+  K();
+  L();
   A: string;
   B: string;
+  I();
+  J();
   C: string;
   D: string;
   E: string;
   F: string;
+};
+      `,
+      options: [{ typeLiterals: 'never' }],
+    },
+    {
+      code: `
+// no accessibility === public
+type Foo = {
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
+  [Z: string]: any;
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'signature',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'signature',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'signature',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'signature',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'signature',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'signature',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'signature',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        { typeLiterals: ['method', 'constructor', 'signature', 'field'] },
-      ],
+      options: [{ typeLiterals: ['method', 'field', 'signature'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
+  G();
+  H();
+  I();
+  J();
+  K();
+  L();
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
+  [Z: string]: any;
+};
+      `,
+      options: [
+        { typeLiterals: ['method', 'constructor', 'field', 'signature'] },
+      ],
+    },
+    {
+      code: `
+// no accessibility === public
+type Foo = {
   G();
   H();
   I();
   J();
   K();
   L();
-  new ();
+  A: string;
+  B: string;
+  C: string;
+  D: string;
+  E: string;
+  F: string;
   [Z: string]: any;
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'new',
-            rank: 'field',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['field', 'method', 'constructor', 'signature'],
-          typeLiterals: ['signature', 'method', 'constructor', 'field'],
+          default: ['signature', 'field', 'constructor', 'method'],
+          typeLiterals: ['method', 'constructor', 'field', 'signature'],
         },
       ],
     },
@@ -753,80 +391,36 @@ type Foo = {
       code: `
 // no accessibility === public
 type Foo = {
-  new ();
   [Z: string]: any;
+  D: string;
+  E: string;
+  F: string;
   A: string;
-  G();
   B: string;
-  H();
   C: string;
+  G();
+  H();
   I();
-  D: string;
   J();
-  E: string;
   K();
-  F: string;
   L();
 };
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'method',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'method',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'E',
-            rank: 'method',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'method',
-          },
-          line: 16,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        {
-          typeLiterals: ['constructor', 'signature', 'field', 'method'],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
+          typeLiterals: ['signature', 'field', 'method'],
         },
       ],
     },
-    {
-      code: `
+    `
 class Foo {
   [Z: string]: any;
-  public static A: string = '';
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -835,60 +429,46 @@ class Foo {
   private F: string = '';
   #F: string = '';
   constructor() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
   #L() {}
+}
+    `,
+    {
+      code: `
+class Foo {
+  [Z: string]: any;
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  static #C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  #F: string = '';
+  constructor() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   static #I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  #L() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'public instance method',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 18,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 19,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 20,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
+      options: [{ default: 'never' }],
     },
     {
       code: `
 class Foo {
-  constructor() {}
-  public static A: string = '';
+  [Z: string]: any;
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -896,226 +476,129 @@ class Foo {
   protected E: string = '';
   private F: string = '';
   #F: string = '';
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
+  constructor() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   static #I() {}
-  [Z: string]: any;
+  public J() {}
+  protected K() {}
+  private L() {}
+  #L() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'constructor',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'constructor',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'constructor',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'E',
-            rank: 'constructor',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['field', 'constructor', 'method', 'signature'] }],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
 class Foo {
+  [Z: string]: any;
   constructor() {}
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
+  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  #F: string = '';
   public static G() {}
-  public static A: string;
   protected static H() {}
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
+  #L() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
 class Foo {
-  protected static H() {}
-  private static I() {}
-  public J() {}
+  public static G() {}
   protected K() {}
   private L() {}
+  private static I() {}
+  public J() {}
+  public D: string = '';
+  [Z: string]: any;
+  protected static H() {}
   public static A: string;
-  public static G() {}
   protected static B: string = '';
+  constructor() {}
   private static C: string = '';
-  public D: string = '';
   protected E: string = '';
   private F: string = '';
-  constructor() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'field'] }],
+      options: [{ classes: 'never' }],
     },
     {
       code: `
 class Foo {
   public static G() {}
   protected static H() {}
-  protected static B: string = '';
   private static I() {}
+  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
+  #L() {}
+  [Z: string]: any;
   public static A: string;
-  constructor() {}
+  protected static B: string = '';
   private static C: string = '';
+  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  #F: string = '';
+  constructor() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ classes: ['method', 'constructor', 'field'] }],
+      options: [{ classes: ['method', 'field'] }],
     },
     {
       code: `
 class Foo {
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
+  constructor() {}
   public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  [Z: string]: any;
+}
+      `,
+      options: [{ classes: ['method', 'constructor', 'field', 'signature'] }],
+    },
+    {
+      code: `
+class Foo {
+  private required: boolean;
+  private typeChecker: (data: any) => boolean;
+  constructor(validator: (data: any) => boolean) {
+    this.typeChecker = validator;
+  }
+  check(data: any): boolean {
+    return this.typeChecker(data);
+  }
+}
+      `,
+      options: [{ classes: ['field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+class Foo {
   public static G() {}
   protected static H() {}
   private static I() {}
@@ -1123,132 +606,52 @@ class Foo {
   protected K() {}
   private L() {}
   constructor() {}
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  [Z: string]: any;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          classes: ['method', 'constructor', 'field'],
-          default: ['field', 'constructor', 'method'],
+          classes: ['method', 'constructor', 'field', 'signature'],
+          default: ['signature', 'field', 'constructor', 'method'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  private L() {}
   public J() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   protected K() {}
+  private L() {}
+  [Z: string]: any;
   constructor() {}
   public D: string = '';
-  private static C: string = '';
   public static A: string;
   private static C: string = '';
-  protected static B: string = '';
   private F: string = '';
+  static #M: string = '';
+  #N: string = '';
   protected static B: string = '';
   protected E: string = '';
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'private field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'protected field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           classes: [
             'public-method',
+            'signature',
             'constructor',
             'public-field',
             'private-field',
+            '#private-field',
             'protected-field',
           ],
         },
@@ -1259,39 +662,21 @@ class Foo {
 class Foo {
   public static G() {}
   private static I() {}
-  public J() {}
   protected static H() {}
+  public J() {}
   private L() {}
   protected K() {}
-  public D: string = '';
+  [Z: string]: any;
   constructor() {}
+  public D: string = '';
   public static A: string;
   protected static B: string = '';
   protected E: string = '';
   private static C: string = '';
   private F: string = '';
+  #M: string = '';
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'public field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           classes: [
@@ -1299,10 +684,12 @@ class Foo {
             'static-method',
             'public-instance-method',
             'instance-method',
+            'signature',
             'constructor',
             'public-field',
             'protected-field',
             'private-field',
+            '#private-field',
           ],
         },
       ],
@@ -1314,28 +701,22 @@ class Foo {
   public static G() {}
   public D: string = '';
   public static A: string = '';
-  private L() {}
   constructor() {}
   protected K() {}
+  private L() {}
+  #P() {}
   protected static H() {}
   private static I() {}
+  static #O() {}
   protected static B: string = '';
   private static C: string = '';
+  static #N: string = '';
   protected E: string = '';
   private F: string = '';
+  #M: string = '';
+  [Z: string]: any;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'method',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: [
@@ -1344,6 +725,7 @@ class Foo {
             'constructor',
             'method',
             'field',
+            'signature',
           ],
         },
       ],
@@ -1352,49 +734,36 @@ class Foo {
       code: `
 class Foo {
   public J() {}
-  private static I() {}
   public static G() {}
   protected static H() {}
+  private static I() {}
+  static #I() {}
   protected K() {}
   private L() {}
+  #L() {}
   constructor() {}
+  [Z: string]: any;
   public static A: string;
   private F: string = '';
+  #F: string = '';
   protected static B: string = '';
   public D: string = '';
   private static C: string = '';
+  static #C: string = '';
   protected E: string = '';
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'private static method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'private static method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
+      options: [
         {
           classes: [
             'public-method',
             'protected-static-method',
-            'private-static-method',
+            '#private-static-method',
             'protected-instance-method',
             'private-instance-method',
+            '#private-instance-method',
             'constructor',
+            'signature',
             'field',
           ],
         },
@@ -1403,6 +772,7 @@ class Foo {
     {
       code: `
 class Foo {
+  private L() {}
   private static I() {}
   protected static H() {}
   protected static B: string = '';
@@ -1410,25 +780,39 @@ class Foo {
   public J() {}
   protected K() {}
   private static C: string = '';
-  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
   public D: string = '';
   constructor() {}
+  [Z: string]: any;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'protected static field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
+          classes: ['private-instance-method', 'protected-static-field'],
         },
       ],
+    },
+    {
+      code: `
+class Foo {
+  private L() {}
+  private static I() {}
+  static #H() {}
+  static #B: string = '';
+  public static G() {}
+  public J() {}
+  #K() {}
+  private static C: string = '';
+  private F: string = '';
+  #E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
+  [Z: string]: any;
+}
+      `,
       options: [
         {
           classes: ['private-instance-method', 'protected-static-field'],
@@ -1442,8 +826,8 @@ class Foo {
   private static I() {}
   protected static H() {}
   public static G() {}
-  protected static B: string = '';
   public J() {}
+  protected static B: string = '';
   protected K() {}
   private static C: string = '';
   private F: string = '';
@@ -1451,19 +835,9 @@ class Foo {
   public static A: string;
   public D: string = '';
   constructor() {}
+  [Z: string]: any;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'protected static field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: ['public-instance-method', 'protected-static-field'],
@@ -1472,581 +846,384 @@ class Foo {
     },
     {
       code: `
-const foo = class Foo {
-  public static A: string = '';
+class Foo {
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
   protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   private F: string = '';
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
   constructor() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-};
+  [Z: string]: any;
+}
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'public instance method',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 14,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'public instance method',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
+          classes: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
-const foo = class {
+class Foo {
   [Z: string]: any;
-  constructor() {}
-  public static A: string = '';
-  protected static B: string = '';
-  private static C: string = '';
   public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  public J() {}
-  protected K() {}
   private L() {}
-  public static G() {}
-  protected static H() {}
   private static I() {}
-};
+  protected static H() {}
+  public static G() {}
+  public J() {}
+  private constructor() {}
+  protected static B: string = '';
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+}
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'constructor',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'constructor',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'constructor',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'constructor',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'E',
-            rank: 'constructor',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'constructor',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
+          classes: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-const foo = class {
-  constructor() {}
+class Foo {
+  public constructor() {}
+  public D: string = '';
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
+  [Z: string]: any;
+  protected static B: string = '';
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+}
+      `,
+      options: [
+        {
+          classes: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
+        },
+      ],
+    },
+    `
+const foo = class Foo {
+  [Z: string]: any;
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  [Z: string]: any;
+  constructor() {}
   public static G() {}
-  public static A: string;
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
 };
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['field', 'method'] }],
-    },
+    `,
     {
       code: `
-const foo = class {
-  protected static H() {}
+const foo = class Foo {
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
   private static I() {}
   public J() {}
+  private F: string = '';
+  [Z: string]: any;
+  public static G() {}
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  protected static H() {}
   protected K() {}
   private L() {}
+};
+      `,
+      options: [{ default: 'never' }],
+    },
+    {
+      code: `
+const foo = class Foo {
+  [Z: string]: any;
   public static A: string;
-  public static G() {}
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
   constructor() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  public J() {}
+  protected K() {}
+  private L() {}
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'field'] }],
+      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
+  constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
+  private F: string = '';
+  [Z: string]: any;
   public static G() {}
   protected static H() {}
-  protected static B: string = '';
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  public static A: string;
+};
+      `,
+      options: [{ default: ['field', 'method'] }],
+    },
+    {
+      code: `
+const foo = class Foo {
+  private L() {}
+  protected static H() {}
   constructor() {}
-  [Z: string]: any;
+  private static I() {}
+  public J() {}
   private static C: string = '';
+  [Z: string]: any;
   public D: string = '';
+  protected K() {}
+  public static G() {}
+  public static A: string;
+  protected static B: string = '';
   protected E: string = '';
   private F: string = '';
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 11,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ classExpressions: ['method', 'constructor', 'field'] }],
+      options: [{ classExpressions: 'never' }],
     },
     {
       code: `
-const foo = class {
-  public static A: string;
+const foo = class Foo {
   public static G() {}
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  constructor() {}
+  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
+  constructor() {}
+  [Z: string]: any;
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        {
-          classExpressions: ['method', 'constructor', 'field'],
-          default: ['field', 'constructor', 'method'],
-        },
-      ],
+      options: [{ classExpressions: ['method', 'field'] }],
     },
     {
       code: `
-const foo = class {
-  private L() {}
-  public J() {}
+const foo = class Foo {
   public static G() {}
   protected static H() {}
   private static I() {}
+  public J() {}
   protected K() {}
+  private L() {}
+  [Z: string]: any;
   constructor() {}
-  public D: string = '';
-  private static C: string = '';
   public static A: string;
-  private static C: string = '';
-  protected static B: string = '';
-  private F: string = '';
   protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
   protected E: string = '';
+  private F: string = '';
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'private field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'protected field',
-          },
-          line: 15,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
-        {
-          classExpressions: [
-            'public-method',
-            'constructor',
-            'public-field',
-            'private-field',
-            'protected-field',
-          ],
-        },
+        { classExpressions: ['method', 'signature', 'constructor', 'field'] },
       ],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
   public static G() {}
+  protected static H() {}
   private static I() {}
   public J() {}
-  protected static H() {}
-  private L() {}
   protected K() {}
-  public D: string = '';
+  private L() {}
+  [Z: string]: any;
   constructor() {}
   public static A: string;
   protected static B: string = '';
-  protected E: string = '';
   private static C: string = '';
+  public D: string = '';
+  protected E: string = '';
   private F: string = '';
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'public instance method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'public field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
+          classExpressions: ['method', 'signature', 'constructor', 'field'],
+          default: ['field', 'constructor', 'method'],
         },
       ],
+    },
+    {
+      code: `
+const foo = class Foo {
+  [Z: string]: any;
+  private L() {}
+  private static I() {}
+  protected static H() {}
+  protected static B: string = '';
+  public static G() {}
+  public J() {}
+  protected K() {}
+  private static C: string = '';
+  private F: string = '';
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
+};
+      `,
       options: [
         {
           classExpressions: [
-            'public-static-method',
-            'static-method',
-            'public-instance-method',
-            'instance-method',
-            'constructor',
-            'public-field',
-            'protected-field',
-            'private-field',
+            'private-instance-method',
+            'protected-static-field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  public J() {}
-  public static G() {}
-  public D: string = '';
-  public static A: string = '';
+const foo = class Foo {
   private L() {}
-  constructor() {}
-  protected K() {}
-  protected static H() {}
   private static I() {}
+  protected static H() {}
+  public static G() {}
+  public J() {}
+  [Z: string]: any;
   protected static B: string = '';
+  protected K() {}
   private static C: string = '';
-  protected E: string = '';
   private F: string = '';
+  protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'method',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: [
-            'public-method',
-            'public-field',
-            'constructor',
-            'method',
-            'field',
-          ],
+          default: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
-const foo = class {
-  public J() {}
+const foo = class Foo {
+  private L() {}
   private static I() {}
-  public static G() {}
   protected static H() {}
-  protected K() {}
-  private L() {}
-  constructor() {}
-  public static A: string;
-  private F: string = '';
+  public static G() {}
+  public J() {}
+  [Z: string]: any;
   protected static B: string = '';
-  public D: string = '';
+  protected K() {}
   private static C: string = '';
+  private F: string = '';
   protected E: string = '';
+  public static A: string;
+  public D: string = '';
+  constructor() {}
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'G',
-            rank: 'private static method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'H',
-            rank: 'private static method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           classExpressions: [
-            'public-method',
-            'protected-static-method',
-            'private-static-method',
-            'protected-instance-method',
-            'private-instance-method',
-            'constructor',
-            'field',
+            'public-instance-method',
+            'protected-static-field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
+  public D: string = '';
+  private L() {}
   private static I() {}
   protected static H() {}
-  protected static B: string = '';
   public static G() {}
   public J() {}
+  [Z: string]: any;
+  private constructor() {}
+  protected static B: string = '';
   protected K() {}
   private static C: string = '';
-  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
-  public D: string = '';
-  constructor() {}
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'L',
-            rank: 'protected static field',
-          },
-          line: 10,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
+          classes: [
+            'public-instance-method',
+            'protected-constructor',
+            'protected-static-method',
+          ],
           classExpressions: [
-            'private-instance-method',
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
             'protected-static-field',
           ],
         },
@@ -2054,399 +1231,301 @@ const foo = class {
     },
     {
       code: `
-const foo = class {
+const foo = class Foo {
+  public constructor() {}
+  public D: string = '';
   private L() {}
   private static I() {}
   protected static H() {}
   public static G() {}
-  protected static B: string = '';
   public J() {}
+  protected static B: string = '';
   protected K() {}
+  [Z: string]: any;
   private static C: string = '';
   private F: string = '';
   protected E: string = '';
   public static A: string;
-  public D: string = '';
-  constructor() {}
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'protected static field',
-          },
-          line: 8,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['public-instance-method', 'protected-static-field'],
+          classes: [
+            'public-instance-method',
+            'protected-constructor',
+            'protected-static-method',
+          ],
+          classExpressions: [
+            'public-instance-field',
+            'private-constructor',
+            'protected-instance-method',
+          ],
+          default: [
+            'public-instance-method',
+            'public-constructor',
+            'protected-static-field',
+          ],
         },
       ],
     },
+    `
+class Foo {
+  [Z: string]: any;
+  A: string;
+  constructor() {}
+  J() {}
+  K = () => {};
+}
+    `,
     {
       code: `
 class Foo {
+  J() {}
   K = () => {};
-  A: string;
   constructor() {}
+  A: string;
   [Z: string]: any;
-  J() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'public instance method',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'public instance method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'Z',
-            rank: 'public instance method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
+      options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
     },
     {
       code: `
 class Foo {
   J() {}
-  constructor() {}
   K = () => {};
-  A: string;
+  constructor() {}
   [Z: string]: any;
+  A: string;
+  L: () => {};
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'constructor',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
     },
     {
       code: `
 class Foo {
-  J() {}
-  constructor() {}
-  K = () => {};
-  L: () => {};
-  A: string;
+  static {}
+  m() {}
+  f = 1;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'K',
-            rank: 'constructor',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'constructor', 'field'] }],
+      options: [{ default: ['static-initialization', 'method', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  m() {}
+  f = 1;
+  static {}
+}
+      `,
+      options: [{ default: ['method', 'field', 'static-initialization'] }],
     },
     {
       code: `
+class Foo {
+  f = 1;
+  static {}
+  m() {}
+}
+      `,
+      options: [{ default: ['field', 'static-initialization', 'method'] }],
+    },
+    `
 interface Foo {
+  [Z: string]: any;
+  A: string;
   K: () => {};
   J();
+}
+    `,
+    {
+      code: `
+interface Foo {
+  [Z: string]: any;
+  J();
+  K: () => {};
   A: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
+      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
     },
-    {
-      code: `
+    `
 type Foo = {
+  [Z: string]: any;
+  A: string;
   K: () => {};
   J();
-  A: string;
 };
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-    },
+    `,
     {
       code: `
 type Foo = {
-  A: string;
-  K: () => {};
   J();
+  [Z: string]: any;
+  K: () => {};
+  A: string;
 };
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['method', 'constructor', 'field'] }],
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
     },
     {
       code: `
 abstract class Foo {
-  abstract A(): void;
+  B: string;
+  abstract A: () => {};
+}
+      `,
+    },
+    {
+      code: `
+interface Foo {
+  [A: string]: number;
   B: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'public abstract method',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
     },
     {
       code: `
 abstract class Foo {
-  abstract A: () => {};
+  [Z: string]: any;
+  private static C: string;
   B: string;
+  private D: string;
+  protected static F(): {};
+  public E(): {};
+  public abstract A(): void;
+  protected abstract G(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'public abstract field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
     },
     {
       code: `
 abstract class Foo {
-  abstract A: () => {};
+  protected typeChecker: (data: any) => boolean;
+  public abstract required: boolean;
+  abstract verify(): void;
+}
+      `,
+      options: [{ classes: ['signature', 'field', 'constructor', 'method'] }],
+    },
+    {
+      code: `
+class Foo {
+  @Dec() B: string;
+  @Dec() A: string;
+  constructor() {}
+  D: string;
+  C: string;
+  E(): void;
+  F(): void;
+}
+      `,
+      options: [{ default: ['decorated-field', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  A: string;
   B: string;
-  public C() {}
-  private D() {}
-  abstract E() {}
+  @Dec() private C: string;
+  private D: string;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'public abstract field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
+          default: ['public-field', 'private-decorated-field', 'private-field'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  C: number;
-  [A: string]: number;
-  public static D(): {};
-  static [B: string]: number;
+  constructor() {}
+  @Dec() public A(): void {}
+  @Dec() private B: string;
+  private C(): void;
+  private D: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'signature',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: [
-            'field',
-            'method',
-            'public-static-method',
-            'private-static-method',
-            'signature',
+            'decorated-method',
+            'private-decorated-field',
+            'private-method',
           ],
         },
       ],
     },
     {
       code: `
-abstract class Foo {
-  abstract B: string;
-  abstract A(): void;
-  public C(): {};
+class Foo {
+  @Dec() private A(): void {}
+  @Dec() private B: string;
+  constructor() {}
+  private C(): void;
+  private D: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
+          default: [
+            'private-decorated-method',
+            'private-decorated-field',
+            'constructor',
+            'private-field',
+          ],
         },
       ],
-      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
-  B: string;
-  @Dec() A: string = '';
-  C: string = '';
-  constructor() {}
-  D() {}
-  E() {}
+  public A: string;
+  @Dec() private B: string;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
+          classes: ['public-instance-field', 'private-decorated-field'],
+          default: ['private-decorated-field', 'public-instance-field'],
         },
       ],
-      options: [{ default: ['decorated-field', 'field'] }],
     },
+    // class + ignore decorator
     {
       code: `
 class Foo {
-  A() {}
+  public A(): string;
+  @Dec() public B(): string {}
+  public C(): string;
 
-  @Decorator()
-  B() {}
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'method',
-          },
-          line: 5, // Symbol starts at the line with decorator
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [{ default: ['decorated-method', 'method'] }],
-    },
-    {
-      code: `
-class Foo {
-  @Decorator() C() {}
-  A() {}
+  d: string;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'decorated method',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
+          default: ['public-method', 'field'],
         },
       ],
-      options: [{ default: ['public-method', 'decorated-method'] }],
     },
     {
       code: `
 class Foo {
-  A(): void;
-  B(): void;
-  private C() {}
+  A: string;
   constructor() {}
-  @Dec() private D() {}
+  get B() {}
+  set B() {}
+  get C() {}
+  set C() {}
+  D(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'private method',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          classes: ['public-method', 'decorated-method', 'private-method'],
+          default: ['field', 'constructor', ['get', 'set'], 'method'],
         },
       ],
     },
@@ -2454,28 +1533,13 @@ class Foo {
       code: `
 class Foo {
   A: string;
-  get B() {}
   constructor() {}
-  set B() {}
-  get C() {}
-  set C() {}
-  D(): void;
+  B(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'get, set',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['field', 'constructor', ['get', 'set'], 'method'],
+          default: ['field', 'constructor', [], 'method'],
         },
       ],
     },
@@ -2483,24 +1547,13 @@ class Foo {
       code: `
 class Foo {
   A: string;
-  private C(): void;
   constructor() {}
   @Dec() private B: string;
+  private C(): void;
   set D() {}
   E(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'private decorated field, public set, private method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: [
@@ -2518,357 +1571,193 @@ class Foo {
   A: string;
   constructor() {}
   get B() {}
-  set B() {}
   get C() {}
+  set B() {}
   set C() {}
   D(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'set',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['field', 'constructor', 'get', ['set'], 'method'],
+          default: ['field', 'constructor', ['get'], ['set'], 'method'],
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  static {}
-  m() {}
-  f = 1;
+  imPublic() {}
+  #imPrivate() {}
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'm',
-            rank: 'static initialization',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
+      name: 'with private identifier',
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'f',
-            rank: 'static initialization',
+          default: {
+            memberTypes: ['public-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
           },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
         },
       ],
-      options: [{ default: ['method', 'field', 'static-initialization'] }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  m() {}
-  f = 1;
-  static {}
+  private imPrivate() {}
+  #imPrivate() {}
 }
       `,
-      errors: [
+      name: 'private and #private member order',
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'static block',
-            rank: 'method',
+          default: {
+            memberTypes: ['private-method', '#private-method'],
+            order: 'alphabetically-case-insensitive',
           },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
         },
       ],
-      options: [{ default: ['static-initialization', 'method', 'field'] }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  f = 1;
-  static {}
-  m() {}
+  #imPrivate() {}
+  private imPrivate() {}
 }
       `,
-      errors: [
+      name: '#private and private member order',
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'static block',
-            rank: 'field',
+          default: {
+            memberTypes: ['#private-method', 'private-method'],
+            order: 'alphabetically-case-insensitive',
           },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
         },
       ],
-      options: [{ default: ['static-initialization', 'field', 'method'] }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  static {}
-  f = 1;
-  m() {}
+  [A: string]: any;
+  [a: string]: any;
+  static C: boolean;
+  static d: boolean;
+  b: any;
+  B: any;
+  get e(): string {}
+  get E(): string {}
+  private imPrivate() {}
+  private ImPrivate() {}
 }
       `,
-      errors: [
+      name: 'default member types with alphabetically-case-insensitive order',
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'f',
-            rank: 'static initialization',
+          default: {
+            order: 'alphabetically-case-insensitive',
           },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
         },
       ],
-      options: [{ default: ['field', 'static-initialization', 'method'] }],
     },
     {
       code: `
 class Foo {
-  private mp() {}
-  static {}
-  public m() {}
-  @dec
-  md() {}
+  readonly B: string;
+  readonly A: string;
+  constructor() {}
+  D: string;
+  C: string;
+  E(): void;
+  F(): void;
 }
       `,
-      errors: [
+      options: [{ default: ['readonly-field', 'field'] }],
+    },
+    {
+      code: `
+class Foo {
+  A: string;
+  B: string;
+  private readonly C: string;
+  private D: string;
+}
+      `,
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'static block',
-            rank: 'method',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'md',
-            rank: 'method',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        { default: ['decorated-method', 'static-initialization', 'method'] },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-class Foo {
-  #imPrivate() {}
-  imPublic() {}
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'imPublic',
-            rank: '#private method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      name: 'with private identifier',
-      options: [
-        {
-          default: {
-            memberTypes: ['public-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
-          },
+          default: ['public-field', 'private-readonly-field', 'private-field'],
         },
       ],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
-  #imPrivate() {}
-  private imPrivate() {}
+  private readonly A: string;
+  constructor() {}
+  private B: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'imPrivate',
-            rank: '#private method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      name: 'private and #private member order',
       options: [
         {
-          default: {
-            memberTypes: ['private-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
-          },
+          default: ['private-readonly-field', 'constructor', 'private-field'],
         },
       ],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
-  static C: boolean;
-  [B: string]: any;
-  private A() {}
+  public A: string;
+  private readonly B: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'public static field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      name: 'default member types with alphabetically order',
       options: [
         {
-          default: {
-            order: 'alphabetically',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-class Foo {
-  static C: boolean;
-  [B: string]: any;
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            beforeMember: 'C',
-            member: 'B',
-          },
-          line: 5,
-          messageId: 'incorrectOrder',
+          classes: ['public-instance-field', 'private-readonly-field'],
+          default: ['private-readonly-field', 'public-instance-field'],
         },
       ],
-      name: 'alphabetically order without member types',
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
     },
+    // class + ignore readonly
     {
       code: `
-// no accessibility === public
 class Foo {
-  private imPrivate() {}
-  #imPrivate() {}
+  public A(): string;
+  public B(): string;
+  public C(): string;
+
+  d: string;
+  readonly e: string;
+  f: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'imPrivate',
-            rank: 'private method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      name: '#private and private member order',
       options: [
         {
-          default: {
-            memberTypes: ['#private-method', 'private-method'],
-            order: 'alphabetically-case-insensitive',
-          },
-        },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-class Foo {
-  B: string;
-  readonly A: string = '';
-  C: string = '';
-  constructor() {}
-  D() {}
-  E() {}
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'A',
-            rank: 'field',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
+          default: ['public-method', 'field'],
         },
       ],
-      options: [{ default: ['readonly-field', 'field'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  private C(): void;
+  private readonly A: string;
+  readonly B: string;
+  C: string;
   constructor() {}
-  private readonly B: string;
-  set D() {}
-  E(): void;
+  @Dec() private D: string;
+  private E(): void;
+  set F() {}
+  G(): void;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'constructor',
-            rank: 'public set, private method',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'public field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: [
-            'private-readonly-field',
+            'readonly-field',
             'public-field',
             'constructor',
-            ['public-set', 'private-method'],
+            ['private-decorated-field', 'public-set', 'private-method'],
             'public-method',
           ],
         },
@@ -2877,61 +1766,6 @@ class Foo {
     {
       code: `
 abstract class Foo {
-  @Dec public readonly A: string;
-  public readonly B: string;
-  public static readonly C: string;
-  static readonly #D: string;
-  readonly #E: string;
-
-  @Dec public F: string;
-  public G: string;
-  public static H: string;
-  static readonly #I: string;
-  readonly #J: string;
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'F',
-            rank: 'readonly field',
-          },
-          line: 9,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'I',
-            rank: 'field',
-          },
-          line: 12,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'J',
-            rank: 'field',
-          },
-          line: 13,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
-      options: [
-        {
-          default: ['decorated-field', 'readonly-field', 'field'],
-        },
-      ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
-
   public static readonly SA: string;
   protected static readonly SB: string;
   private static readonly SC: string;
@@ -2944,232 +1778,378 @@ abstract class Foo {
 
   public abstract readonly AA: string;
   protected abstract readonly AB: string;
+
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'AA',
-            rank: 'static readonly field',
-          },
-          line: 17,
-          messageId: 'incorrectGroupOrder',
-        },
+      options: [
         {
-          column: 3,
-          data: {
-            name: 'AB',
-            rank: 'static readonly field',
-          },
-          line: 18,
-          messageId: 'incorrectGroupOrder',
+          default: [
+            'public-static-readonly-field',
+            'protected-static-readonly-field',
+            'private-static-readonly-field',
+            '#private-static-readonly-field',
+
+            'static-readonly-field',
+
+            'public-instance-readonly-field',
+            'protected-instance-readonly-field',
+            'private-instance-readonly-field',
+            '#private-instance-readonly-field',
+
+            'instance-readonly-field',
+
+            'public-readonly-field',
+            'protected-readonly-field',
+            'private-readonly-field',
+            '#private-readonly-field',
+
+            'readonly-field',
+
+            'public-abstract-readonly-field',
+            'protected-abstract-readonly-field',
+
+            'abstract-readonly-field',
+
+            'public-decorated-readonly-field',
+            'protected-decorated-readonly-field',
+            'private-decorated-readonly-field',
+            'decorated-readonly-field',
+          ],
         },
       ],
+    },
+    {
+      code: `
+abstract class Foo {
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
+
+  public static readonly SA: string;
+  protected static readonly SB: string;
+  private static readonly SC: string;
+  static readonly #SD: string;
+
+  public readonly IA: string;
+  protected readonly IB: string;
+  private readonly IC: string;
+  readonly #ID: string;
+
+  public abstract readonly AA: string;
+  protected abstract readonly AB: string;
+}
+      `,
       options: [
         {
           default: [
             'decorated-readonly-field',
-            'abstract-readonly-field',
             'static-readonly-field',
             'instance-readonly-field',
+            'abstract-readonly-field',
           ],
         },
       ],
     },
     {
       code: `
-interface Foo {
-  readonly A: string;
-  readonly B: string;
+abstract class Foo {
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
 
-  C: string;
-  D: string;
+  public static readonly SA: string;
+  public readonly IA: string;
+  public abstract readonly AA: string;
+
+  protected static readonly SB: string;
+  protected readonly IB: string;
+  protected abstract readonly AB: string;
+
+  private static readonly SC: string;
+  private readonly IC: string;
+
+  static readonly #SD: string;
+  readonly #ID: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'C',
-            rank: 'readonly field',
-          },
-          line: 6,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'D',
-            rank: 'readonly field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['field', 'readonly-field'],
+          default: [
+            'decorated-readonly-field',
+            'public-readonly-field',
+            'protected-readonly-field',
+            'private-readonly-field',
+          ],
         },
       ],
     },
     {
       code: `
-interface Foo {
-  [i: number]: string;
-  readonly [i: string]: string;
+abstract class Foo {
+  @Dec public readonly DA: string;
+  @Dec protected readonly DB: string;
+  @Dec private readonly DC: string;
 
-  A: string;
-  readonly B: string;
+  public static readonly SA: string;
+  public readonly IA: string;
+  static readonly #SD: string;
+  readonly #ID: string;
+
+  protected static readonly SB: string;
+  protected readonly IB: string;
+
+  private static readonly SC: string;
+  private readonly IC: string;
+
+  public abstract readonly AA: string;
+  protected abstract readonly AB: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'i',
-            rank: 'signature',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-        {
-          column: 3,
-          data: {
-            name: 'B',
-            rank: 'field',
-          },
-          line: 7,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
           default: [
-            'readonly-signature',
-            'signature',
-            'readonly-field',
-            'field',
+            'decorated-readonly-field',
+            ['public-readonly-field', 'readonly-field'],
+            'protected-readonly-field',
+            'private-readonly-field',
+            'abstract-readonly-field',
           ],
         },
       ],
     },
     {
       code: `
-class Foo {
-  accessor bar;
+abstract class Foo {
+  @Dec public readonly A: string;
+  @Dec public B: string;
 
-  baz() {}
+  public readonly C: string;
+  public static readonly D: string;
+  public E: string;
+  public static F: string;
+
+  static readonly #G: string;
+  readonly #H: string;
+  static #I: string;
+  #J: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'baz',
-            rank: 'accessor',
-          },
-          line: 5,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['method', 'accessor'],
+          default: [
+            ['decorated-field', 'decorated-readonly-field'],
+            ['field', 'readonly-field'],
+            ['#private-field', '#private-readonly-field'],
+          ],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  y(): void;
-  get x(): number;
+  readonly A: string;
+  readonly B: string;
+
+  C: string;
+  D: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'x',
-            rank: 'method',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['get', 'method'],
+          default: ['readonly-field', 'field'],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  get x(): number;
-  y(): void;
+  readonly [i: string]: string;
+  readonly A: string;
+
+  [i: number]: string;
+  B: string;
 }
       `,
-      errors: [
-        {
-          column: 3,
-          data: {
-            name: 'y',
-            rank: 'get',
-          },
-          line: 4,
-          messageId: 'incorrectGroupOrder',
-        },
-      ],
       options: [
         {
-          default: ['method', 'get'],
+          default: [
+            'readonly-signature',
+            'readonly-field',
+            'signature',
+            'field',
+          ],
         },
       ],
     },
-  ],
-  valid: [
-    `
-// no accessibility === public
-interface Foo {
-  [Z: string]: any;
-  A: string;
+    {
+      code: `
+interface Foo {
+  readonly [i: string]: string;
+  [i: number]: string;
+
+  readonly A: string;
   B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
 }
-    `,
+      `,
+      options: [
+        {
+          default: [
+            'readonly-signature',
+            'signature',
+            'readonly-field',
+            'field',
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  readonly A: string;
+  B: string;
+
+  [i: number]: string;
+  readonly [i: string]: string;
+}
+      `,
+      options: [
+        {
+          default: ['readonly-field', 'field', 'signature'],
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6812
+    {
+      code: `
+class Foo {
+  #bar: string;
+
+  get bar(): string {
+    return this.#bar;
+  }
+
+  set bar(value: string) {
+    this.#bar = value;
+  }
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: [['get', 'set']],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+// no accessibility === public
+class Foo {
+  [A: string]: any;
+  [B: string]: any;
+  [a: string]: any;
+  [b: string]: any;
+  static C: boolean;
+  static d: boolean;
+  get E(): string {}
+  get e(): string {}
+  private ImPrivate() {}
+  private imPrivate() {}
+}
+      `,
+      name: 'default member types with alphabetically order',
+      options: [
+        {
+          default: {
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
     {
       code: `
 // no accessibility === public
 interface Foo {
   A: string;
-  J();
-  K();
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  G();
-  H();
-  [Z: string]: any;
   B: string;
-  C: string;
-  I();
-  L();
+  [Z: string]: any;
+  c();
+  new ();
+  r();
 }
       `,
-      options: [{ default: 'never' }],
+      name: 'alphabetically order without member types',
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+    {
+      code: `
+class Foo {
+  #bar: string;
+
+  get bar(): string {
+    return this.#bar;
+  }
+
+  set bar(value: string) {
+    this.#bar = value;
+  }
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: [['get', 'set']],
+            order: 'natural',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  accessor bar;
+
+  baz() {}
+}
+      `,
+      options: [
+        {
+          default: ['accessor', 'method'],
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  get x(): number;
+  y(): void;
+}
+      `,
+      options: [
+        {
+          default: ['get', 'method'],
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo {
+  y(): void;
+  get x(): number;
+}
+      `,
+      options: [
+        {
+          default: ['method', 'get'],
+        },
+      ],
     },
+  ],
+  invalid: [
     {
       code: `
 // no accessibility === public
@@ -3181,25 +2161,46 @@ interface Foo {
   D: string;
   E: string;
   F: string;
-  new ();
   G();
   H();
   I();
   J();
   K();
   L();
+  new ();
 }
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 interface X {
-  (): void;
   a: unknown;
+  (): void;
   b(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'call',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['call-signature', 'field', 'method'] }],
     },
     {
@@ -3207,51 +2208,107 @@ interface X {
 // no accessibility === public
 interface Foo {
   A: string;
-  J();
-  K();
+  B: string;
+  C: string;
   D: string;
-  [Z: string]: any;
   E: string;
   F: string;
-  new ();
   G();
-  B: string;
-  C: string;
   H();
   I();
+  J();
+  K();
   L();
+  new ();
+  [Z: string]: any;
 }
       `,
-      options: [{ interfaces: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
-  [Z: string]: any;
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  new ();
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-}
-      `,
-      options: [
-        { interfaces: ['signature', 'method', 'constructor', 'field'] },
-      ],
-    },
-    {
-      code: `
-// no accessibility === public
-interface Foo {
   G();
   H();
   I();
@@ -3259,50 +2316,185 @@ interface Foo {
   K();
   L();
   new ();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
   [Z: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['signature', 'field', 'constructor', 'method'],
-          interfaces: ['method', 'constructor', 'field', 'signature'],
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [
+        { interfaces: ['method', 'signature', 'constructor', 'field'] },
+      ],
     },
     {
       code: `
 // no accessibility === public
 interface Foo {
-  G();
-  H();
-  I();
-  new ();
-  [Z: string]: any;
+  A: string;
+  B: string;
+  C: string;
   D: string;
   E: string;
   F: string;
-  G?: string;
+  G();
+  H();
+  I();
   J();
   K();
   L();
-  A: string;
-  B: string;
-  C: string;
+  new ();
+  [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'private-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
+          default: ['field', 'method', 'constructor', 'signature'],
+          interfaces: ['method', 'signature', 'constructor', 'field'],
         },
       ],
     },
@@ -3310,73 +2502,111 @@ interface Foo {
       code: `
 // no accessibility === public
 interface Foo {
+  [Z: string]: any;
+  new ();
+  A: string;
   G();
+  B: string;
   H();
+  C: string;
   I();
-  J();
-  K();
-  L();
-  [Z: string]: any;
   D: string;
+  J();
   E: string;
+  K();
   F: string;
-  new ();
-  A: string;
-  B: string;
-  C: string;
+  L();
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'method',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'method',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['method', 'public-constructor', 'protected-static-field'],
+          interfaces: ['signature', 'constructor', 'field', 'method'],
         },
       ],
     },
-    `
-// no accessibility === public
-type Foo = {
-  [Z: string]: any;
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  new ();
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-};
-    `,
     {
       code: `
 // no accessibility === public
 type Foo = {
+  [Z: string]: any;
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-  [Z: string]: any;
   G();
   H();
   I();
   J();
   K();
   L();
+  new ();
 };
       `,
-      options: [{ default: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  [Z: string]: any;
   A: string;
   B: string;
   C: string;
@@ -3389,16 +2619,91 @@ type Foo = {
   J();
   K();
   L();
+  [Z: string]: any;
+  new ();
 };
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
   [Z: string]: any;
-  new ();
   A: string;
   B: string;
   C: string;
@@ -3411,98 +2716,176 @@ type Foo = {
   J();
   K();
   L();
+  new ();
 };
       `,
-      options: [{ default: ['field', 'method'] }],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
-  G();
-  H();
-  [Z: string]: any;
-  K();
-  L();
-  A: string;
-  B: string;
-  I();
-  J();
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-};
-      `,
-      options: [{ typeLiterals: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'signature',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'signature',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'signature',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'signature',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'signature',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'signature',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'signature',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        { typeLiterals: ['method', 'constructor', 'signature', 'field'] },
+      ],
     },
     {
       code: `
 // no accessibility === public
 type Foo = {
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
   A: string;
   B: string;
   C: string;
   D: string;
   E: string;
   F: string;
-  [Z: string]: any;
-};
-      `,
-      options: [{ typeLiterals: ['method', 'field', 'signature'] }],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
   G();
   H();
   I();
   J();
   K();
   L();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
+  new ();
   [Z: string]: any;
 };
       `,
-      options: [
-        { typeLiterals: ['method', 'constructor', 'field', 'signature'] },
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'new',
+            rank: 'field',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
       ],
-    },
-    {
-      code: `
-// no accessibility === public
-type Foo = {
-  G();
-  H();
-  I();
-  J();
-  K();
-  L();
-  A: string;
-  B: string;
-  C: string;
-  D: string;
-  E: string;
-  F: string;
-  [Z: string]: any;
-};
-      `,
       options: [
         {
-          default: ['signature', 'field', 'constructor', 'method'],
-          typeLiterals: ['method', 'constructor', 'field', 'signature'],
+          default: ['field', 'method', 'constructor', 'signature'],
+          typeLiterals: ['signature', 'method', 'constructor', 'field'],
         },
       ],
     },
@@ -3510,36 +2893,80 @@ type Foo = {
       code: `
 // no accessibility === public
 type Foo = {
+  new ();
   [Z: string]: any;
-  D: string;
-  E: string;
-  F: string;
   A: string;
-  B: string;
-  C: string;
   G();
+  B: string;
   H();
+  C: string;
   I();
+  D: string;
   J();
+  E: string;
   K();
+  F: string;
   L();
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'method',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'method',
+          },
+          line: 16,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
-          typeLiterals: ['signature', 'field', 'method'],
+          typeLiterals: ['constructor', 'signature', 'field', 'method'],
         },
       ],
     },
-    `
+    {
+      code: `
 class Foo {
   [Z: string]: any;
-  public static A: string;
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -3548,21 +2975,60 @@ class Foo {
   private F: string = '';
   #F: string = '';
   constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
   #L() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
+  static #I() {}
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'public instance method',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 18,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 19,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 20,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
     {
       code: `
 class Foo {
-  [Z: string]: any;
-  public static A: string;
+  constructor() {}
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   static #C: string = '';
@@ -3570,154 +3036,226 @@ class Foo {
   protected E: string = '';
   private F: string = '';
   #F: string = '';
-  constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
   #L() {}
-}
-      `,
-      options: [{ default: 'never' }],
-    },
-    {
-      code: `
-class Foo {
-  [Z: string]: any;
-  public static A: string;
-  protected static B: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  public D: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #F: string = '';
-  constructor() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   static #I() {}
-  public J() {}
-  protected K() {}
-  private L() {}
-  #L() {}
+  [Z: string]: any;
 }
       `,
-      options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'constructor',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'constructor',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'constructor',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['field', 'constructor', 'method', 'signature'] }],
     },
     {
       code: `
 class Foo {
-  [Z: string]: any;
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
-  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  #F: string = '';
   public static G() {}
+  public static A: string;
   protected static H() {}
   private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
-  #L() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
 class Foo {
-  public static G() {}
-  protected K() {}
-  private L() {}
-  private static I() {}
-  public J() {}
-  public D: string = '';
-  [Z: string]: any;
-  protected static H() {}
-  public static A: string;
-  protected static B: string = '';
-  constructor() {}
-  private static C: string = '';
-  protected E: string = '';
-  private F: string = '';
-}
-      `,
-      options: [{ classes: 'never' }],
-    },
-    {
-      code: `
-class Foo {
-  public static G() {}
   protected static H() {}
   private static I() {}
-  static #I() {}
   public J() {}
   protected K() {}
   private L() {}
-  #L() {}
-  [Z: string]: any;
   public static A: string;
+  public static G() {}
   protected static B: string = '';
   private static C: string = '';
-  static #C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  #F: string = '';
   constructor() {}
 }
       `,
-      options: [{ classes: ['method', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'field'] }],
     },
     {
       code: `
 class Foo {
   public static G() {}
   protected static H() {}
+  protected static B: string = '';
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  constructor() {}
   public static A: string;
-  protected static B: string = '';
+  constructor() {}
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  [Z: string]: any;
-}
-      `,
-      options: [{ classes: ['method', 'constructor', 'field', 'signature'] }],
-    },
-    {
-      code: `
-class Foo {
-  private required: boolean;
-  private typeChecker: (data: any) => boolean;
-  constructor(validator: (data: any) => boolean) {
-    this.typeChecker = validator;
-  }
-  check(data: any): boolean {
-    return this.typeChecker(data);
-  }
 }
       `,
-      options: [{ classes: ['field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ classes: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
 class Foo {
+  public static A: string;
   public static G() {}
   protected static H() {}
   private static I() {}
@@ -3725,52 +3263,132 @@ class Foo {
   protected K() {}
   private L() {}
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: ['method', 'constructor', 'field', 'signature'],
-          default: ['signature', 'field', 'constructor', 'method'],
+          classes: ['method', 'constructor', 'field'],
+          default: ['field', 'constructor', 'method'],
         },
       ],
     },
     {
       code: `
 class Foo {
+  private L() {}
   public J() {}
   public static G() {}
   protected static H() {}
   private static I() {}
   protected K() {}
-  private L() {}
-  [Z: string]: any;
   constructor() {}
   public D: string = '';
+  private static C: string = '';
   public static A: string;
   private static C: string = '';
+  protected static B: string = '';
   private F: string = '';
-  static #M: string = '';
-  #N: string = '';
   protected static B: string = '';
   protected E: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'private field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'protected field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classes: [
             'public-method',
-            'signature',
             'constructor',
             'public-field',
             'private-field',
-            '#private-field',
             'protected-field',
           ],
         },
@@ -3781,21 +3399,39 @@ class Foo {
 class Foo {
   public static G() {}
   private static I() {}
-  protected static H() {}
   public J() {}
+  protected static H() {}
   private L() {}
   protected K() {}
-  [Z: string]: any;
-  constructor() {}
   public D: string = '';
+  constructor() {}
   public static A: string;
   protected static B: string = '';
   protected E: string = '';
   private static C: string = '';
   private F: string = '';
-  #M: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classes: [
@@ -3803,12 +3439,10 @@ class Foo {
             'static-method',
             'public-instance-method',
             'instance-method',
-            'signature',
             'constructor',
             'public-field',
             'protected-field',
             'private-field',
-            '#private-field',
           ],
         },
       ],
@@ -3820,307 +3454,291 @@ class Foo {
   public static G() {}
   public D: string = '';
   public static A: string = '';
+  private L() {}
   constructor() {}
   protected K() {}
-  private L() {}
-  #P() {}
-  protected static H() {}
-  private static I() {}
-  static #O() {}
-  protected static B: string = '';
-  private static C: string = '';
-  static #N: string = '';
-  protected E: string = '';
-  private F: string = '';
-  #M: string = '';
-  [Z: string]: any;
-}
-      `,
-      options: [
-        {
-          default: [
-            'public-method',
-            'public-field',
-            'constructor',
-            'method',
-            'field',
-            'signature',
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  public J() {}
-  public static G() {}
   protected static H() {}
   private static I() {}
-  static #I() {}
-  protected K() {}
-  private L() {}
-  #L() {}
-  constructor() {}
-  [Z: string]: any;
-  public static A: string;
-  private F: string = '';
-  #F: string = '';
-  protected static B: string = '';
-  public D: string = '';
-  private static C: string = '';
-  static #C: string = '';
-  protected E: string = '';
-}
-      `,
-      options: [
-        {
-          classes: [
-            'public-method',
-            'protected-static-method',
-            '#private-static-method',
-            'protected-instance-method',
-            'private-instance-method',
-            '#private-instance-method',
-            'constructor',
-            'signature',
-            'field',
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  private L() {}
-  private static I() {}
-  protected static H() {}
   protected static B: string = '';
-  public static G() {}
-  public J() {}
-  protected K() {}
   private static C: string = '';
-  private F: string = '';
   protected E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
-  [Z: string]: any;
-}
-      `,
-      options: [
-        {
-          classes: ['private-instance-method', 'protected-static-field'],
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  private L() {}
-  private static I() {}
-  static #H() {}
-  static #B: string = '';
-  public static G() {}
-  public J() {}
-  #K() {}
-  private static C: string = '';
   private F: string = '';
-  #E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
-  [Z: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          classes: ['private-instance-method', 'protected-static-field'],
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
         },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  private L() {}
-  private static I() {}
-  protected static H() {}
-  public static G() {}
-  public J() {}
-  protected static B: string = '';
-  protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
-  [Z: string]: any;
-}
-      `,
+      ],
       options: [
         {
-          default: ['public-instance-method', 'protected-static-field'],
+          default: [
+            'public-method',
+            'public-field',
+            'constructor',
+            'method',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  private L() {}
+  public J() {}
   private static I() {}
-  protected static H() {}
   public static G() {}
-  public J() {}
-  protected static B: string = '';
+  protected static H() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
+  private L() {}
+  constructor() {}
   public static A: string;
+  private F: string = '';
+  protected static B: string = '';
   public D: string = '';
-  constructor() {}
-  [Z: string]: any;
+  private static C: string = '';
+  protected E: string = '';
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'private static method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'private static method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: ['public-instance-method', 'protected-static-field'],
+          classes: [
+            'public-method',
+            'protected-static-method',
+            'private-static-method',
+            'protected-instance-method',
+            'private-instance-method',
+            'constructor',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
 class Foo {
-  [Z: string]: any;
-  public D: string = '';
-  private L() {}
   private static I() {}
   protected static H() {}
+  protected static B: string = '';
   public static G() {}
   public J() {}
-  private constructor() {}
-  protected static B: string = '';
   protected K() {}
   private static C: string = '';
+  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'protected static field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
+          classes: ['private-instance-method', 'protected-static-field'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  public constructor() {}
-  public D: string = '';
   private L() {}
   private static I() {}
   protected static H() {}
   public static G() {}
-  public J() {}
-  [Z: string]: any;
   protected static B: string = '';
+  public J() {}
   protected K() {}
   private static C: string = '';
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'protected static field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
+          default: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
-    `
+    {
+      code: `
 const foo = class Foo {
-  [Z: string]: any;
-  public static A: string;
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
   constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-};
-    `,
-    {
-      code: `
-const foo = class Foo {
-  constructor() {}
-  public static A: string;
-  protected static B: string = '';
-  private static I() {}
-  public J() {}
-  private F: string = '';
-  [Z: string]: any;
   public static G() {}
-  private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
   protected static H() {}
-  protected K() {}
-  private L() {}
+  private static I() {}
 };
       `,
-      options: [{ default: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'public instance method',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 14,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'public instance method',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   [Z: string]: any;
-  public static A: string;
+  constructor() {}
+  public static A: string = '';
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  constructor() {}
-  public static G() {}
-  protected static H() {}
-  private static I() {}
   public J() {}
   protected K() {}
   private L() {}
+  public static G() {}
+  protected static H() {}
+  private static I() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'constructor',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'constructor',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'constructor',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'E',
+            rank: 'constructor',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'constructor',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
@@ -4128,6 +3746,7 @@ const foo = class Foo {
   private F: string = '';
   [Z: string]: any;
   public static G() {}
+  public static A: string;
   protected static H() {}
   private static I() {}
   public J() {}
@@ -4135,62 +3754,129 @@ const foo = class Foo {
   private L() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['field', 'method'] }],
     },
     {
       code: `
-const foo = class Foo {
-  private L() {}
+const foo = class {
   protected static H() {}
-  constructor() {}
   private static I() {}
   public J() {}
-  private static C: string = '';
-  [Z: string]: any;
-  public D: string = '';
   protected K() {}
-  public static G() {}
+  private L() {}
   public static A: string;
+  public static G() {}
   protected static B: string = '';
+  private static C: string = '';
+  public D: string = '';
   protected E: string = '';
   private F: string = '';
+  constructor() {}
 };
       `,
-      options: [{ classExpressions: 'never' }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'field'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
   public static G() {}
   protected static H() {}
+  protected static B: string = '';
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
   public static A: string;
-  protected static B: string = '';
+  constructor() {}
+  [Z: string]: any;
   private static C: string = '';
   public D: string = '';
   protected E: string = '';
   private F: string = '';
-  constructor() {}
-  [Z: string]: any;
 };
       `,
-      options: [{ classExpressions: ['method', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 11,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ classExpressions: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
+  public static A: string;
   public static G() {}
   protected static H() {}
   private static I() {}
   public J() {}
   protected K() {}
   private L() {}
-  [Z: string]: any;
   constructor() {}
-  public static A: string;
   protected static B: string = '';
   private static C: string = '';
   public D: string = '';
@@ -4198,151 +3884,309 @@ const foo = class Foo {
   private F: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
-        { classExpressions: ['method', 'signature', 'constructor', 'field'] },
+        {
+          classExpressions: ['method', 'constructor', 'field'],
+          default: ['field', 'constructor', 'method'],
+        },
       ],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
+  private L() {}
+  public J() {}
   public static G() {}
   protected static H() {}
   private static I() {}
-  public J() {}
   protected K() {}
-  private L() {}
-  [Z: string]: any;
   constructor() {}
+  public D: string = '';
+  private static C: string = '';
   public static A: string;
-  protected static B: string = '';
   private static C: string = '';
-  public D: string = '';
-  protected E: string = '';
+  protected static B: string = '';
   private F: string = '';
+  protected static B: string = '';
+  protected E: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'private field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'protected field',
+          },
+          line: 15,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classExpressions: ['method', 'signature', 'constructor', 'field'],
-          default: ['field', 'constructor', 'method'],
+          classExpressions: [
+            'public-method',
+            'constructor',
+            'public-field',
+            'private-field',
+            'protected-field',
+          ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  [Z: string]: any;
-  private L() {}
-  private static I() {}
-  protected static H() {}
-  protected static B: string = '';
+const foo = class {
   public static G() {}
+  private static I() {}
   public J() {}
+  protected static H() {}
+  private L() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
-  public static A: string;
   public D: string = '';
   constructor() {}
+  public static A: string;
+  protected static B: string = '';
+  protected E: string = '';
+  private static C: string = '';
+  private F: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classExpressions: [
-            'private-instance-method',
-            'protected-static-field',
+            'public-static-method',
+            'static-method',
+            'public-instance-method',
+            'instance-method',
+            'constructor',
+            'public-field',
+            'protected-field',
+            'private-field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
+const foo = class {
+  public J() {}
+  public static G() {}
+  public D: string = '';
+  public static A: string = '';
   private L() {}
-  private static I() {}
+  constructor() {}
+  protected K() {}
   protected static H() {}
-  public static G() {}
-  public J() {}
-  [Z: string]: any;
+  private static I() {}
   protected static B: string = '';
-  protected K() {}
   private static C: string = '';
-  private F: string = '';
   protected E: string = '';
-  public static A: string;
-  public D: string = '';
-  constructor() {}
+  private F: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'method',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['public-instance-method', 'protected-static-field'],
+          default: [
+            'public-method',
+            'public-field',
+            'constructor',
+            'method',
+            'field',
+          ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  private L() {}
+const foo = class {
+  public J() {}
   private static I() {}
-  protected static H() {}
   public static G() {}
-  public J() {}
-  [Z: string]: any;
-  protected static B: string = '';
+  protected static H() {}
   protected K() {}
-  private static C: string = '';
-  private F: string = '';
-  protected E: string = '';
+  private L() {}
+  constructor() {}
   public static A: string;
+  private F: string = '';
+  protected static B: string = '';
   public D: string = '';
-  constructor() {}
+  private static C: string = '';
+  protected E: string = '';
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'G',
+            rank: 'private static method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'H',
+            rank: 'private static method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           classExpressions: [
-            'public-instance-method',
-            'protected-static-field',
+            'public-method',
+            'protected-static-method',
+            'private-static-method',
+            'protected-instance-method',
+            'private-instance-method',
+            'constructor',
+            'field',
           ],
         },
       ],
     },
     {
       code: `
-const foo = class Foo {
-  public D: string = '';
-  private L() {}
+const foo = class {
   private static I() {}
   protected static H() {}
+  protected static B: string = '';
   public static G() {}
   public J() {}
-  [Z: string]: any;
-  private constructor() {}
-  protected static B: string = '';
   protected K() {}
   private static C: string = '';
+  private L() {}
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'L',
+            rank: 'protected static field',
+          },
+          line: 10,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: [
-            'public-instance-method',
-            'protected-constructor',
-            'protected-static-method',
-          ],
           classExpressions: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
-          default: [
-            'public-instance-method',
-            'public-constructor',
+            'private-instance-method',
             'protected-static-field',
           ],
         },
@@ -4350,283 +4194,461 @@ const foo = class Foo {
     },
     {
       code: `
-const foo = class Foo {
-  public constructor() {}
-  public D: string = '';
+const foo = class {
   private L() {}
   private static I() {}
   protected static H() {}
   public static G() {}
-  public J() {}
   protected static B: string = '';
+  public J() {}
   protected K() {}
-  [Z: string]: any;
   private static C: string = '';
   private F: string = '';
   protected E: string = '';
   public static A: string;
+  public D: string = '';
+  constructor() {}
 };
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'protected static field',
+          },
+          line: 8,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: [
-            'public-instance-method',
-            'protected-constructor',
-            'protected-static-method',
-          ],
-          classExpressions: [
-            'public-instance-field',
-            'private-constructor',
-            'protected-instance-method',
-          ],
-          default: [
-            'public-instance-method',
-            'public-constructor',
-            'protected-static-field',
-          ],
+          default: ['public-instance-method', 'protected-static-field'],
         },
       ],
     },
-    `
+    {
+      code: `
 class Foo {
-  [Z: string]: any;
+  K = () => {};
   A: string;
   constructor() {}
+  [Z: string]: any;
   J() {}
-  K = () => {};
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'public instance method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public instance method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'Z',
+            rank: 'public instance method',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
     {
       code: `
 class Foo {
   J() {}
-  K = () => {};
   constructor() {}
+  K = () => {};
   A: string;
   [Z: string]: any;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
     },
     {
       code: `
 class Foo {
   J() {}
-  K = () => {};
   constructor() {}
-  [Z: string]: any;
-  A: string;
+  K = () => {};
   L: () => {};
-}
-      `,
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
-    },
-    {
-      code: `
-class Foo {
-  static {}
-  m() {}
-  f = 1;
-}
-      `,
-      options: [{ default: ['static-initialization', 'method', 'field'] }],
-    },
-    {
-      code: `
-class Foo {
-  m() {}
-  f = 1;
-  static {}
-}
-      `,
-      options: [{ default: ['method', 'field', 'static-initialization'] }],
-    },
-    {
-      code: `
-class Foo {
-  f = 1;
-  static {}
-  m() {}
-}
-      `,
-      options: [{ default: ['field', 'static-initialization', 'method'] }],
-    },
-    `
-interface Foo {
-  [Z: string]: any;
   A: string;
-  K: () => {};
-  J();
 }
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'K',
+            rank: 'constructor',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
+    },
     {
       code: `
 interface Foo {
-  [Z: string]: any;
-  J();
   K: () => {};
+  J();
   A: string;
 }
       `,
-      options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
-    `
+    {
+      code: `
 type Foo = {
-  [Z: string]: any;
-  A: string;
   K: () => {};
   J();
+  A: string;
 };
-    `,
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
     {
       code: `
 type Foo = {
-  J();
-  [Z: string]: any;
-  K: () => {};
   A: string;
+  K: () => {};
+  J();
 };
       `,
-      options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
 abstract class Foo {
+  abstract A(): void;
   B: string;
-  abstract A: () => {};
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
-interface Foo {
-  [A: string]: number;
+abstract class Foo {
+  abstract A: () => {};
   B: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
     },
     {
       code: `
 abstract class Foo {
-  [Z: string]: any;
-  private static C: string;
+  abstract A: () => {};
   B: string;
-  private D: string;
-  protected static F(): {};
-  public E(): {};
-  public abstract A(): void;
-  protected abstract G(): void;
+  public C() {}
+  private D() {}
+  abstract E() {}
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public abstract field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  C: number;
+  [A: string]: number;
+  public static D(): {};
+  static [B: string]: number;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'signature',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          default: [
+            'field',
+            'method',
+            'public-static-method',
+            'private-static-method',
+            'signature',
+          ],
+        },
+      ],
     },
     {
       code: `
 abstract class Foo {
-  protected typeChecker: (data: any) => boolean;
-  public abstract required: boolean;
-  abstract verify(): void;
+  abstract B: string;
+  abstract A(): void;
+  public C(): {};
 }
       `,
-      options: [{ classes: ['signature', 'field', 'constructor', 'method'] }],
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [{ default: ['method', 'constructor', 'field'] }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  @Dec() B: string;
-  @Dec() A: string;
+  B: string;
+  @Dec() A: string = '';
+  C: string = '';
   constructor() {}
-  D: string;
-  C: string;
-  E(): void;
-  F(): void;
+  D() {}
+  E() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [{ default: ['decorated-field', 'field'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  B: string;
-  @Dec() private C: string;
-  private D: string;
+  A() {}
+
+  @Decorator()
+  B() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['public-field', 'private-decorated-field', 'private-field'],
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'method',
+          },
+          line: 5, // Symbol starts at the line with decorator
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['decorated-method', 'method'] }],
     },
     {
       code: `
 class Foo {
-  constructor() {}
-  @Dec() public A(): void {}
-  @Dec() private B: string;
-  private C(): void;
-  private D: string;
+  @Decorator() C() {}
+  A() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'decorated-method',
-            'private-decorated-field',
-            'private-method',
-          ],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'decorated method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['public-method', 'decorated-method'] }],
     },
     {
       code: `
 class Foo {
-  @Dec() private A(): void {}
-  @Dec() private B: string;
+  A(): void;
+  B(): void;
+  private C() {}
   constructor() {}
-  private C(): void;
-  private D: string;
+  @Dec() private D() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'private-decorated-method',
-            'private-decorated-field',
-            'constructor',
-            'private-field',
-          ],
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'private method',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      options: [
+        {
+          classes: ['public-method', 'decorated-method', 'private-method'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  public A: string;
-  @Dec() private B: string;
+  A: string;
+  get B() {}
+  constructor() {}
+  set B() {}
+  get C() {}
+  set C() {}
+  D(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'get, set',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          classes: ['public-instance-field', 'private-decorated-field'],
-          default: ['private-decorated-field', 'public-instance-field'],
+          default: ['field', 'constructor', ['get', 'set'], 'method'],
         },
       ],
     },
-    // class + ignore decorator
     {
       code: `
 class Foo {
-  public A(): string;
-  @Dec() public B(): string {}
-  public C(): string;
-
-  d: string;
+  A: string;
+  private C(): void;
+  constructor() {}
+  @Dec() private B: string;
+  set D() {}
+  E(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'private decorated field, public set, private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['public-method', 'field'],
+          default: [
+            'public-field',
+            'constructor',
+            ['private-decorated-field', 'public-set', 'private-method'],
+            'public-method',
+          ],
         },
       ],
     },
@@ -4642,115 +4664,174 @@ class Foo {
   D(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'set',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: ['field', 'constructor', ['get', 'set'], 'method'],
+          default: ['field', 'constructor', 'get', ['set'], 'method'],
         },
       ],
     },
     {
       code: `
 class Foo {
-  A: string;
-  constructor() {}
-  B(): void;
+  static {}
+  m() {}
+  f = 1;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['field', 'constructor', [], 'method'],
+          column: 3,
+          data: {
+            name: 'm',
+            rank: 'static initialization',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'f',
+            rank: 'static initialization',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['method', 'field', 'static-initialization'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  constructor() {}
-  @Dec() private B: string;
-  private C(): void;
-  set D() {}
-  E(): void;
+  m() {}
+  f = 1;
+  static {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'public-field',
-            'constructor',
-            ['private-decorated-field', 'public-set', 'private-method'],
-            'public-method',
-          ],
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['static-initialization', 'method', 'field'] }],
     },
     {
       code: `
 class Foo {
-  A: string;
-  constructor() {}
-  get B() {}
-  get C() {}
-  set B() {}
-  set C() {}
-  D(): void;
+  f = 1;
+  static {}
+  m() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['field', 'constructor', ['get'], ['set'], 'method'],
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'field',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['static-initialization', 'field', 'method'] }],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
-  imPublic() {}
-  #imPrivate() {}
+  static {}
+  f = 1;
+  m() {}
 }
       `,
-      name: 'with private identifier',
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: ['public-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'f',
+            rank: 'static initialization',
           },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['field', 'static-initialization', 'method'] }],
     },
     {
       code: `
-// no accessibility === public
 class Foo {
-  private imPrivate() {}
-  #imPrivate() {}
+  private mp() {}
+  static {}
+  public m() {}
+  @dec
+  md() {}
 }
       `,
-      name: 'private and #private member order',
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: ['private-method', '#private-method'],
-            order: 'alphabetically-case-insensitive',
+          column: 3,
+          data: {
+            name: 'static block',
+            rank: 'method',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'md',
+            rank: 'method',
           },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [
+        { default: ['decorated-method', 'static-initialization', 'method'] },
+      ],
     },
     {
       code: `
 // no accessibility === public
 class Foo {
   #imPrivate() {}
-  private imPrivate() {}
+  imPublic() {}
 }
       `,
-      name: '#private and private member order',
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPublic',
+            rank: '#private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'with private identifier',
       options: [
         {
           default: {
-            memberTypes: ['#private-method', 'private-method'],
+            memberTypes: ['public-method', '#private-method'],
             order: 'alphabetically-case-insensitive',
           },
         },
@@ -4760,22 +4841,26 @@ class Foo {
       code: `
 // no accessibility === public
 class Foo {
-  [A: string]: any;
-  [a: string]: any;
-  static C: boolean;
-  static d: boolean;
-  b: any;
-  B: any;
-  get e(): string {}
-  get E(): string {}
+  #imPrivate() {}
   private imPrivate() {}
-  private ImPrivate() {}
 }
       `,
-      name: 'default member types with alphabetically-case-insensitive order',
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPrivate',
+            rank: '#private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'private and #private member order',
       options: [
         {
           default: {
+            memberTypes: ['private-method', '#private-method'],
             order: 'alphabetically-case-insensitive',
           },
         },
@@ -4783,100 +4868,147 @@ class Foo {
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  readonly B: string;
-  readonly A: string;
-  constructor() {}
-  D: string;
-  C: string;
-  E(): void;
-  F(): void;
-}
-      `,
-      options: [{ default: ['readonly-field', 'field'] }],
-    },
-    {
-      code: `
-class Foo {
-  A: string;
-  B: string;
-  private readonly C: string;
-  private D: string;
+  static C: boolean;
+  [B: string]: any;
+  private A() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public static field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: 'default member types with alphabetically order',
       options: [
         {
-          default: ['public-field', 'private-readonly-field', 'private-field'],
+          default: {
+            order: 'alphabetically',
+          },
         },
       ],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  private readonly A: string;
-  constructor() {}
-  private B: string;
+  static C: boolean;
+  [B: string]: any;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['private-readonly-field', 'constructor', 'private-field'],
+          column: 3,
+          data: {
+            beforeMember: 'C',
+            member: 'B',
+          },
+          line: 5,
+          messageId: 'incorrectOrder',
         },
       ],
+      name: 'alphabetically order without member types',
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
     },
     {
       code: `
+// no accessibility === public
 class Foo {
-  public A: string;
-  private readonly B: string;
+  private imPrivate() {}
+  #imPrivate() {}
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'imPrivate',
+            rank: 'private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
+      name: '#private and private member order',
       options: [
         {
-          classes: ['public-instance-field', 'private-readonly-field'],
-          default: ['private-readonly-field', 'public-instance-field'],
+          default: {
+            memberTypes: ['#private-method', 'private-method'],
+            order: 'alphabetically-case-insensitive',
+          },
         },
       ],
     },
-    // class + ignore readonly
     {
       code: `
+// no accessibility === public
 class Foo {
-  public A(): string;
-  public B(): string;
-  public C(): string;
-
-  d: string;
-  readonly e: string;
-  f: string;
+  B: string;
+  readonly A: string = '';
+  C: string = '';
+  constructor() {}
+  D() {}
+  E() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['public-method', 'field'],
+          column: 3,
+          data: {
+            name: 'A',
+            rank: 'field',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
+      options: [{ default: ['readonly-field', 'field'] }],
     },
     {
       code: `
 class Foo {
-  private readonly A: string;
-  readonly B: string;
-  C: string;
+  A: string;
+  private C(): void;
   constructor() {}
-  @Dec() private D: string;
-  private E(): void;
-  set F() {}
-  G(): void;
+  private readonly B: string;
+  set D() {}
+  E(): void;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'constructor',
+            rank: 'public set, private method',
+          },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'public field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
-            'readonly-field',
+            'private-readonly-field',
             'public-field',
             'constructor',
-            ['private-decorated-field', 'public-set', 'private-method'],
+            ['public-set', 'private-method'],
             'public-method',
           ],
         },
@@ -4885,123 +5017,51 @@ class Foo {
     {
       code: `
 abstract class Foo {
-  public static readonly SA: string;
-  protected static readonly SB: string;
-  private static readonly SC: string;
-  static readonly #SD: string;
-
-  public readonly IA: string;
-  protected readonly IB: string;
-  private readonly IC: string;
-  readonly #ID: string;
-
-  public abstract readonly AA: string;
-  protected abstract readonly AB: string;
+  @Dec public readonly A: string;
+  public readonly B: string;
+  public static readonly C: string;
+  static readonly #D: string;
+  readonly #E: string;
 
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
+  @Dec public F: string;
+  public G: string;
+  public static H: string;
+  static readonly #I: string;
+  readonly #J: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'public-static-readonly-field',
-            'protected-static-readonly-field',
-            'private-static-readonly-field',
-            '#private-static-readonly-field',
-
-            'static-readonly-field',
-
-            'public-instance-readonly-field',
-            'protected-instance-readonly-field',
-            'private-instance-readonly-field',
-            '#private-instance-readonly-field',
-
-            'instance-readonly-field',
-
-            'public-readonly-field',
-            'protected-readonly-field',
-            'private-readonly-field',
-            '#private-readonly-field',
-
-            'readonly-field',
-
-            'public-abstract-readonly-field',
-            'protected-abstract-readonly-field',
-
-            'abstract-readonly-field',
-
-            'public-decorated-readonly-field',
-            'protected-decorated-readonly-field',
-            'private-decorated-readonly-field',
-            'decorated-readonly-field',
-          ],
+          column: 3,
+          data: {
+            name: 'F',
+            rank: 'readonly field',
+          },
+          line: 9,
+          messageId: 'incorrectGroupOrder',
         },
-      ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
-
-  public static readonly SA: string;
-  protected static readonly SB: string;
-  private static readonly SC: string;
-  static readonly #SD: string;
-
-  public readonly IA: string;
-  protected readonly IB: string;
-  private readonly IC: string;
-  readonly #ID: string;
-
-  public abstract readonly AA: string;
-  protected abstract readonly AB: string;
-}
-      `,
-      options: [
         {
-          default: [
-            'decorated-readonly-field',
-            'static-readonly-field',
-            'instance-readonly-field',
-            'abstract-readonly-field',
-          ],
+          column: 3,
+          data: {
+            name: 'I',
+            rank: 'field',
+          },
+          line: 12,
+          messageId: 'incorrectGroupOrder',
         },
-      ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly DA: string;
-  @Dec protected readonly DB: string;
-  @Dec private readonly DC: string;
-
-  public static readonly SA: string;
-  public readonly IA: string;
-  public abstract readonly AA: string;
-
-  protected static readonly SB: string;
-  protected readonly IB: string;
-  protected abstract readonly AB: string;
-
-  private static readonly SC: string;
-  private readonly IC: string;
-
-  static readonly #SD: string;
-  readonly #ID: string;
-}
-      `,
+        {
+          column: 3,
+          data: {
+            name: 'J',
+            rank: 'field',
+          },
+          line: 13,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
-          default: [
-            'decorated-readonly-field',
-            'public-readonly-field',
-            'protected-readonly-field',
-            'private-readonly-field',
-          ],
+          default: ['decorated-field', 'readonly-field', 'field'],
         },
       ],
     },
@@ -5013,55 +5073,46 @@ abstract class Foo {
   @Dec private readonly DC: string;
 
   public static readonly SA: string;
-  public readonly IA: string;
+  protected static readonly SB: string;
+  private static readonly SC: string;
   static readonly #SD: string;
-  readonly #ID: string;
 
-  protected static readonly SB: string;
+  public readonly IA: string;
   protected readonly IB: string;
-
-  private static readonly SC: string;
   private readonly IC: string;
+  readonly #ID: string;
 
   public abstract readonly AA: string;
   protected abstract readonly AB: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: [
-            'decorated-readonly-field',
-            ['public-readonly-field', 'readonly-field'],
-            'protected-readonly-field',
-            'private-readonly-field',
-            'abstract-readonly-field',
-          ],
+          column: 3,
+          data: {
+            name: 'AA',
+            rank: 'static readonly field',
+          },
+          line: 17,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'AB',
+            rank: 'static readonly field',
+          },
+          line: 18,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-abstract class Foo {
-  @Dec public readonly A: string;
-  @Dec public B: string;
-
-  public readonly C: string;
-  public static readonly D: string;
-  public E: string;
-  public static F: string;
-
-  static readonly #G: string;
-  readonly #H: string;
-  static #I: string;
-  #J: string;
-}
-      `,
       options: [
         {
           default: [
-            ['decorated-field', 'decorated-readonly-field'],
-            ['field', 'readonly-field'],
-            ['#private-field', '#private-readonly-field'],
+            'decorated-readonly-field',
+            'abstract-readonly-field',
+            'static-readonly-field',
+            'instance-readonly-field',
           ],
         },
       ],
@@ -5076,43 +5127,62 @@ interface Foo {
   D: string;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['readonly-field', 'field'],
+          column: 3,
+          data: {
+            name: 'C',
+            rank: 'readonly field',
+          },
+          line: 6,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'D',
+            rank: 'readonly field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-interface Foo {
-  readonly [i: string]: string;
-  readonly A: string;
-
-  [i: number]: string;
-  B: string;
-}
-      `,
       options: [
         {
-          default: [
-            'readonly-signature',
-            'readonly-field',
-            'signature',
-            'field',
-          ],
+          default: ['field', 'readonly-field'],
         },
       ],
     },
     {
       code: `
 interface Foo {
-  readonly [i: string]: string;
   [i: number]: string;
+  readonly [i: string]: string;
 
-  readonly A: string;
-  B: string;
+  A: string;
+  readonly B: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            name: 'i',
+            rank: 'signature',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
+        },
+        {
+          column: 3,
+          data: {
+            name: 'B',
+            rank: 'field',
+          },
+          line: 7,
+          messageId: 'incorrectGroupOrder',
+        },
+      ],
       options: [
         {
           default: [
@@ -5126,118 +5196,50 @@ interface Foo {
     },
     {
       code: `
-interface Foo {
-  readonly A: string;
-  B: string;
-
-  [i: number]: string;
-  readonly [i: string]: string;
-}
-      `,
-      options: [
-        {
-          default: ['readonly-field', 'field', 'signature'],
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6812
-    {
-      code: `
 class Foo {
-  #bar: string;
-
-  get bar(): string {
-    return this.#bar;
-  }
+  accessor bar;
 
-  set bar(value: string) {
-    this.#bar = value;
-  }
+  baz() {}
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: [['get', 'set']],
-            order: 'alphabetically',
+          column: 3,
+          data: {
+            name: 'baz',
+            rank: 'accessor',
           },
+          line: 5,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-// no accessibility === public
-class Foo {
-  [A: string]: any;
-  [B: string]: any;
-  [a: string]: any;
-  [b: string]: any;
-  static C: boolean;
-  static d: boolean;
-  get E(): string {}
-  get e(): string {}
-  private ImPrivate() {}
-  private imPrivate() {}
-}
-      `,
-      name: 'default member types with alphabetically order',
       options: [
         {
-          default: {
-            order: 'alphabetically',
-          },
+          default: ['method', 'accessor'],
         },
       ],
     },
     {
       code: `
-// no accessibility === public
 interface Foo {
-  A: string;
-  B: string;
-  [Z: string]: any;
-  c();
-  new ();
-  r();
-}
-      `,
-      name: 'alphabetically order without member types',
-      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
-    },
-    {
-      code: `
-class Foo {
-  #bar: string;
-
-  get bar(): string {
-    return this.#bar;
-  }
-
-  set bar(value: string) {
-    this.#bar = value;
-  }
+  y(): void;
+  get x(): number;
 }
       `,
-      options: [
+      errors: [
         {
-          default: {
-            memberTypes: [['get', 'set']],
-            order: 'natural',
+          column: 3,
+          data: {
+            name: 'x',
+            rank: 'method',
           },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-class Foo {
-  accessor bar;
-
-  baz() {}
-}
-      `,
       options: [
         {
-          default: ['accessor', 'method'],
+          default: ['get', 'method'],
         },
       ],
     },
@@ -5248,19 +5250,17 @@ interface Foo {
   y(): void;
 }
       `,
-      options: [
+      errors: [
         {
-          default: ['get', 'method'],
+          column: 3,
+          data: {
+            name: 'y',
+            rank: 'get',
+          },
+          line: 4,
+          messageId: 'incorrectGroupOrder',
         },
       ],
-    },
-    {
-      code: `
-interface Foo {
-  y(): void;
-  get x(): number;
-}
-      `,
       options: [
         {
           default: ['method', 'get'],
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 23b8b0e77b46..5542e09989ef 100644
--- a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
@@ -5,6 +5,135 @@ import rule from '../../src/rules/method-signature-style';
 const ruleTester = new RuleTester();
 
 ruleTester.run('method-signature-style', rule, {
+  valid: [
+    `
+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;
+}
+    `,
+    `
+interface Test {
+  get f(): number;
+}
+    `,
+    `
+interface Test {
+  set f(value: number): 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 };",
+    'type Test = { get f(): number };',
+    'type Test = { set f(value: number): void };',
+    {
+      code: `
+        interface Test {
+          f(a: string): number;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          ['f'](a: boolean): void;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          f<T>(a: T): T;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          ['f']<T extends {}>(a: T, b: T): T;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        interface Test {
+          'f!'</* a */>(/* b */ x: any /* c */): void;
+        }
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { f(a: string): number };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { ['f']?(a: boolean): void };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { f?<T>(a?: T): T };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { ['f']?<T>(a: T, b: T): T };
+      `,
+      options: ['method'],
+    },
+    `
+      interface Test {
+        get f(): number;
+      }
+    `,
+    `
+      interface Test {
+        set f(value: number): void;
+      }
+    `,
+    {
+      code: `
+        type Test = { get f(): number };
+      `,
+      options: ['method'],
+    },
+    {
+      code: `
+        type Test = { set f(value: number): void };
+      `,
+      options: ['method'],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -542,133 +671,4 @@ interface MyInterface {
       `,
     },
   ],
-  valid: [
-    `
-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;
-}
-    `,
-    `
-interface Test {
-  get f(): number;
-}
-    `,
-    `
-interface Test {
-  set f(value: number): 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 };",
-    'type Test = { get f(): number };',
-    'type Test = { set f(value: number): void };',
-    {
-      code: `
-        interface Test {
-          f(a: string): number;
-        }
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        interface Test {
-          ['f'](a: boolean): void;
-        }
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        interface Test {
-          f<T>(a: T): T;
-        }
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        interface Test {
-          ['f']<T extends {}>(a: T, b: T): T;
-        }
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        interface Test {
-          'f!'</* a */>(/* b */ x: any /* c */): void;
-        }
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        type Test = { f(a: string): number };
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        type Test = { ['f']?(a: boolean): void };
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        type Test = { f?<T>(a?: T): T };
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        type Test = { ['f']?<T>(a: T, b: T): T };
-      `,
-      options: ['method'],
-    },
-    `
-      interface Test {
-        get f(): number;
-      }
-    `,
-    `
-      interface Test {
-        set f(value: number): void;
-      }
-    `,
-    {
-      code: `
-        type Test = { get f(): number };
-      `,
-      options: ['method'],
-    },
-    {
-      code: `
-        type Test = { set f(value: number): void };
-      `,
-      options: ['method'],
-    },
-  ],
 });
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 d696be8f093f..9a3582334c76 100644
--- a/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
@@ -8,6 +8,34 @@ const ruleTester = new RuleTester();
 const messageId = 'useLiteral';
 
 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();',
+
+    // TypeScript
+    '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);',
+  ],
   invalid: [
     {
       code: 'new Array();',
@@ -84,33 +112,4 @@ new Array(0, 1, 2);
       `,
     },
   ],
-
-  valid: [
-    '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>();',
-
-    // 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);',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-array-delete.test.ts b/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
index 4279a4750c12..b0918b571437 100644
--- a/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
@@ -15,6 +15,47 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-array-delete', rule, {
+  valid: [
+    `
+      declare const obj: { a: 1; b: 2 };
+      delete obj.a;
+    `,
+
+    `
+      declare const obj: { a: 1; b: 2 };
+      delete obj['a'];
+    `,
+
+    `
+      declare const arr: { a: 1; b: 2 }[][][][];
+      delete arr[0][0][0][0].a;
+    `,
+
+    `
+      declare const maybeArray: any;
+      delete maybeArray[0];
+    `,
+
+    `
+      declare const maybeArray: unknown;
+      delete maybeArray[0];
+    `,
+
+    `
+      declare function getObject<T extends { a: 1; b: 2 }>(): T;
+      delete getObject().a;
+    `,
+
+    `
+      declare function getObject<T extends number>(): { a: T; b: 2 };
+      delete getObject().a;
+    `,
+
+    `
+      declare const test: never;
+      delete test[0];
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -555,46 +596,4 @@ ruleTester.run('no-array-delete', rule, {
       ],
     },
   ],
-
-  valid: [
-    `
-      declare const obj: { a: 1; b: 2 };
-      delete obj.a;
-    `,
-
-    `
-      declare const obj: { a: 1; b: 2 };
-      delete obj['a'];
-    `,
-
-    `
-      declare const arr: { a: 1; b: 2 }[][][][];
-      delete arr[0][0][0][0].a;
-    `,
-
-    `
-      declare const maybeArray: any;
-      delete maybeArray[0];
-    `,
-
-    `
-      declare const maybeArray: unknown;
-      delete maybeArray[0];
-    `,
-
-    `
-      declare function getObject<T extends { a: 1; b: 2 }>(): T;
-      delete getObject().a;
-    `,
-
-    `
-      declare function getObject<T extends number>(): { a: T; b: 2 };
-      delete getObject().a;
-    `,
-
-    `
-      declare const test: never;
-      delete test[0];
-    `,
-  ],
 });
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 e01eb9ca5d77..78d8af5956fb 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
@@ -39,6 +39,86 @@ const literalListWrapped = [
 ];
 
 ruleTester.run('no-base-to-string', rule, {
+  valid: [
+    // template
+    ...literalList.map(i => `\`\${${i}}\`;`),
+
+    // operator + +=
+    ...literalListWrapped
+      .map(l => literalListWrapped.map(r => `${l} + ${r};`))
+      .reduce((pre, cur) => [...pre, ...cur]),
+
+    // toString()
+    ...literalListWrapped.map(i => `${i === '1' ? `(${i})` : i}.toString();`),
+
+    // variable toString() and template
+    ...literalList.map(
+      i => `
+        let value = ${i};
+        value.toString();
+        let text = \`\${value}\`;
+      `,
+    ),
+
+    `
+function someFunction() {}
+someFunction.toString();
+let text = \`\${someFunction}\`;
+    `,
+    'unknownObject.toString();',
+    'unknownObject.someOtherMethod();',
+    `
+class CustomToString {
+  toString() {
+    return 'Hello, world!';
+  }
+}
+'' + new CustomToString();
+    `,
+    `
+const literalWithToString = {
+  toString: () => 'Hello, world!',
+};
+'' + literalToString;
+    `,
+    `
+const printer = (inVar: string | number | boolean) => {
+  inVar.toString();
+};
+printer('');
+printer(1);
+printer(true);
+    `,
+    'let _ = {} * {};',
+    'let _ = {} / {};',
+    'let _ = ({} *= {});',
+    'let _ = ({} /= {});',
+    'let _ = ({} = {});',
+    'let _ = {} == {};',
+    'let _ = {} === {};',
+    'let _ = {} in {};',
+    'let _ = {} & {};',
+    'let _ = {} ^ {};',
+    'let _ = {} << {};',
+    'let _ = {} >> {};',
+    `
+function tag() {}
+tag\`\${{}}\`;
+    `,
+    `
+      function tag() {}
+      tag\`\${{}}\`;
+    `,
+    `
+      interface Brand {}
+      function test(v: string & Brand): string {
+        return \`\${v}\`;
+      }
+    `,
+    "'' += new Error();",
+    "'' += new URL();",
+    "'' += new URLSearchParams();",
+  ],
   invalid: [
     {
       code: '`${{}})`;',
@@ -167,84 +247,4 @@ ruleTester.run('no-base-to-string', rule, {
       ],
     },
   ],
-  valid: [
-    // template
-    ...literalList.map(i => `\`\${${i}}\`;`),
-
-    // operator + +=
-    ...literalListWrapped
-      .map(l => literalListWrapped.map(r => `${l} + ${r};`))
-      .reduce((pre, cur) => [...pre, ...cur]),
-
-    // toString()
-    ...literalListWrapped.map(i => `${i === '1' ? `(${i})` : i}.toString();`),
-
-    // variable toString() and template
-    ...literalList.map(
-      i => `
-        let value = ${i};
-        value.toString();
-        let text = \`\${value}\`;
-      `,
-    ),
-
-    `
-function someFunction() {}
-someFunction.toString();
-let text = \`\${someFunction}\`;
-    `,
-    'unknownObject.toString();',
-    'unknownObject.someOtherMethod();',
-    `
-class CustomToString {
-  toString() {
-    return 'Hello, world!';
-  }
-}
-'' + new CustomToString();
-    `,
-    `
-const literalWithToString = {
-  toString: () => 'Hello, world!',
-};
-'' + literalToString;
-    `,
-    `
-const printer = (inVar: string | number | boolean) => {
-  inVar.toString();
-};
-printer('');
-printer(1);
-printer(true);
-    `,
-    'let _ = {} * {};',
-    'let _ = {} / {};',
-    'let _ = ({} *= {});',
-    'let _ = ({} /= {});',
-    'let _ = ({} = {});',
-    'let _ = {} == {};',
-    'let _ = {} === {};',
-    'let _ = {} in {};',
-    'let _ = {} & {};',
-    'let _ = {} ^ {};',
-    'let _ = {} << {};',
-    'let _ = {} >> {};',
-    `
-function tag() {}
-tag\`\${{}}\`;
-    `,
-    `
-      function tag() {}
-      tag\`\${{}}\`;
-    `,
-    `
-      interface Brand {}
-      function test(v: string & Brand): string {
-        return \`\${v}\`;
-      }
-    `,
-    "'' += new Error();",
-    "'' += new URL();",
-    "'' += new URLSearchParams();",
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
index 7fe5698308a0..343b399eabb4 100644
--- a/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-confusing-non-null-assertion.test.ts
@@ -10,6 +10,15 @@ import rule from '../../src/rules/no-confusing-non-null-assertion';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-confusing-non-null-assertion', rule, {
+  valid: [
+    //
+    'a == b!;',
+    'a = b!;',
+    'a !== b;',
+    'a != b;',
+    '(a + b!) == c;',
+    '(a + b!) = c;',
+  ],
   invalid: [
     {
       code: 'a! == b;',
@@ -140,13 +149,4 @@ ruleTester.run('no-confusing-non-null-assertion', rule, {
       ],
     },
   ],
-  valid: [
-    //
-    'a == b!;',
-    'a = b!;',
-    'a !== b;',
-    'a != b;',
-    '(a + b!) == c;',
-    '(a + b!) = c;',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
index d2fb35ebef74..43f134e23657 100644
--- a/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-confusing-void-expression.test.ts
@@ -14,6 +14,113 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-confusing-void-expression', rule, {
+  valid: [
+    '() => Math.random();',
+    "console.log('foo');",
+    'foo && console.log(foo);',
+    'foo || console.log(foo);',
+    'foo ? console.log(true) : console.log(false);',
+    "console?.log('foo');",
+
+    {
+      code: `
+        () => console.log('foo');
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => foo && console.log(foo);
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => foo || console.log(foo);
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+    {
+      code: `
+        foo => (foo ? console.log(true) : console.log(false));
+      `,
+      options: [{ ignoreArrowShorthand: true }],
+    },
+
+    {
+      code: `
+        !void console.log('foo');
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        +void (foo && console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        -void (foo || console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        () => void ((foo && void console.log(true)) || console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        const x = void (foo ? console.log(true) : console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        !(foo && void console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        !!(foo || void console.log(foo));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        const x = (foo && void console.log(true)) || void console.log(false);
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        () => (foo ? void console.log(true) : void console.log(false));
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+    {
+      code: `
+        return void console.log('foo');
+      `,
+      options: [{ ignoreVoidOperator: true }],
+    },
+
+    `
+function cool(input: string) {
+  return console.log(input), input;
+}
+    `,
+    {
+      code: `
+function cool(input: string) {
+  return input, console.log(input), input;
+}
+      `,
+    },
+  ],
   invalid: [
     {
       code: `
@@ -387,112 +494,4 @@ function notcool(input: string) {
       output: null,
     },
   ],
-
-  valid: [
-    '() => Math.random();',
-    "console.log('foo');",
-    'foo && console.log(foo);',
-    'foo || console.log(foo);',
-    'foo ? console.log(true) : console.log(false);',
-    "console?.log('foo');",
-
-    {
-      code: `
-        () => console.log('foo');
-      `,
-      options: [{ ignoreArrowShorthand: true }],
-    },
-    {
-      code: `
-        foo => foo && console.log(foo);
-      `,
-      options: [{ ignoreArrowShorthand: true }],
-    },
-    {
-      code: `
-        foo => foo || console.log(foo);
-      `,
-      options: [{ ignoreArrowShorthand: true }],
-    },
-    {
-      code: `
-        foo => (foo ? console.log(true) : console.log(false));
-      `,
-      options: [{ ignoreArrowShorthand: true }],
-    },
-
-    {
-      code: `
-        !void console.log('foo');
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        +void (foo && console.log(foo));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        -void (foo || console.log(foo));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        () => void ((foo && void console.log(true)) || console.log(false));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        const x = void (foo ? console.log(true) : console.log(false));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        !(foo && void console.log(foo));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        !!(foo || void console.log(foo));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        const x = (foo && void console.log(true)) || void console.log(false);
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        () => (foo ? void console.log(true) : void console.log(false));
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-    {
-      code: `
-        return void console.log('foo');
-      `,
-      options: [{ ignoreVoidOperator: true }],
-    },
-
-    `
-function cool(input: string) {
-  return console.log(input), input;
-}
-    `,
-    {
-      code: `
-function cool(input: string) {
-  return input, console.log(input), input;
-}
-      `,
-    },
-  ],
 });
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 0e619268ff8b..9f5b38c7dd77 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
@@ -5,6 +5,81 @@ import rule from '../../src/rules/no-dupe-class-members';
 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 Foo {
+        foo(a: string): string;
+        foo(a: number): number;
+        foo(a: any): any {}
+      }
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -119,79 +194,4 @@ class A {
       ],
     },
   ],
-  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 Foo {
-        foo(a: string): string;
-        foo(a: number): number;
-        foo(a: any): any {}
-      }
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts b/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
index 766cf1f2798e..a8864bfb6aa6 100644
--- a/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-duplicate-enum-values.test.ts
@@ -5,64 +5,6 @@ import rule from '../../src/rules/no-duplicate-enum-values';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-duplicate-enum-values', rule, {
-  invalid: [
-    {
-      code: `
-enum E {
-  A = 1,
-  B = 1,
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { value: 1 },
-          line: 4,
-          messageId: 'duplicateValue',
-        },
-      ],
-    },
-    {
-      code: `
-enum E {
-  A = 'A',
-  B = 'A',
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { value: 'A' },
-          line: 4,
-          messageId: 'duplicateValue',
-        },
-      ],
-    },
-    {
-      code: `
-enum E {
-  A = 'A',
-  B = 'A',
-  C = 1,
-  D = 1,
-}
-      `,
-      errors: [
-        {
-          column: 3,
-          data: { value: 'A' },
-          line: 4,
-          messageId: 'duplicateValue',
-        },
-        {
-          column: 3,
-          data: { value: 1 },
-          line: 6,
-          messageId: 'duplicateValue',
-        },
-      ],
-    },
-  ],
   valid: [
     `
 enum E {
@@ -132,4 +74,62 @@ enum E {
 }
     `,
   ],
+  invalid: [
+    {
+      code: `
+enum E {
+  A = 1,
+  B = 1,
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 1 },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+    {
+      code: `
+enum E {
+  A = 'A',
+  B = 'A',
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 'A' },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+    {
+      code: `
+enum E {
+  A = 'A',
+  B = 'A',
+  C = 1,
+  D = 1,
+}
+      `,
+      errors: [
+        {
+          column: 3,
+          data: { value: 'A' },
+          line: 4,
+          messageId: 'duplicateValue',
+        },
+        {
+          column: 3,
+          data: { value: 1 },
+          line: 6,
+          messageId: 'duplicateValue',
+        },
+      ],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
index d145aca4e9ee..a78a414e4ab7 100644
--- a/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-duplicate-type-constituents.test.ts
@@ -15,6 +15,152 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-duplicate-type-constituents', rule, {
+  valid: [
+    {
+      code: 'type T = 1 | 2;',
+    },
+    {
+      code: "type T = 1 | '1';",
+    },
+    {
+      code: 'type T = true & boolean;',
+    },
+    {
+      code: 'type T = null | undefined;',
+    },
+    {
+      code: 'type T = any | unknown;',
+    },
+    {
+      code: 'type T = { a: string } | { b: string };',
+    },
+    {
+      code: 'type T = { a: string; b: number } | { b: number; a: string };',
+    },
+    {
+      code: 'type T = { a: string | number };',
+    },
+    {
+      code: 'type T = Set<string> | Set<number>;',
+    },
+    {
+      code: 'type T = Class<string> | Class<number>;',
+    },
+    {
+      code: 'type T = string[] | number[];',
+    },
+    {
+      code: 'type T = string[][] | string[];',
+    },
+    {
+      code: 'type T = [1, 2, 3] | [1, 2, 4];',
+    },
+    {
+      code: 'type T = [1, 2, 3] | [1, 2, 3, 4];',
+    },
+    {
+      code: "type T = 'A' | string[];",
+    },
+    {
+      code: 'type T = (() => string) | (() => void);',
+    },
+    {
+      code: 'type T = () => string | void;',
+    },
+    {
+      code: 'type T = () => null | undefined;',
+    },
+    {
+      code: 'type T = (arg: string | number) => void;',
+    },
+    {
+      code: 'type T = A | A;',
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = A | B;
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+const a: A | B = 'A';
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = A | /* comment */ B;
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = 'A' | 'B';
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type T = A | B | C;
+      `,
+    },
+    {
+      code: 'type T = readonly string[] | string[];',
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type C = 'C';
+type D = 'D';
+type T = (A | B) | (C | D);
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = (A | B) | (A & B);
+      `,
+    },
+    {
+      code: `
+type A = 'A';
+type B = 'B';
+type T = Record<string, A | B>;
+      `,
+    },
+    {
+      code: 'type T = A | A;',
+      options: [
+        {
+          ignoreUnions: true,
+        },
+      ],
+    },
+    {
+      code: 'type T = A & A;',
+      options: [
+        {
+          ignoreIntersections: true,
+        },
+      ],
+    },
+    {
+      code: 'type T = Class<string> | Class<string>;',
+    },
+    {
+      code: 'type T = A | A | string;',
+    },
+  ],
   invalid: [
     {
       code: 'type T = 1 | 1;',
@@ -529,150 +675,4 @@ type T = Record<string, A  >;
       output: 'type T = A | A | string  ;',
     },
   ],
-  valid: [
-    {
-      code: 'type T = 1 | 2;',
-    },
-    {
-      code: "type T = 1 | '1';",
-    },
-    {
-      code: 'type T = true & boolean;',
-    },
-    {
-      code: 'type T = null | undefined;',
-    },
-    {
-      code: 'type T = any | unknown;',
-    },
-    {
-      code: 'type T = { a: string } | { b: string };',
-    },
-    {
-      code: 'type T = { a: string; b: number } | { b: number; a: string };',
-    },
-    {
-      code: 'type T = { a: string | number };',
-    },
-    {
-      code: 'type T = Set<string> | Set<number>;',
-    },
-    {
-      code: 'type T = Class<string> | Class<number>;',
-    },
-    {
-      code: 'type T = string[] | number[];',
-    },
-    {
-      code: 'type T = string[][] | string[];',
-    },
-    {
-      code: 'type T = [1, 2, 3] | [1, 2, 4];',
-    },
-    {
-      code: 'type T = [1, 2, 3] | [1, 2, 3, 4];',
-    },
-    {
-      code: "type T = 'A' | string[];",
-    },
-    {
-      code: 'type T = (() => string) | (() => void);',
-    },
-    {
-      code: 'type T = () => string | void;',
-    },
-    {
-      code: 'type T = () => null | undefined;',
-    },
-    {
-      code: 'type T = (arg: string | number) => void;',
-    },
-    {
-      code: 'type T = A | A;',
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = A | B;
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-const a: A | B = 'A';
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = A | /* comment */ B;
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = 'A' | 'B';
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type T = A | B | C;
-      `,
-    },
-    {
-      code: 'type T = readonly string[] | string[];',
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type C = 'C';
-type D = 'D';
-type T = (A | B) | (C | D);
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = (A | B) | (A & B);
-      `,
-    },
-    {
-      code: `
-type A = 'A';
-type B = 'B';
-type T = Record<string, A | B>;
-      `,
-    },
-    {
-      code: 'type T = A | A;',
-      options: [
-        {
-          ignoreUnions: true,
-        },
-      ],
-    },
-    {
-      code: 'type T = A & A;',
-      options: [
-        {
-          ignoreIntersections: true,
-        },
-      ],
-    },
-    {
-      code: 'type T = Class<string> | Class<string>;',
-    },
-    {
-      code: 'type T = A | A | string;',
-    },
-  ],
 });
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 534639579c61..09fc5af480d5 100644
--- a/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
@@ -15,6 +15,52 @@ 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['-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['NaN'];
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -100,50 +146,4 @@ delete container[typeof 1];
       output: null,
     },
   ],
-  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['-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['NaN'];
-    `,
-  ],
 });
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 0957992c5444..410c894c43aa 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
@@ -5,6 +5,81 @@ import rule from '../../src/rules/no-empty-function';
 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 {
+  constructor(private name: string) {}
+}
+      `,
+    },
+    {
+      code: `
+class Person {
+  constructor(name: string) {}
+}
+      `,
+      options: [{ allow: ['constructors'] }],
+    },
+    {
+      code: `
+class Person {
+  otherMethod(name: string) {}
+}
+      `,
+      options: [{ allow: ['methods'] }],
+    },
+    {
+      code: `
+class Foo {
+  private constructor() {}
+}
+      `,
+      options: [{ allow: ['private-constructors'] }],
+    },
+    {
+      code: `
+class Foo {
+  protected constructor() {}
+}
+      `,
+      options: [{ allow: ['protected-constructors'] }],
+    },
+    {
+      code: `
+function foo() {
+  const a = null;
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  @decorator()
+  foo() {}
+}
+      `,
+      options: [{ allow: ['decoratedFunctions'] }],
+    },
+    {
+      code: `
+class Foo extends Base {
+  override foo() {}
+}
+      `,
+      options: [{ allow: ['overrideMethods'] }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -125,80 +200,4 @@ class Foo extends Base {
       ],
     },
   ],
-
-  valid: [
-    {
-      code: `
-class Person {
-  private name: string;
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-      `,
-    },
-    {
-      code: `
-class Person {
-  constructor(private name: string) {}
-}
-      `,
-    },
-    {
-      code: `
-class Person {
-  constructor(name: string) {}
-}
-      `,
-      options: [{ allow: ['constructors'] }],
-    },
-    {
-      code: `
-class Person {
-  otherMethod(name: string) {}
-}
-      `,
-      options: [{ allow: ['methods'] }],
-    },
-    {
-      code: `
-class Foo {
-  private constructor() {}
-}
-      `,
-      options: [{ allow: ['private-constructors'] }],
-    },
-    {
-      code: `
-class Foo {
-  protected constructor() {}
-}
-      `,
-      options: [{ allow: ['protected-constructors'] }],
-    },
-    {
-      code: `
-function foo() {
-  const a = null;
-}
-      `,
-    },
-    {
-      code: `
-class Foo {
-  @decorator()
-  foo() {}
-}
-      `,
-      options: [{ allow: ['decoratedFunctions'] }],
-    },
-    {
-      code: `
-class Foo extends Base {
-  override foo() {}
-}
-      `,
-      options: [{ allow: ['overrideMethods'] }],
-    },
-  ],
 });
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 75992c066919..0613f45c8e7e 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -5,6 +5,47 @@ import rule from '../../src/rules/no-empty-interface';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-interface', rule, {
+  valid: [
+    `
+interface Foo {
+  name: string;
+}
+    `,
+    `
+interface Foo {
+  name: string;
+}
+
+interface Bar {
+  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;
+}
+
+interface Bar extends Foo {}
+      `,
+      options: [{ allowSingleExtends: true }],
+    },
+    {
+      code: `
+interface Foo {
+  props: string;
+}
+
+interface Bar extends Foo {}
+
+class Bar {}
+      `,
+      options: [{ allowSingleExtends: true }],
+    },
+  ],
   invalid: [
     {
       code: 'interface Foo {}',
@@ -235,45 +276,4 @@ declare module FooBar {
       output: null,
     },
   ],
-  valid: [
-    `
-interface Foo {
-  name: string;
-}
-    `,
-    `
-interface Foo {
-  name: string;
-}
-
-interface Bar {
-  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;
-}
-
-interface Bar extends Foo {}
-      `,
-      options: [{ allowSingleExtends: true }],
-    },
-    {
-      code: `
-interface Foo {
-  props: string;
-}
-
-interface Bar extends Foo {}
-
-class Bar {}
-      `,
-      options: [{ allowSingleExtends: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts b/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
index 6bf4d7d9cd33..3dd7579a83a8 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-object-type.test.ts
@@ -5,6 +5,75 @@ import rule from '../../src/rules/no-empty-object-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-object-type', rule, {
+  valid: [
+    `
+interface Base {
+  name: string;
+}
+    `,
+    `
+interface Base {
+  name: string;
+}
+
+interface Derived {
+  age: number;
+}
+
+// valid because extending multiple interfaces can be used instead of a union type
+interface Both extends Base, Derived {}
+    `,
+    {
+      code: 'interface Base {}',
+      options: [{ allowInterfaces: 'always' }],
+    },
+    {
+      code: `
+interface Base {
+  name: string;
+}
+
+interface Derived extends Base {}
+      `,
+      options: [{ allowInterfaces: 'with-single-extends' }],
+    },
+    {
+      code: `
+interface Base {
+  props: string;
+}
+
+interface Derived extends Base {}
+
+class Derived {}
+      `,
+      options: [{ allowInterfaces: 'with-single-extends' }],
+    },
+    'let value: object;',
+    'let value: Object;',
+    'let value: { inner: true };',
+    'type MyNonNullable<T> = T & {};',
+    {
+      code: 'type Base = {};',
+      options: [{ allowObjectTypes: 'always' }],
+    },
+    {
+      code: 'type Base = {};',
+      options: [{ allowWithName: 'Base' }],
+    },
+    {
+      code: 'type BaseProps = {};',
+      options: [{ allowWithName: 'Props$' }],
+    },
+    {
+      code: 'interface Base {}',
+      options: [{ allowWithName: 'Base' }],
+    },
+    {
+      code: 'interface BaseProps {}',
+      options: [{ allowWithName: 'Props$' }],
+    },
+  ],
   invalid: [
     {
       code: 'interface Base {}',
@@ -541,73 +610,4 @@ let value: unknown;
       options: [{ allowWithName: '.*Props$' }],
     },
   ],
-  valid: [
-    `
-interface Base {
-  name: string;
-}
-    `,
-    `
-interface Base {
-  name: string;
-}
-
-interface Derived {
-  age: number;
-}
-
-// valid because extending multiple interfaces can be used instead of a union type
-interface Both extends Base, Derived {}
-    `,
-    {
-      code: 'interface Base {}',
-      options: [{ allowInterfaces: 'always' }],
-    },
-    {
-      code: `
-interface Base {
-  name: string;
-}
-
-interface Derived extends Base {}
-      `,
-      options: [{ allowInterfaces: 'with-single-extends' }],
-    },
-    {
-      code: `
-interface Base {
-  props: string;
-}
-
-interface Derived extends Base {}
-
-class Derived {}
-      `,
-      options: [{ allowInterfaces: 'with-single-extends' }],
-    },
-    'let value: object;',
-    'let value: Object;',
-    'let value: { inner: true };',
-    'type MyNonNullable<T> = T & {};',
-    {
-      code: 'type Base = {};',
-      options: [{ allowObjectTypes: 'always' }],
-    },
-    {
-      code: 'type Base = {};',
-      options: [{ allowWithName: 'Base' }],
-    },
-    {
-      code: 'type BaseProps = {};',
-      options: [{ allowWithName: 'Props$' }],
-    },
-    {
-      code: 'interface Base {}',
-      options: [{ allowWithName: 'Base' }],
-    },
-    {
-      code: 'interface BaseProps {}',
-      options: [{ allowWithName: 'Props$' }],
-    },
-  ],
 });
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 51c3af20bec5..ad10eabfaa2c 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -15,576 +15,441 @@ type RuleSuggestionOutput = SuggestionOutput<MessageIds>;
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-explicit-any', rule, {
-  invalid: (
-    [
-      {
-        code: 'const number: any = 1',
-        errors: [
-          {
-            column: 15,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(): any {}',
-        errors: [
-          {
-            column: 21,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(): Array<any> {}',
-        errors: [
-          {
-            column: 27,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(): any[] {}',
-        errors: [
-          {
-            column: 21,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(param: Array<any>): number {}',
-        errors: [
-          {
-            column: 31,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(param: any[]): number {}',
-        errors: [
-          {
-            column: 25,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(param: Array<any>): Array<any> {}',
-        errors: [
-          {
-            column: 31,
-            line: 1,
-            messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'function generic(param: Array<unknown>): Array<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'function generic(param: Array<never>): Array<any> {}',
-              },
-            ],
-          },
-          {
-            column: 44,
-            line: 1,
-            messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'function generic(param: Array<any>): Array<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'function generic(param: Array<any>): Array<never> {}',
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: 'function generic(): Array<Array<any>> {}',
-        errors: [
-          {
-            column: 33,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: 'function generic(): Array<any[]> {}',
-        errors: [
-          {
-            column: 27,
-            line: 1,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  valid: [
+    'const number: number = 1;',
+    'function greet(): string {}',
+    'function greet(): Array<string> {}',
+    'function greet(): string[] {}',
+    'function greet(): Array<Array<string>> {}',
+    'function greet(): Array<string[]> {}',
+    'function greet(param: Array<string>): Array<string> {}',
+    `
 class Greeter {
-    constructor(param: Array<any>) {}
+  message: string;
 }
-            `,
-        errors: [
-          {
-            column: 30,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 class Greeter {
-    message: any;
+  message: Array<string>;
 }
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 class Greeter {
-    message: Array<any>;
+  message: string[];
 }
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 class Greeter {
-    message: any[];
+  message: Array<Array<string>>;
 }
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 class Greeter {
-    message: Array<Array<any>>;
+  message: Array<string[]>;
 }
-            `,
-        errors: [
-          {
-            column: 26,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
-class Greeter {
-    message: Array<any[]>;
+    `,
+    `
+interface Greeter {
+  message: string;
 }
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 interface Greeter {
-    message: any;
+  message: Array<string>;
 }
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 interface Greeter {
-    message: Array<any>;
+  message: string[];
 }
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 interface Greeter {
-    message: any[];
+  message: Array<Array<string>>;
 }
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
-interface Greeter {
-    message: Array<Array<any>>;
-}
-            `,
-        errors: [
-          {
-            column: 26,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 interface Greeter {
-    message: Array<any[]>;
+  message: Array<string[]>;
 }
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+    `,
+    `
 type obj = {
-    message: any;
-}
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string;
+};
+    `,
+    `
 type obj = {
-    message: Array<any>;
-}
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: Array<string>;
+};
+    `,
+    `
 type obj = {
-    message: any[];
-}
-            `,
-        errors: [
-          {
-            column: 14,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string[];
+};
+    `,
+    `
 type obj = {
-    message: Array<Array<any>>;
-}
-            `,
-        errors: [
-          {
-            column: 26,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: Array<Array<string>>;
+};
+    `,
+    `
 type obj = {
-    message: Array<any[]>;
-}
-            `,
-        errors: [
-          {
-            column: 20,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: Array<string[]>;
+};
+    `,
+    `
 type obj = {
-    message: string | any;
-}
-            `,
-        errors: [
-          {
-            column: 23,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string | number;
+};
+    `,
+    `
 type obj = {
-    message: string | Array<any>;
-}
-            `,
-        errors: [
-          {
-            column: 29,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string | Array<string>;
+};
+    `,
+    `
 type obj = {
-    message: string | any[];
-}
-            `,
-        errors: [
-          {
-            column: 23,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string | string[];
+};
+    `,
+    `
 type obj = {
-    message: string | Array<Array<any>>;
-}
-            `,
-        errors: [
-          {
-            column: 35,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string | Array<Array<string>>;
+};
+    `,
+    `
 type obj = {
-    message: string | Array<any[]>;
-}
-            `,
-        errors: [
-          {
-            column: 29,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string & number;
+};
+    `,
+    `
 type obj = {
-    message: string & any;
-}
-            `,
-        errors: [
-          {
-            column: 23,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string & Array<string>;
+};
+    `,
+    `
 type obj = {
-    message: string & Array<any>;
-}
-            `,
-        errors: [
-          {
-            column: 29,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
+  message: string & string[];
+};
+    `,
+    `
 type obj = {
-    message: string & any[];
-}
-            `,
-        errors: [
-          {
-            column: 23,
-            line: 3,
-            messageId: 'unexpectedAny',
-          },
-        ],
-      },
-      {
-        code: `
-type obj = {
-    message: string & Array<Array<any>>;
+  message: string & Array<Array<string>>;
+};
+    `,
+    // https://github.com/eslint/typescript-eslint-parser/issues/397
+    {
+      code: `
+        function foo(a: number, ...rest: any[]): void {
+          return;
+        }
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo1(...args: any[]) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar1 = function (...args: any[]) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz1 = (...args: any[]) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo2(...args: readonly any[]) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar2 = function (...args: readonly any[]) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz2 = (...args: readonly any[]) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo3(...args: Array<any>) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar3 = function (...args: Array<any>) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz3 = (...args: Array<any>) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function foo4(...args: ReadonlyArray<any>) {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const bar4 = function (...args: ReadonlyArray<any>) {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'const baz4 = (...args: ReadonlyArray<any>) => {};',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux1 {
+  (...args: any[]): void;
 }
-            `,
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux2 {
+  (...args: readonly any[]): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux3 {
+  (...args: Array<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Qux4 {
+  (...args: ReadonlyArray<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux1(fn: (...args: any[]) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux2(fn: (...args: readonly any[]) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux3(fn: (...args: Array<any>) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz1(): (...args: any[]) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz2(): (...args: readonly any[]) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'function quuz3(): (...args: Array<any>) => void {}',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      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: (
+    [
+      {
+        code: 'const number: any = 1',
         errors: [
           {
-            column: 35,
-            line: 3,
+            column: 15,
+            line: 1,
             messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        code: `
-type obj = {
-    message: string & Array<any[]>;
-}
-            `,
+        code: 'function generic(): any {}',
         errors: [
           {
-            column: 29,
-            line: 3,
+            column: 21,
+            line: 1,
             messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        code: 'class Foo<t = any> extends Bar<any> {}',
+        code: 'function generic(): Array<any> {}',
         errors: [
           {
-            column: 15,
+            column: 27,
             line: 1,
             messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'class Foo<t = unknown> extends Bar<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'class Foo<t = never> extends Bar<any> {}',
-              },
-            ],
           },
+        ],
+      },
+      {
+        code: 'function generic(): any[] {}',
+        errors: [
           {
-            column: 32,
+            column: 21,
             line: 1,
             messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'class Foo<t = any> extends Bar<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'class Foo<t = any> extends Bar<never> {}',
-              },
-            ],
           },
         ],
       },
       {
-        code: 'abstract class Foo<t = any> extends Bar<any> {}',
+        code: 'function generic(param: Array<any>): number {}',
         errors: [
           {
-            column: 24,
+            column: 31,
             line: 1,
             messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'abstract class Foo<t = unknown> extends Bar<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'abstract class Foo<t = never> extends Bar<any> {}',
-              },
-            ],
           },
+        ],
+      },
+      {
+        code: 'function generic(param: any[]): number {}',
+        errors: [
           {
-            column: 41,
+            column: 25,
             line: 1,
             messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: 'abstract class Foo<t = any> extends Bar<unknown> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output: 'abstract class Foo<t = any> extends Bar<never> {}',
-              },
-            ],
           },
         ],
       },
       {
-        code: 'abstract class Foo<t = any> implements Bar<any>, Baz<any> {}',
+        code: 'function generic(param: Array<any>): Array<any> {}',
         errors: [
           {
-            column: 24,
+            column: 31,
             line: 1,
             messageId: 'unexpectedAny',
             suggestions: [
               {
                 messageId: 'suggestUnknown',
                 output:
-                  'abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}',
+                  'function generic(param: Array<unknown>): Array<any> {}',
               },
               {
                 messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = never> implements Bar<any>, Baz<any> {}',
+                output: 'function generic(param: Array<never>): Array<any> {}',
               },
             ],
           },
@@ -596,653 +461,788 @@ type obj = {
               {
                 messageId: 'suggestUnknown',
                 output:
-                  'abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}',
-              },
-              {
-                messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = any> implements Bar<never>, Baz<any> {}',
-              },
-            ],
-          },
-          {
-            column: 54,
-            line: 1,
-            messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output:
-                  'abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}',
+                  'function generic(param: Array<any>): Array<unknown> {}',
               },
               {
                 messageId: 'suggestNever',
-                output:
-                  'abstract class Foo<t = any> implements Bar<any>, Baz<never> {}',
+                output: 'function generic(param: Array<any>): Array<never> {}',
               },
             ],
           },
         ],
       },
       {
-        code: 'new Foo<any>()',
+        code: 'function generic(): Array<Array<any>> {}',
         errors: [
           {
-            column: 9,
+            column: 33,
             line: 1,
             messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        code: 'Foo<any>()',
+        code: 'function generic(): Array<any[]> {}',
         errors: [
           {
-            column: 5,
+            column: 27,
             line: 1,
             messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        // https://github.com/typescript-eslint/typescript-eslint/issues/64
         code: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<any>>() => {};
-      `,
+class Greeter {
+    constructor(param: Array<any>) {}
+}
+            `,
         errors: [
           {
-            column: 33,
-            line: 2,
-            messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: `
-function test<T extends Partial<unknown>>() {}
-const test = <T extends Partial<any>>() => {};
-      `,
-              },
-              {
-                messageId: 'suggestNever',
-                output: `
-function test<T extends Partial<never>>() {}
-const test = <T extends Partial<any>>() => {};
-      `,
-              },
-            ],
-          },
-          {
-            column: 33,
+            column: 30,
             line: 3,
             messageId: 'unexpectedAny',
-            suggestions: [
-              {
-                messageId: 'suggestUnknown',
-                output: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<unknown>>() => {};
-      `,
-              },
-              {
-                messageId: 'suggestNever',
-                output: `
-function test<T extends Partial<any>>() {}
-const test = <T extends Partial<never>>() => {};
-      `,
-              },
-            ],
           },
         ],
       },
       {
-        // https://github.com/eslint/typescript-eslint-parser/issues/397
         code: `
-        function foo(a: number, ...rest: any[]): void {
-          return;
-        }
-      `,
+class Greeter {
+    message: any;
+}
+            `,
         errors: [
           {
-            column: 42,
-            line: 2,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
       },
       {
-        code: 'type Any = any;',
+        code: `
+class Greeter {
+    message: Array<any>;
+}
+            `,
         errors: [
           {
-            column: 12,
-            line: 1,
+            column: 20,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'function foo5(...args: any) {}',
+        code: `
+class Greeter {
+    message: any[];
+}
+            `,
         errors: [
           {
-            column: 24,
-            line: 1,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'const bar5 = function (...args: any) {}',
+        code: `
+class Greeter {
+    message: Array<Array<any>>;
+}
+            `,
         errors: [
           {
-            column: 33,
-            line: 1,
+            column: 26,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'const baz5 = (...args: any) => {}',
+        code: `
+class Greeter {
+    message: Array<any[]>;
+}
+            `,
         errors: [
           {
-            column: 24,
-            line: 1,
+            column: 20,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'interface Qux5 { (...args: any): void; }',
+        code: `
+interface Greeter {
+    message: any;
+}
+            `,
         errors: [
           {
-            column: 28,
-            line: 1,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'function quux5(fn: (...args: any) => void): void {}',
+        code: `
+interface Greeter {
+    message: Array<any>;
+}
+            `,
         errors: [
           {
-            column: 30,
-            line: 1,
+            column: 20,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'function quuz5(): ((...args: any) => void) {}',
+        code: `
+interface Greeter {
+    message: any[];
+}
+            `,
         errors: [
           {
-            column: 30,
-            line: 1,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'type Fred5 = (...args: any) => void;',
+        code: `
+interface Greeter {
+    message: Array<Array<any>>;
+}
+            `,
         errors: [
           {
-            column: 24,
-            line: 1,
+            column: 26,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'type Corge5 = new (...args: any) => void;',
-        errors: [
-          {
-            column: 29,
-            line: 1,
+        code: `
+interface Greeter {
+    message: Array<any[]>;
+}
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'interface Grault5 { new (...args: any): void; }',
+        code: `
+type obj = {
+    message: any;
+}
+            `,
         errors: [
           {
-            column: 35,
-            line: 1,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'interface Garply5 { f(...args: any): void; }',
+        code: `
+type obj = {
+    message: Array<any>;
+}
+            `,
         errors: [
           {
-            column: 32,
-            line: 1,
+            column: 20,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
       {
-        code: 'declare function waldo5(...args: any): void;',
+        code: `
+type obj = {
+    message: any[];
+}
+            `,
         errors: [
           {
-            column: 34,
-            line: 1,
+            column: 14,
+            line: 3,
             messageId: 'unexpectedAny',
           },
         ],
-        options: [{ ignoreRestArgs: true }],
       },
-    ] as RuleInvalidTestCase[]
-  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
-    const suggestions = (code: string): RuleSuggestionOutput[] => [
       {
-        messageId: 'suggestUnknown',
-        output: code.replace(/any/, 'unknown'),
+        code: `
+type obj = {
+    message: Array<Array<any>>;
+}
+            `,
+        errors: [
+          {
+            column: 26,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
       },
       {
-        messageId: 'suggestNever',
-        output: code.replace(/any/, 'never'),
-      },
-    ];
-    acc.push({
-      ...testCase,
-      errors: testCase.errors.map(e => ({
-        ...e,
-        suggestions: e.suggestions ?? suggestions(testCase.code),
-      })),
-    });
-    const options = testCase.options ?? [];
-    const code = `// fixToUnknown: true\n${testCase.code}`;
-    acc.push({
-      code,
-      errors: testCase.errors.map(err => {
-        if (err.line === undefined) {
-          return err;
-        }
-
-        return {
-          ...err,
-          line: err.line + 1,
-          suggestions:
-            err.suggestions?.map(
-              (s): RuleSuggestionOutput => ({
-                ...s,
-                output: `// fixToUnknown: true\n${s.output}`,
-              }),
-            ) ?? suggestions(code),
-        };
-      }),
-      options: [{ ...options[0], fixToUnknown: true }],
-      output: code.replaceAll('any', 'unknown'),
-    });
-
-    return acc;
-  }, []),
-  valid: [
-    'const number: number = 1;',
-    'function greet(): string {}',
-    'function greet(): Array<string> {}',
-    'function greet(): string[] {}',
-    'function greet(): Array<Array<string>> {}',
-    'function greet(): Array<string[]> {}',
-    'function greet(param: Array<string>): Array<string> {}',
-    `
-class Greeter {
-  message: string;
-}
-    `,
-    `
-class Greeter {
-  message: Array<string>;
-}
-    `,
-    `
-class Greeter {
-  message: string[];
+        code: `
+type obj = {
+    message: Array<any[]>;
 }
-    `,
-    `
-class Greeter {
-  message: Array<Array<string>>;
+            `,
+        errors: [
+          {
+            column: 20,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string | any;
 }
-    `,
-    `
-class Greeter {
-  message: Array<string[]>;
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string | Array<any>;
 }
-    `,
-    `
-interface Greeter {
-  message: string;
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string | any[];
 }
-    `,
-    `
-interface Greeter {
-  message: Array<string>;
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string | Array<Array<any>>;
 }
-    `,
-    `
-interface Greeter {
-  message: string[];
+            `,
+        errors: [
+          {
+            column: 35,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string | Array<any[]>;
 }
-    `,
-    `
-interface Greeter {
-  message: Array<Array<string>>;
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string & any;
 }
-    `,
-    `
-interface Greeter {
-  message: Array<string[]>;
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string & Array<any>;
 }
-    `,
-    `
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
 type obj = {
-  message: string;
-};
-    `,
-    `
-type obj = {
-  message: Array<string>;
-};
-    `,
-    `
-type obj = {
-  message: string[];
-};
-    `,
-    `
-type obj = {
-  message: Array<Array<string>>;
-};
-    `,
-    `
-type obj = {
-  message: Array<string[]>;
-};
-    `,
-    `
-type obj = {
-  message: string | number;
-};
-    `,
-    `
-type obj = {
-  message: string | Array<string>;
-};
-    `,
-    `
-type obj = {
-  message: string | string[];
-};
-    `,
-    `
-type obj = {
-  message: string | Array<Array<string>>;
-};
-    `,
-    `
-type obj = {
-  message: string & number;
-};
-    `,
-    `
-type obj = {
-  message: string & Array<string>;
-};
-    `,
-    `
-type obj = {
-  message: string & string[];
-};
-    `,
-    `
-type obj = {
-  message: string & Array<Array<string>>;
-};
-    `,
-    // https://github.com/eslint/typescript-eslint-parser/issues/397
-    {
-      code: `
-        function foo(a: number, ...rest: any[]): void {
-          return;
-        }
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo1(...args: any[]) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar1 = function (...args: any[]) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz1 = (...args: any[]) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo2(...args: readonly any[]) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar2 = function (...args: readonly any[]) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz2 = (...args: readonly any[]) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo3(...args: Array<any>) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar3 = function (...args: Array<any>) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz3 = (...args: Array<any>) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function foo4(...args: ReadonlyArray<any>) {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const bar4 = function (...args: ReadonlyArray<any>) {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'const baz4 = (...args: ReadonlyArray<any>) => {};',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux1 {
-  (...args: any[]): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux2 {
-  (...args: readonly any[]): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux3 {
-  (...args: Array<any>): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Qux4 {
-  (...args: ReadonlyArray<any>): void;
-}
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux1(fn: (...args: any[]) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux2(fn: (...args: readonly any[]) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux3(fn: (...args: Array<any>) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz1(): (...args: any[]) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz2(): (...args: readonly any[]) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: 'function quuz3(): (...args: Array<any>) => void {}',
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      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;
+    message: string & any[];
 }
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Grault2 {
-  new (...args: readonly any[]): void;
+            `,
+        errors: [
+          {
+            column: 23,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string & Array<Array<any>>;
 }
-      `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Grault3 {
-  new (...args: Array<any>): void;
+            `,
+        errors: [
+          {
+            column: 35,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: `
+type obj = {
+    message: string & Array<any[]>;
 }
+            `,
+        errors: [
+          {
+            column: 29,
+            line: 3,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'class Foo<t = any> extends Bar<any> {}',
+        errors: [
+          {
+            column: 15,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'class Foo<t = unknown> extends Bar<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'class Foo<t = never> extends Bar<any> {}',
+              },
+            ],
+          },
+          {
+            column: 32,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'class Foo<t = any> extends Bar<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'class Foo<t = any> extends Bar<never> {}',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        code: 'abstract class Foo<t = any> extends Bar<any> {}',
+        errors: [
+          {
+            column: 24,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'abstract class Foo<t = unknown> extends Bar<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'abstract class Foo<t = never> extends Bar<any> {}',
+              },
+            ],
+          },
+          {
+            column: 41,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: 'abstract class Foo<t = any> extends Bar<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output: 'abstract class Foo<t = any> extends Bar<never> {}',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        code: 'abstract class Foo<t = any> implements Bar<any>, Baz<any> {}',
+        errors: [
+          {
+            column: 24,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output:
+                  'abstract class Foo<t = never> implements Bar<any>, Baz<any> {}',
+              },
+            ],
+          },
+          {
+            column: 44,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output:
+                  'abstract class Foo<t = any> implements Bar<never>, Baz<any> {}',
+              },
+            ],
+          },
+          {
+            column: 54,
+            line: 1,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output:
+                  'abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}',
+              },
+              {
+                messageId: 'suggestNever',
+                output:
+                  'abstract class Foo<t = any> implements Bar<any>, Baz<never> {}',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        code: 'new Foo<any>()',
+        errors: [
+          {
+            column: 9,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'Foo<any>()',
+        errors: [
+          {
+            column: 5,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        // https://github.com/typescript-eslint/typescript-eslint/issues/64
+        code: `
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<any>>() => {};
       `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Grault4 {
-  new (...args: ReadonlyArray<any>): void;
-}
+        errors: [
+          {
+            column: 33,
+            line: 2,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: `
+function test<T extends Partial<unknown>>() {}
+const test = <T extends Partial<any>>() => {};
       `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Garply1 {
-  f(...args: any[]): void;
-}
+              },
+              {
+                messageId: 'suggestNever',
+                output: `
+function test<T extends Partial<never>>() {}
+const test = <T extends Partial<any>>() => {};
       `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Garply2 {
-  f(...args: readonly any[]): void;
-}
+              },
+            ],
+          },
+          {
+            column: 33,
+            line: 3,
+            messageId: 'unexpectedAny',
+            suggestions: [
+              {
+                messageId: 'suggestUnknown',
+                output: `
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<unknown>>() => {};
       `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Garply3 {
-  f(...args: Array<any>): void;
-}
+              },
+              {
+                messageId: 'suggestNever',
+                output: `
+function test<T extends Partial<any>>() {}
+const test = <T extends Partial<never>>() => {};
       `,
-      options: [{ ignoreRestArgs: true }],
-    },
-    {
-      code: `
-interface Garply4 {
-  f(...args: ReadonlyArray<any>): void;
-}
+              },
+            ],
+          },
+        ],
+      },
+      {
+        // https://github.com/eslint/typescript-eslint-parser/issues/397
+        code: `
+        function foo(a: number, ...rest: any[]): void {
+          return;
+        }
       `,
-      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 }],
-    },
-  ],
+        errors: [
+          {
+            column: 42,
+            line: 2,
+            messageId: 'unexpectedAny',
+          },
+        ],
+      },
+      {
+        code: 'type Any = any;',
+        errors: [
+          {
+            column: 12,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'function foo5(...args: any) {}',
+        errors: [
+          {
+            column: 24,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'const bar5 = function (...args: any) {}',
+        errors: [
+          {
+            column: 33,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'const baz5 = (...args: any) => {}',
+        errors: [
+          {
+            column: 24,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'interface Qux5 { (...args: any): void; }',
+        errors: [
+          {
+            column: 28,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'function quux5(fn: (...args: any) => void): void {}',
+        errors: [
+          {
+            column: 30,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'function quuz5(): ((...args: any) => void) {}',
+        errors: [
+          {
+            column: 30,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'type Fred5 = (...args: any) => void;',
+        errors: [
+          {
+            column: 24,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'type Corge5 = new (...args: any) => void;',
+        errors: [
+          {
+            column: 29,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'interface Grault5 { new (...args: any): void; }',
+        errors: [
+          {
+            column: 35,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'interface Garply5 { f(...args: any): void; }',
+        errors: [
+          {
+            column: 32,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+      {
+        code: 'declare function waldo5(...args: any): void;',
+        errors: [
+          {
+            column: 34,
+            line: 1,
+            messageId: 'unexpectedAny',
+          },
+        ],
+        options: [{ ignoreRestArgs: true }],
+      },
+    ] as RuleInvalidTestCase[]
+  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
+    const suggestions = (code: string): RuleSuggestionOutput[] => [
+      {
+        messageId: 'suggestUnknown',
+        output: code.replace(/any/, 'unknown'),
+      },
+      {
+        messageId: 'suggestNever',
+        output: code.replace(/any/, 'never'),
+      },
+    ];
+    acc.push({
+      ...testCase,
+      errors: testCase.errors.map(e => ({
+        ...e,
+        suggestions: e.suggestions ?? suggestions(testCase.code),
+      })),
+    });
+    const options = testCase.options ?? [];
+    const code = `// fixToUnknown: true\n${testCase.code}`;
+    acc.push({
+      code,
+      errors: testCase.errors.map(err => {
+        if (err.line === undefined) {
+          return err;
+        }
+
+        return {
+          ...err,
+          line: err.line + 1,
+          suggestions:
+            err.suggestions?.map(
+              (s): RuleSuggestionOutput => ({
+                ...s,
+                output: `// fixToUnknown: true\n${s.output}`,
+              }),
+            ) ?? suggestions(code),
+        };
+      }),
+      options: [{ ...options[0], fixToUnknown: true }],
+      output: code.replaceAll('any', 'unknown'),
+    });
+
+    return acc;
+  }, []),
 });
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 f4b856cc1e46..752eca12868a 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
@@ -5,6 +5,43 @@ import rule from '../../src/rules/no-extra-non-null-assertion';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-extra-non-null-assertion', rule, {
+  valid: [
+    {
+      code: `
+const foo: { bar: number } | null = null;
+const bar = foo!.bar;
+      `,
+    },
+    {
+      code: `
+function foo(bar: number | undefined) {
+  const bar: number = bar!;
+}
+      `,
+    },
+    {
+      code: `
+function foo(bar?: { n: number }) {
+  return bar?.n;
+}
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2166
+    {
+      code: `
+checksCounter?.textContent!.trim();
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2732
+    {
+      code: `
+function foo(key: string | null) {
+  const obj = {};
+  return obj?.[key!];
+}
+      `,
+    },
+  ],
   invalid: [
     {
       code: `
@@ -160,43 +197,6 @@ function foo(bar?: { n: number }) {
       output: `
 function foo(bar?: { n: number }) {
   return (bar)?.();
-}
-      `,
-    },
-  ],
-  valid: [
-    {
-      code: `
-const foo: { bar: number } | null = null;
-const bar = foo!.bar;
-      `,
-    },
-    {
-      code: `
-function foo(bar: number | undefined) {
-  const bar: number = bar!;
-}
-      `,
-    },
-    {
-      code: `
-function foo(bar?: { n: number }) {
-  return bar?.n;
-}
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2166
-    {
-      code: `
-checksCounter?.textContent!.trim();
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2732
-    {
-      code: `
-function foo(key: string | null) {
-  const obj = {};
-  return obj?.[key!];
 }
       `,
     },
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 cb2d23b95812..5e9f29030edf 100644
--- a/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
@@ -16,6 +16,89 @@ const onlyConstructor = {
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-extraneous-class', rule, {
+  valid: [
+    `
+class Foo {
+  public prop = 1;
+  constructor() {}
+}
+    `,
+    `
+export class CClass extends BaseClass {
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
+  constructor() {}
+}
+    `,
+    `
+class Foo {
+  constructor(public bar: string) {}
+}
+    `,
+    {
+      code: 'class Foo {}',
+      options: [{ allowEmpty: true }],
+    },
+    {
+      code: `
+class Foo {
+  constructor() {}
+}
+      `,
+      options: [{ allowConstructorOnly: true }],
+    },
+    {
+      code: `
+export class Bar {
+  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!';
+  }
+}
+    `,
+    {
+      code: `
+@FooDecorator
+class Foo {}
+      `,
+      options: [{ allowWithDecorator: true }],
+    },
+    {
+      code: `
+@FooDecorator
+class Foo {
+  constructor(foo: Foo) {
+    foo.subscribe(a => {
+      console.log(a);
+    });
+  }
+}
+      `,
+      options: [{ allowWithDecorator: true }],
+    },
+    `
+abstract class Foo {
+  abstract property: string;
+}
+    `,
+    `
+abstract class Foo {
+  abstract method(): string;
+}
+    `,
+  ],
   invalid: [
     {
       code: 'class Foo {}',
@@ -129,88 +212,4 @@ abstract class Foo {
       errors: [onlyConstructor],
     },
   ],
-
-  valid: [
-    `
-class Foo {
-  public prop = 1;
-  constructor() {}
-}
-    `,
-    `
-export class CClass extends BaseClass {
-  public static helper(): void {}
-  private static privateHelper(): boolean {
-    return true;
-  }
-  constructor() {}
-}
-    `,
-    `
-class Foo {
-  constructor(public bar: string) {}
-}
-    `,
-    {
-      code: 'class Foo {}',
-      options: [{ allowEmpty: true }],
-    },
-    {
-      code: `
-class Foo {
-  constructor() {}
-}
-      `,
-      options: [{ allowConstructorOnly: true }],
-    },
-    {
-      code: `
-export class Bar {
-  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!';
-  }
-}
-    `,
-    {
-      code: `
-@FooDecorator
-class Foo {}
-      `,
-      options: [{ allowWithDecorator: true }],
-    },
-    {
-      code: `
-@FooDecorator
-class Foo {
-  constructor(foo: Foo) {
-    foo.subscribe(a => {
-      console.log(a);
-    });
-  }
-}
-      `,
-      options: [{ allowWithDecorator: true }],
-    },
-    `
-abstract class Foo {
-  abstract property: string;
-}
-    `,
-    `
-abstract class Foo {
-  abstract method(): string;
-}
-    `,
-  ],
 });
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 e9db3157f76b..f5bd7d785031 100644
--- a/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
@@ -15,243 +15,311 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-floating-promises', rule, {
-  invalid: [
+  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(() => {});
+  return Promise.resolve('value');
+}
+    `,
     {
       code: `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  void Promise.resolve('value');
 }
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
+      options: [{ ignoreVoid: true }],
+    },
+    `
 async function test() {
-  void Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  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(() => {});
+  return Promise.reject(new Error('message'));
 }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
+    `,
+    `
 async function test() {
-  await Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  await (async () => true)();
+  (async () => true)().then(
+    () => {},
+    () => {},
+  );
+  (async () => true)()
+    .then(() => {})
+    .catch(() => {});
+  (async () => true)()
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  (async () => true)().catch(() => {});
+  return (async () => true)();
 }
-      `,
-            },
-          ],
-        },
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  void Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  async function returnsPromise() {}
+  await returnsPromise();
+  returnsPromise().then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {});
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  returnsPromise().catch(() => {});
+  return returnsPromise();
 }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  await Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  const x = Promise.resolve();
+  const y = x.then(() => {});
+  y.catch(() => {});
 }
-      `,
-            },
-          ],
-        },
-        {
-          line: 5,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  void Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  Math.random() > 0.5 ? Promise.resolve().catch(() => {}) : null;
 }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  await Promise.resolve('value').catch();
-  Promise.resolve('value').finally();
+  Promise.resolve().catch(() => {}), 123;
+  123,
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    );
+  123,
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    ),
+    123;
 }
-      `,
-            },
-          ],
-        },
-        {
-          line: 6,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  void Promise.resolve('value').finally();
+  void Promise.resolve().catch(() => {});
 }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
+    `,
+    `
 async function test() {
-  Promise.resolve('value');
-  Promise.resolve('value').then(() => {});
-  Promise.resolve('value').catch();
-  await Promise.resolve('value').finally();
+  Promise.resolve().catch(() => {}) ||
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    );
 }
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
-      `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  void obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  await obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
+    `,
+    `
+declare const promiseValue: Promise<number>;
+async function test() {
+  await promiseValue;
+  promiseValue.then(
+    () => {},
+    () => {},
+  );
+  promiseValue.then(() => {}).catch(() => {});
+  promiseValue
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promiseValue.catch(() => {});
+  return promiseValue;
+}
+    `,
+    `
+declare const promiseUnion: Promise<number> | number;
+async function test() {
+  await promiseUnion;
+  promiseUnion.then(
+    () => {},
+    () => {},
+  );
+  promiseUnion.then(() => {}).catch(() => {});
+  promiseUnion
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promiseUnion.catch(() => {});
+  promiseValue.finally(() => {});
+  return promiseUnion;
+}
+    `,
+    `
+declare const promiseIntersection: Promise<number> & number;
+async function test() {
+  await promiseIntersection;
+  promiseIntersection.then(
+    () => {},
+    () => {},
+  );
+  promiseIntersection.then(() => {}).catch(() => {});
+  promiseIntersection.catch(() => {});
+  return promiseIntersection;
+}
+    `,
+    `
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  callback?.();
-};
+  await canThen;
+  canThen.then(
+    () => {},
+    () => {},
+  );
+  canThen.then(() => {}).catch(() => {});
+  canThen
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  canThen.catch(() => {});
+  return canThen;
+}
+    `,
+    `
+declare const intersectionPromise: Promise<number> & number;
+async function test() {
+  await (Math.random() > 0.5 ? numberPromise : 0);
+  await (Math.random() > 0.5 ? foo : 0);
+  await (Math.random() > 0.5 ? bar : 0);
 
-doSomething();
-      `,
-            },
-          ],
-        },
-        {
-          line: 12,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  void obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
+  await intersectionPromise;
+}
+    `,
+    `
+async function test() {
+  class Thenable {
+    then(callback: () => void): Thenable {
+      return new Thenable();
+    }
+  }
+  const thenable = new Thenable();
 
-  callback?.();
-};
+  await thenable;
+  thenable;
+  thenable.then(() => {});
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class NonFunctionParamThenable {
+    then(param: string, param2: number): NonFunctionParamThenable {
+      return new NonFunctionParamThenable();
+    }
+  }
+  const thenable = new NonFunctionParamThenable();
 
-doSomething();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
+  await thenable;
+  thenable;
+  thenable.then('abc', 'def');
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class NonFunctionThenable {
+    then: number;
+  }
+  const thenable = new NonFunctionThenable();
+
+  thenable;
+  thenable.then;
+  return thenable;
+}
+    `,
+    `
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  await thenable;
+  return thenable;
+}
+    `,
+    `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  await promise;
+  promise.then(
+    () => {},
+    () => {},
+  );
+  promise.then(() => {}).catch(() => {});
+  promise
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  promise.catch(() => {});
+  return promise;
+}
+    `,
+
+    // optional chaining
+    `
+declare const returnsPromise: () => Promise<void> | null;
+async function test() {
+  await returnsPromise?.();
+  returnsPromise()?.then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    ?.then(() => {})
+    ?.catch(() => {});
+  returnsPromise()?.catch(() => {});
+  return returnsPromise();
+}
+    `,
+    `
 const doSomething = async (
   obj1: { a?: { b?: { c?: () => Promise<void> } } },
   obj2: { a?: { b?: { c: () => Promise<void> } } },
@@ -261,779 +329,549 @@ const doSomething = async (
   obj6?: { a: { b: { c?: () => Promise<void> } } },
   callback?: () => Promise<void>,
 ): Promise<void> => {
-  obj1.a?.b?.c?.();
+  await obj1.a?.b?.c?.();
   await obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
+  await obj3.a?.b.c?.();
+  await obj4.a.b.c?.();
+  await obj5.a?.().b?.c?.();
+  await obj6?.a.b.c?.();
 
-  callback?.();
+  return callback?.();
 };
 
-doSomething();
-      `,
-            },
-          ],
-        },
-        {
-          line: 13,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  void obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+void doSomething();
+    `,
+    // ignoreIIFE
+    {
+      code: `
+        (async () => {
+          await something();
+        })();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  await obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+        (async () => {
+          something();
+        })();
       `,
-            },
-          ],
-        },
-        {
-          line: 14,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  void obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: '(async function foo() {})();',
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+        function foo() {
+          (async function bar() {})();
+        }
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  await obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+        const foo = () =>
+          new Promise(res => {
+            (async function () {
+              await res(1);
+            })();
+          });
       `,
-            },
-          ],
-        },
-        {
-          line: 15,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  void obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+        (async function () {
+          await res(1);
+        })();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  await obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  void (condition && myPromise());
+}
       `,
-            },
-          ],
-        },
-        {
-          line: 16,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  void obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  await (condition && myPromise());
+}
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  await obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-doSomething();
-      `,
-            },
-          ],
-        },
-        {
-          line: 18,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  void callback?.();
-};
-
-doSomething();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  await callback?.();
-};
-
-doSomething();
-      `,
-            },
-          ],
-        },
-        {
-          line: 21,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-void doSomething();
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  obj1.a?.b?.c?.();
-  obj2.a?.b?.c();
-  obj3.a?.b.c?.();
-  obj4.a.b.c?.();
-  obj5.a?.().b?.c?.();
-  obj6?.a.b.c?.();
-
-  callback?.();
-};
-
-await doSomething();
-      `,
-            },
-          ],
-        },
-      ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`;
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`;
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  condition && void myPromise();
+}
       `,
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.then(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+  condition && (await myPromise());
+}
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`.then(() => {});
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function foo() {
+  const myPromise = async () => void 0;
+  let condition = false;
+  condition && myPromise();
+  condition = true;
+  condition || myPromise();
+  condition ?? myPromise();
+}
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`.then(() => {});
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+declare const definitelyCallable: () => void;
+Promise.reject().catch(definitelyCallable);
       `,
-            },
-          ],
-        },
-      ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.finally(() => {});
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {});
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-void myTag\`abc\`.finally(() => {});
+    },
+    {
+      code: `
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-await myTag\`abc\`.finally(() => {});
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+Promise.reject()
+  .catch(() => {})
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
-            },
-          ],
-        },
-      ],
     },
-
     {
       code: `
-async function test() {
-  Promise.resolve('value');
-}
+await Promise.all([Promise.resolve(), Promise.resolve()]);
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  void Promise.resolve('value');
-}
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+void promiseArray;
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  await Promise.resolve('value');
+    },
+    {
+      // Expressions aren't checked by this rule, so this just becomes an array
+      // of number | undefined, which is fine regardless of the ignoreVoid setting.
+      code: `
+[1, 2, void Promise.reject(), 3];
+      `,
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+['I', 'am', 'just', 'an', 'array'];
+      `,
+    },
+    {
+      code: `
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
 }
+let promise: SafeThenable<number> = Promise.resolve(5);
+0, promise;
       `,
-            },
-          ],
+      options: [
+        {
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
-      options: [{ ignoreVoid: true }],
     },
     {
       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();
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
 }
+let promise: SafeThenable<number> = Promise.resolve(5);
+0 ? promise : 3;
       `,
-      errors: [
+      options: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  void Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  await Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
-      `,
-            },
-          ],
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  void Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  await Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
+      ],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: { a: SafePromise<number> } = { a: Promise.resolve(5) };
+promise.a;
       `,
-            },
-          ],
-        },
-        {
-          line: 5,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  void Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+promise;
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  await Promise.reject(new Error('message')).catch();
-  Promise.reject(new Error('message')).finally();
-}
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: Foo = Promise.resolve(5);
+0 || promise;
       `,
-            },
-          ],
-        },
-        {
-          line: 6,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  void Promise.reject(new Error('message')).finally();
-}
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: Foo = Promise.resolve(5);
+promise.finally();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  Promise.reject(new Error('message'));
-  Promise.reject(new Error('message')).then(() => {});
-  Promise.reject(new Error('message')).catch();
-  await Promise.reject(new Error('message')).finally();
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
 }
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+0, promise();
       `,
-            },
-          ],
+      options: [
+        {
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
         },
       ],
     },
     {
       code: `
-async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
 }
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+0 ? promise() : 3;
       `,
-      errors: [
+      options: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  void (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
-}
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+        },
+      ],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: () => Foo = () => Promise.resolve(5);
+promise();
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  await (async () => true)();
-  (async () => true)().then(() => {});
-  (async () => true)().catch();
-}
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo = Promise<number> & { hey?: string };
+let promise: () => Foo = async () => 5;
+promise().finally();
+      `,
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: () => SafePromise<number> = async () => 5;
+0 || promise();
+      `,
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+class SafePromise<T> extends Promise<T> {}
+let promise: () => SafePromise<number> = async () => 5;
+null ?? promise();
+      `,
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+let promise: () => PromiseLike<number> = () => Promise.resolve(5);
+promise();
+      `,
+      options: [
+        { allowForKnownSafePromises: [{ from: 'lib', name: 'PromiseLike' }] },
+      ],
+    },
+    {
+      code: `
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: Foo<unknown>[];
+arrayOrPromiseTuple;
+      `,
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
+arrayOrPromiseTuple;
+      `,
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+    },
+    {
+      code: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+myTag\`abc\`;
+      `,
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        it('...', () => {});
       `,
+      options: [
+        {
+          allowForKnownSafeCalls: [
+            {
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
             },
           ],
         },
-        {
-          line: 4,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  (async () => true)();
-  void (async () => true)().then(() => {});
-  (async () => true)().catch();
+      ],
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.catch(() => {});
+      `,
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => string;
+myTag\`abc\`;
+      `,
+    },
+    {
+      code: `
+declare let x: any;
+declare const promiseArray: Array<Promise<unknown>>;
+x = promiseArray;
+      `,
+    },
+    {
+      code: `
+declare let x: Promise<number>;
+x = Promise.resolve(2);
+      `,
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+async function f() {
+  return promiseArray;
 }
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  (async () => true)();
-  await (async () => true)().then(() => {});
-  (async () => true)().catch();
+    },
+    {
+      code: `
+declare const promiseArray: Array<Promise<unknown>>;
+async function* generator() {
+  yield* promiseArray;
 }
       `,
-            },
-          ],
-        },
-        {
-          line: 5,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  void (async () => true)().catch();
+    },
+    {
+      code: `
+async function* generator() {
+  yield Promise.resolve();
 }
       `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  (async () => true)();
-  (async () => true)().then(() => {});
-  await (async () => true)().catch();
+    },
+    {
+      code: `
+interface SafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): SafeThenable<TResult1 | TResult2>;
 }
+let promise: () => SafeThenable<number> = () => Promise.resolve(5);
+promise().then(() => {});
       `,
-            },
+      options: [
+        {
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+        },
+      ],
+    },
+
+    {
+      code: `
+        declare module 'abc' {
+          export function it(name: string, action: () => void): void;
+        }
+        it('...', () => {});
+      `,
+      options: [
+        {
+          allowForKnownSafeCalls: [
+            { from: 'package', name: 'it', package: 'abc' },
           ],
         },
       ],
     },
     {
       code: `
-async function test() {
-  async function returnsPromise() {}
+        declare module 'abc' {
+          export function it(name: string, action: () => void): void;
+        }
 
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
-}
+        it('...', () => {});
       `,
-      errors: [
+      options: [
         {
-          line: 5,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  async function returnsPromise() {}
+          allowForKnownSafeCalls: [
+            { from: 'package', name: 'it', package: 'abc' },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+interface SafePromise<T> extends Promise<T> {
+  brand: 'safe';
+}
 
-  void returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
-}
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  async function returnsPromise() {}
-
-  await returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
-}
+declare const createSafePromise: () => SafePromise<string>;
+createSafePromise();
       `,
-            },
-          ],
-        },
+      options: [
         {
-          line: 6,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  void returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+          allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }],
+          checkThenables: true,
+        },
+      ],
+    },
+    `
+declare const createPromiseLike: () => PromiseLike<number>;
+createPromiseLike();
+    `,
+    `
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
 }
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  async function returnsPromise() {}
 
-  returnsPromise();
-  await returnsPromise().then(() => {});
-  returnsPromise().catch();
-  returnsPromise().finally();
+declare function createMyThenable(): MyThenable;
+
+createMyThenable();
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+async function test() {
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
-            },
-          ],
-        },
+      errors: [
         {
-          line: 7,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  returnsPromise().then(() => {});
-  void returnsPromise().catch();
-  returnsPromise().finally();
+  void Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
@@ -1041,31 +879,27 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  returnsPromise().then(() => {});
-  await returnsPromise().catch();
-  returnsPromise().finally();
+  await Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
           ],
         },
         {
-          line: 8,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  void returnsPromise().finally();
+  Promise.resolve('value');
+  void Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
@@ -1073,37 +907,27 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  async function returnsPromise() {}
-
-  returnsPromise();
-  returnsPromise().then(() => {});
-  returnsPromise().catch();
-  await returnsPromise().finally();
+  Promise.resolve('value');
+  await Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  Math.random() > 0.5 ? null : Promise.resolve();
-}
-      `,
-      errors: [
         {
-          line: 3,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void (Math.random() > 0.5 ? Promise.resolve() : null);
-  Math.random() > 0.5 ? null : Promise.resolve();
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  void Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
@@ -1111,23 +935,27 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  await (Math.random() > 0.5 ? Promise.resolve() : null);
-  Math.random() > 0.5 ? null : Promise.resolve();
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  await Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
       `,
             },
           ],
         },
         {
-          line: 4,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  void (Math.random() > 0.5 ? null : Promise.resolve());
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  void Promise.resolve('value').finally();
 }
       `,
             },
@@ -1135,8 +963,10 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  Math.random() > 0.5 ? Promise.resolve() : null;
-  await (Math.random() > 0.5 ? null : Promise.resolve());
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  await Promise.resolve('value').finally();
 }
       `,
             },
@@ -1146,608 +976,689 @@ async function test() {
     },
     {
       code: `
-async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
       errors: [
         {
-          line: 3,
+          line: 11,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  void (Promise.resolve(), 123);
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  void obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  await (Promise.resolve(), 123);
-  123, Promise.resolve();
-  123, Promise.resolve(), 123;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  await obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
         {
-          line: 4,
+          line: 12,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  Promise.resolve(), 123;
-  void (123, Promise.resolve());
-  123, Promise.resolve(), 123;
-}
-      `,
-            },
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function test() {
-  Promise.resolve(), 123;
-  await (123, Promise.resolve());
-  123, Promise.resolve(), 123;
-}
-      `,
-            },
-          ],
-        },
-        {
-          line: 5,
-          messageId: 'floatingVoid',
-          suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  void (123, Promise.resolve(), 123);
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  void obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  Promise.resolve(), 123;
-  123, Promise.resolve();
-  await (123, Promise.resolve(), 123);
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  await obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  void Promise.resolve();
-}
-      `,
-      errors: [
         {
-          line: 3,
-          messageId: 'floating',
+          line: 13,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  await Promise.resolve();
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  void obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
-          ],
-        },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function test() {
-  const promise = new Promise((resolve, reject) => resolve('value'));
-  promise;
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'floating',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  const promise = new Promise((resolve, reject) => resolve('value'));
-  await promise;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  await obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function returnsPromise() {
-  return 'value';
-}
-void returnsPromise();
-      `,
-      errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 14,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await returnsPromise();
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  void obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
-          ],
-        },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
-      code: `
-async function returnsPromise() {
-  return 'value';
-}
-void /* ... */ returnsPromise();
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'floating',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await /* ... */ returnsPromise();
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  await obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function returnsPromise() {
-  return 'value';
-}
-1, returnsPromise();
-      `,
-      errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 15,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await (1, returnsPromise());
-      `,
-            },
-          ],
-        },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function returnsPromise() {
-  return 'value';
-}
-bool ? returnsPromise() : null;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'floating',
-          suggestions: [
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  void obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function returnsPromise() {
-  return 'value';
-}
-await (bool ? returnsPromise() : null);
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  await obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  obj.foo;
-}
-      `,
-      errors: [
         {
-          line: 4,
+          line: 16,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  void obj.foo;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  void obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  const obj = { foo: Promise.resolve() };
-  await obj.foo;
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  await obj6?.a.b.c?.();
+
+  callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  new Promise(resolve => resolve());
-}
-      `,
-      errors: [
         {
-          line: 3,
+          line: 18,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function test() {
-  void new Promise(resolve => resolve());
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  void callback?.();
+};
+
+doSomething();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function test() {
-  await new Promise(resolve => resolve());
-}
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
+
+  await callback?.();
+};
+
+doSomething();
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
-      `,
-      errors: [
         {
-          line: 5,
+          line: 21,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-async function test() {
-  void promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+  callback?.();
+};
+
+void doSomething();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
+const doSomething = async (
+  obj1: { a?: { b?: { c?: () => Promise<void> } } },
+  obj2: { a?: { b?: { c: () => Promise<void> } } },
+  obj3: { a?: { b: { c?: () => Promise<void> } } },
+  obj4: { a: { b: { c?: () => Promise<void> } } },
+  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
+  obj6?: { a: { b: { c?: () => Promise<void> } } },
+  callback?: () => Promise<void>,
+): Promise<void> => {
+  obj1.a?.b?.c?.();
+  obj2.a?.b?.c();
+  obj3.a?.b.c?.();
+  obj4.a.b.c?.();
+  obj5.a?.().b?.c?.();
+  obj6?.a.b.c?.();
 
-async function test() {
-  await promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+  callback?.();
+};
+
+await doSomething();
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`;
+      `,
+      errors: [
         {
-          line: 6,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  void promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`;
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  await promiseValue.then(() => {});
-  promiseValue.catch();
-  promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`;
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.then(() => {});
+      `,
+      errors: [
         {
-          line: 7,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  void promiseValue.catch();
-  promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`.then(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  await promiseValue.catch();
-  promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`.then(() => {});
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+myTag\`abc\`.finally(() => {});
+      `,
+      errors: [
         {
-          line: 8,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  void promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+void myTag\`abc\`.finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseValue: Promise<number>;
-
-async function test() {
-  promiseValue;
-  promiseValue.then(() => {});
-  promiseValue.catch();
-  await promiseValue.finally();
-}
+declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
+await myTag\`abc\`.finally(() => {});
       `,
             },
           ],
         },
       ],
     },
+
     {
       code: `
-declare const promiseUnion: Promise<number> | number;
-
 async function test() {
-  promiseUnion;
+  Promise.resolve('value');
 }
       `,
       errors: [
         {
-          line: 5,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseUnion: Promise<number> | number;
-
 async function test() {
-  void promiseUnion;
+  void Promise.resolve('value');
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseUnion: Promise<number> | number;
-
 async function test() {
-  await promiseUnion;
+  await Promise.resolve('value');
 }
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: true }],
     },
     {
       code: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  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: 5,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  void promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  void Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  await promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  await Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
           ],
         },
         {
-          line: 6,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  promiseIntersection;
-  void promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  Promise.reject(new Error('message'));
+  void Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  promiseIntersection;
-  await promiseIntersection.then(() => {});
-  promiseIntersection.catch();
+  Promise.reject(new Error('message'));
+  await Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
           ],
         },
         {
-          line: 7,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  void promiseIntersection.catch();
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  void Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-
 async function test() {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  await promiseIntersection.catch();
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  await Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
-}
-      `,
-      errors: [
         {
           line: 6,
           messageId: 'floatingVoid',
@@ -1756,13 +1667,10 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  void canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  void Promise.reject(new Error('message')).finally();
 }
       `,
             },
@@ -1770,33 +1678,37 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  await canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  await Promise.reject(new Error('message')).finally();
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
+}
+      `,
+      errors: [
         {
-          line: 7,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  void canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  void (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -1804,33 +1716,25 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  await canThen.then(() => {});
-  canThen.catch();
-  canThen.finally();
+  await (async () => true)();
+  (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
           ],
         },
         {
-          line: 8,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  void canThen.catch();
-  canThen.finally();
+  (async () => true)();
+  void (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
@@ -1838,33 +1742,25 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  await canThen.catch();
-  canThen.finally();
+  (async () => true)();
+  await (async () => true)().then(() => {});
+  (async () => true)().catch();
 }
       `,
             },
           ],
         },
         {
-          line: 9,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  void canThen.finally();
+  (async () => true)();
+  (async () => true)().then(() => {});
+  void (async () => true)().catch();
 }
       `,
             },
@@ -1872,13 +1768,9 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  canThen;
-  canThen.then(() => {});
-  canThen.catch();
-  await canThen.finally();
+  (async () => true)();
+  (async () => true)().then(() => {});
+  await (async () => true)().catch();
 }
       `,
             },
@@ -1889,35 +1781,29 @@ async function test() {
     {
       code: `
 async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+  async function returnsPromise() {}
 
-  thenable;
-  thenable.then(() => {});
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
       errors: [
         {
-          line: 10,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+  async function returnsPromise() {}
 
-  void thenable;
-  thenable.then(() => {});
+  void returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
@@ -1925,37 +1811,31 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+  async function returnsPromise() {}
 
-  await thenable;
-  thenable.then(() => {});
+  await returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
           ],
         },
         {
-          line: 11,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+  async function returnsPromise() {}
 
-  thenable;
-  void thenable.then(() => {});
+  returnsPromise();
+  void returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
@@ -1963,242 +1843,135 @@ async function test() {
               messageId: 'floatingFixAwait',
               output: `
 async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
+  async function returnsPromise() {}
 
-  thenable;
-  await thenable.then(() => {});
+  returnsPromise();
+  await returnsPromise().then(() => {});
+  returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
           ],
         },
-      ],
-      options: [{ checkThenables: true }],
-    },
-    {
-      code: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
-
-  promise;
-  promise.then(() => {});
-  promise.catch();
-}
-      `,
-      errors: [
         {
-          line: 18,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
+  async function returnsPromise() {}
 
-  void promise;
-  promise.then(() => {});
-  promise.catch();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  void returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
+  async function returnsPromise() {}
 
-  await promise;
-  promise.then(() => {});
-  promise.catch();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  await returnsPromise().catch();
+  returnsPromise().finally();
 }
       `,
             },
           ],
         },
         {
-          line: 19,
+          line: 8,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
+  async function returnsPromise() {}
 
-  promise;
-  void promise.then(() => {});
-  promise.catch();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  void returnsPromise().finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
+  async function returnsPromise() {}
 
-  promise;
-  await promise.then(() => {});
-  promise.catch();
+  returnsPromise();
+  returnsPromise().then(() => {});
+  returnsPromise().catch();
+  await returnsPromise().finally();
 }
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  Math.random() > 0.5 ? null : Promise.resolve();
+}
+      `,
+      errors: [
         {
-          line: 20,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
-
-  promise;
-  promise.then(() => {});
-  void promise.catch();
+  void (Math.random() > 0.5 ? Promise.resolve() : null);
+  Math.random() > 0.5 ? null : Promise.resolve();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
 async function test() {
-  const promise = new PromisePolyfill(() => {});
-
-  promise;
-  promise.then(() => {});
-  await promise.catch();
+  await (Math.random() > 0.5 ? Promise.resolve() : null);
+  Math.random() > 0.5 ? null : Promise.resolve();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        (async () => {
-          await something();
-        })();
-      `,
-      errors: [
         {
-          line: 2,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        void (async () => {
-          await something();
-        })();
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  void (Math.random() > 0.5 ? null : Promise.resolve());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async () => {
-          await something();
-        })();
+async function test() {
+  Math.random() > 0.5 ? Promise.resolve() : null;
+  await (Math.random() > 0.5 ? null : Promise.resolve());
+}
       `,
             },
           ],
@@ -2207,79 +1980,87 @@ async function test() {
     },
     {
       code: `
-        (async () => {
-          something();
-        })();
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
       `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        void (async () => {
-          something();
-        })();
+async function test() {
+  void (Promise.resolve(), 123);
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async () => {
-          something();
-        })();
+async function test() {
+  await (Promise.resolve(), 123);
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
+}
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: '(async function foo() {})();',
-      errors: [
         {
-          line: 1,
+          line: 4,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
-              output: 'void (async function foo() {})();',
+              output: `
+async function test() {
+  Promise.resolve(), 123;
+  void (123, Promise.resolve());
+  123, Promise.resolve(), 123;
+}
+      `,
             },
             {
               messageId: 'floatingFixAwait',
-              output: 'await (async function foo() {})();',
+              output: `
+async function test() {
+  Promise.resolve(), 123;
+  await (123, Promise.resolve());
+  123, Promise.resolve(), 123;
+}
+      `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-        function foo() {
-          (async function bar() {})();
-        }
-      `,
-      errors: [
         {
-          line: 3,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        function foo() {
-          void (async function bar() {})();
-        }
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  void (123, Promise.resolve(), 123);
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        function foo() {
-          await (async function bar() {})();
-        }
+async function test() {
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  await (123, Promise.resolve(), 123);
+}
       `,
             },
           ],
@@ -2288,116 +2069,165 @@ async function test() {
     },
     {
       code: `
-        const foo = () =>
-          new Promise(res => {
-            (async function () {
-              await res(1);
-            })();
-          });
+async function test() {
+  void Promise.resolve();
+}
       `,
       errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 3,
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-        const foo = () =>
-          new Promise(res => {
-            void (async function () {
-              await res(1);
-            })();
-          });
+async function test() {
+  await Promise.resolve();
+}
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function test() {
+  const promise = new Promise((resolve, reject) => resolve('value'));
+  promise;
+}
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-        const foo = () =>
-          new Promise(res => {
-            await (async function () {
-              await res(1);
-            })();
-          });
+async function test() {
+  const promise = new Promise((resolve, reject) => resolve('value'));
+  await promise;
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-        (async function () {
-          await res(1);
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+void returnsPromise();
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-        void (async function () {
-          await res(1);
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+await returnsPromise();
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
+      code: `
+async function returnsPromise() {
+  return 'value';
+}
+void /* ... */ returnsPromise();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-        await (async function () {
-          await res(1);
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+await /* ... */ returnsPromise();
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-        (async function () {
-          Promise.resolve();
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+1, returnsPromise();
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-        (async function () {
-          void Promise.resolve();
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+await (1, returnsPromise());
       `,
             },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+async function returnsPromise() {
+  return 'value';
+}
+bool ? returnsPromise() : null;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'floating',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-        (async function () {
-          await Promise.resolve();
-        })();
+async function returnsPromise() {
+  return 'value';
+}
+await (bool ? returnsPromise() : null);
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreIIFE: true }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+async function test() {
+  const obj = { foo: Promise.resolve() };
+  obj.foo;
+}
       `,
       errors: [
         {
@@ -2407,225 +2237,228 @@ declare const promiseIntersection: Promise<number> & number;
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  void promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+async function test() {
+  const obj = { foo: Promise.resolve() };
+  void obj.foo;
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  await promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+async function test() {
+  const obj = { foo: Promise.resolve() };
+  await obj.foo;
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  new Promise(resolve => resolve());
+}
+      `,
+      errors: [
         {
-          line: 5,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  void promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+async function test() {
+  void new Promise(resolve => resolve());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  await promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+async function test() {
+  await new Promise(resolve => resolve());
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
+      `,
+      errors: [
         {
-          line: 6,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  void promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  void promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  await promiseIntersection.catch();
-  promiseIntersection.finally();
-})();
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  await promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
       `,
             },
           ],
         },
         {
-          line: 7,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  void promiseIntersection.finally();
-})();
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  promiseValue;
+  void promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const promiseIntersection: Promise<number> & number;
-(async function () {
-  promiseIntersection;
-  promiseIntersection.then(() => {});
-  promiseIntersection.catch();
-  await promiseIntersection.finally();
-})();
+declare const promiseValue: Promise<number>;
+
+async function test() {
+  promiseValue;
+  await promiseValue.then(() => {});
+  promiseValue.catch();
+  promiseValue.finally();
+}
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreIIFE: true }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-
-  void condition || myPromise();
-}
-      `,
-      errors: [
         {
-          line: 6,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseValue: Promise<number>;
 
-  void (void condition || myPromise());
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  void promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseValue: Promise<number>;
 
-  await (void condition || myPromise());
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  await promiseValue.catch();
+  promiseValue.finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+        {
+          line: 8,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const promiseValue: Promise<number>;
 
-  (await condition) && myPromise();
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  void promiseValue.finally();
 }
       `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'floating',
-          suggestions: [
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseValue: Promise<number>;
 
-  await ((await condition) && myPromise());
+async function test() {
+  promiseValue;
+  promiseValue.then(() => {});
+  promiseValue.catch();
+  await promiseValue.finally();
 }
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseUnion: Promise<number> | number;
 
-  condition && myPromise();
+async function test() {
+  promiseUnion;
 }
       `,
       errors: [
         {
-          line: 6,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseUnion: Promise<number> | number;
 
-  void (condition && myPromise());
+async function test() {
+  void promiseUnion;
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
+declare const promiseUnion: Promise<number> | number;
 
-  await (condition && myPromise());
+async function test() {
+  await promiseUnion;
 }
       `,
             },
@@ -2635,54 +2468,45 @@ async function foo() {
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+declare const promiseIntersection: Promise<number> & number;
 
-  condition || myPromise();
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
       errors: [
         {
-          line: 6,
+          line: 5,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+declare const promiseIntersection: Promise<number> & number;
 
-  void (condition || myPromise());
+async function test() {
+  void promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+declare const promiseIntersection: Promise<number> & number;
 
-  await (condition || myPromise());
+async function test() {
+  await promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
-
-  condition ?? myPromise();
-}
-      `,
-      errors: [
         {
           line: 6,
           messageId: 'floatingVoid',
@@ -2690,120 +2514,71 @@ async function foo() {
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
+declare const promiseIntersection: Promise<number> & number;
 
-  void (condition ?? myPromise());
+async function test() {
+  promiseIntersection;
+  void promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = null;
+declare const promiseIntersection: Promise<number> & number;
 
-  await (condition ?? myPromise());
-}
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = true;
-  condition && myPromise;
-}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'floating',
-          suggestions: [
-            {
-              messageId: 'floatingFixAwait',
-              output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = true;
-  await (condition && myPromise);
+async function test() {
+  promiseIntersection;
+  await promiseIntersection.then(() => {});
+  promiseIntersection.catch();
 }
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = false;
-  condition || myPromise;
-}
-      `,
-      errors: [
         {
-          line: 5,
-          messageId: 'floating',
+          line: 7,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = false;
-  await (condition || myPromise);
+declare const promiseIntersection: Promise<number> & number;
+
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  void promiseIntersection.catch();
 }
       `,
             },
-          ],
-        },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = null;
-  condition ?? myPromise;
-}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'floating',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = Promise.resolve(true);
-  let condition = null;
-  await (condition ?? myPromise);
+declare const promiseIntersection: Promise<number> & number;
+
+async function test() {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  await promiseIntersection.catch();
 }
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  condition || condition || myPromise();
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
       errors: [
@@ -2814,378 +2589,419 @@ async function foo() {
             {
               messageId: 'floatingFixVoid',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  void (condition || condition || myPromise());
+  void canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = false;
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-  await (condition || condition || myPromise());
+  await canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
 }
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 7,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-void Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  void canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-await Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  await canThen.then(() => {});
+  canThen.catch();
+  canThen.finally();
+}
       `,
             },
           ],
         },
         {
-          line: 5,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 8,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-void Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  canThen.then(() => {});
+  void canThen.catch();
+  canThen.finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-await Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  canThen.then(() => {});
+  await canThen.catch();
+  canThen.finally();
+}
       `,
             },
           ],
         },
         {
-          line: 6,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 9,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-void Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  void canThen.finally();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-await Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CanThen extends Promise<number> {}
+  const canThen: CanThen = Foo.resolve(2);
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  canThen;
+  canThen.then(() => {});
+  canThen.catch();
+  await canThen.finally();
+}
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
+
+  thenable;
+  thenable.then(() => {});
+}
+      `,
+      errors: [
         {
-          line: 7,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 10,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-void Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  void thenable;
+  thenable.then(() => {});
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-await Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  await thenable;
+  thenable.then(() => {});
+}
       `,
             },
           ],
         },
         {
-          line: 10,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 11,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
 
-void Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  thenable;
+  void thenable.then(() => {});
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+async function test() {
+  class CatchableThenable {
+    then(callback: () => void, callback: () => void): CatchableThenable {
+      return new CatchableThenable();
+    }
+  }
+  const thenable = new CatchableThenable();
 
-await Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+  thenable;
+  await thenable.then(() => {});
+}
       `,
             },
           ],
         },
+      ],
+      options: [{ checkThenables: true }],
+    },
+    {
+      code: `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  promise.then(() => {});
+  promise.catch();
+}
+      `,
+      errors: [
         {
-          line: 11,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 18,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-Promise.resolve().catch(undefined);
-void Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  void promise;
+  promise.then(() => {});
+  promise.catch();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-Promise.resolve().catch(undefined);
-await Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  await promise;
+  promise.then(() => {});
+  promise.catch();
+}
       `,
             },
           ],
         },
         {
-          line: 12,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 19,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-void Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  void promise.then(() => {});
+  promise.catch();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-await Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  await promise.then(() => {});
+  promise.catch();
+}
       `,
             },
           ],
         },
         {
-          line: 13,
-          messageId: 'floatingUselessRejectionHandlerVoid',
+          line: 20,
+          messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-void Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  promise.then(() => {});
+  void promise.catch();
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-await Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+interface PromisePolyfillConstructor extends PromiseConstructor {
+  _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  promise;
+  promise.then(() => {});
+  await promise.catch();
+}
       `,
             },
           ],
@@ -3194,7 +3010,9 @@ Promise.resolve().catch(definitelyCallable);
     },
     {
       code: `
-Promise.reject() || 3;
+        (async () => {
+          await something();
+        })();
       `,
       errors: [
         {
@@ -3204,13 +3022,17 @@ Promise.reject() || 3;
             {
               messageId: 'floatingFixVoid',
               output: `
-void (Promise.reject() || 3);
+        void (async () => {
+          await something();
+        })();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.reject() || 3);
+        await (async () => {
+          await something();
+        })();
       `,
             },
           ],
@@ -3219,386 +3041,426 @@ await (Promise.reject() || 3);
     },
     {
       code: `
-void Promise.resolve().then(() => {}, undefined);
+        (async () => {
+          something();
+        })();
       `,
       errors: [
         {
           line: 2,
-          messageId: 'floatingUselessRejectionHandler',
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        void (async () => {
+          something();
+        })();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.resolve().then(() => {}, undefined);
+        await (async () => {
+          something();
+        })();
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: '(async function foo() {})();',
+      errors: [
+        {
+          line: 1,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: 'void (async function foo() {})();',
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: 'await (async function foo() {})();',
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-declare const maybeCallable: string | (() => void);
-Promise.resolve().then(() => {}, maybeCallable);
+        function foo() {
+          (async function bar() {})();
+        }
       `,
       errors: [
         {
           line: 3,
-          messageId: 'floatingUselessRejectionHandler',
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        function foo() {
+          void (async function bar() {})();
+        }
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-await Promise.resolve().then(() => {}, maybeCallable);
+        function foo() {
+          await (async function bar() {})();
+        }
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        const foo = () =>
+          new Promise(res => {
+            (async function () {
+              await res(1);
+            })();
+          });
       `,
       errors: [
         {
           line: 4,
-          messageId: 'floatingUselessRejectionHandler',
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        const foo = () =>
+          new Promise(res => {
+            void (async function () {
+              await res(1);
+            })();
+          });
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-await Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        const foo = () =>
+          new Promise(res => {
+            await (async function () {
+              await res(1);
+            })();
+          });
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+        (async function () {
+          await res(1);
+        })();
+      `,
+      errors: [
         {
-          line: 5,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 2,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-await Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        void (async function () {
+          await res(1);
+        })();
       `,
             },
-          ],
-        },
-        {
-          line: 6,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-await Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        await (async function () {
+          await res(1);
+        })();
       `,
             },
           ],
         },
+      ],
+    },
+    {
+      code: `
+        (async function () {
+          Promise.resolve();
+        })();
+      `,
+      errors: [
         {
-          line: 7,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 3,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-await Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        (async function () {
+          void Promise.resolve();
+        })();
       `,
             },
-          ],
-        },
-        {
-          line: 10,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-await Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+        (async function () {
+          await Promise.resolve();
+        })();
       `,
             },
           ],
         },
+      ],
+      options: [{ ignoreIIFE: true }],
+    },
+    {
+      code: `
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
+      `,
+      errors: [
         {
-          line: 11,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 4,
+          messageId: 'floatingVoid',
           suggestions: [
             {
-              messageId: 'floatingFixAwait',
+              messageId: 'floatingFixVoid',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-await Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  void promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
-          ],
-        },
-        {
-          line: 12,
-          messageId: 'floatingUselessRejectionHandler',
-          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-await Promise.resolve().catch(3);
-Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  await promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
         {
-          line: 13,
-          messageId: 'floatingUselessRejectionHandler',
+          line: 5,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  void promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const maybeCallable: string | (() => void);
-declare const definitelyCallable: () => void;
-Promise.resolve().then(() => {}, undefined);
-Promise.resolve().then(() => {}, null);
-Promise.resolve().then(() => {}, 3);
-Promise.resolve().then(() => {}, maybeCallable);
-Promise.resolve().then(() => {}, definitelyCallable);
-
-Promise.resolve().catch(undefined);
-Promise.resolve().catch(null);
-Promise.resolve().catch(3);
-await Promise.resolve().catch(maybeCallable);
-Promise.resolve().catch(definitelyCallable);
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  await promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-Promise.reject() || 3;
-      `,
-      errors: [
         {
-          line: 2,
-          messageId: 'floating',
+          line: 6,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  void promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.reject() || 3);
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  await promiseIntersection.catch();
+  promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
-      ],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-Promise.reject().finally(() => {});
-      `,
-      errors: [
         {
-          line: 2,
+          line: 7,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject().finally(() => {});
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  void promiseIntersection.finally();
+})();
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject().finally(() => {});
+declare const promiseIntersection: Promise<number> & number;
+(async function () {
+  promiseIntersection;
+  promiseIntersection.then(() => {});
+  promiseIntersection.catch();
+  await promiseIntersection.finally();
+})();
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreIIFE: true }],
     },
     {
       code: `
-Promise.reject()
-  .finally(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  void condition || myPromise();
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floating',
+          line: 6,
+          messageId: 'floatingVoid',
           suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  void (void condition || myPromise());
+}
+      `,
+            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .finally(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  await (void condition || myPromise());
+}
       `,
             },
           ],
         },
       ],
-      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  (await condition) && myPromise();
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 6,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  await ((await condition) && myPromise());
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  condition && myPromise();
+}
       `,
       errors: [
         {
-          line: 2,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  void (condition && myPromise());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject()
-  .then(() => {})
-  .finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = true;
+
+  await (condition && myPromise());
+}
       `,
             },
           ],
@@ -3607,26 +3469,38 @@ await Promise.reject()
     },
     {
       code: `
-declare const returnsPromise: () => Promise<void> | null;
-returnsPromise()?.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  condition || myPromise();
+}
       `,
       errors: [
         {
-          line: 3,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const returnsPromise: () => Promise<void> | null;
-void returnsPromise()?.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  void (condition || myPromise());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const returnsPromise: () => Promise<void> | null;
-await returnsPromise()?.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  await (condition || myPromise());
+}
       `,
             },
           ],
@@ -3635,26 +3509,38 @@ await returnsPromise()?.finally(() => {});
     },
     {
       code: `
-const promiseIntersection: Promise<number> & number;
-promiseIntersection.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
+
+  condition ?? myPromise();
+}
       `,
       errors: [
         {
-          line: 3,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const promiseIntersection: Promise<number> & number;
-void promiseIntersection.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
+
+  void (condition ?? myPromise());
+}
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const promiseIntersection: Promise<number> & number;
-await promiseIntersection.finally(() => {});
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = null;
+
+  await (condition ?? myPromise());
+}
       `,
             },
           ],
@@ -3663,109 +3549,121 @@ await promiseIntersection.finally(() => {});
     },
     {
       code: `
-Promise.resolve().finally(() => {}), 123;
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = true;
+  condition && myPromise;
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void (Promise.resolve().finally(() => {}), 123);
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (Promise.resolve().finally(() => {}), 123);
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = true;
+  await (condition && myPromise);
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-(async () => true)().finally();
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = false;
+  condition || myPromise;
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void (async () => true)().finally();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (async () => true)().finally();
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = false;
+  await (condition || myPromise);
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-Promise.reject(new Error('message')).finally(() => {});
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = null;
+  condition ?? myPromise;
+}
       `,
       errors: [
         {
-          line: 2,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-void Promise.reject(new Error('message')).finally(() => {});
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-await Promise.reject(new Error('message')).finally(() => {});
+async function foo() {
+  const myPromise = Promise.resolve(true);
+  let condition = null;
+  await (condition ?? myPromise);
+}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  maybePromiseArray?.[0];
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  condition || condition || myPromise();
 }
       `,
       errors: [
         {
-          line: 5,
+          line: 6,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  void maybePromiseArray?.[0];
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  void (condition || condition || myPromise());
 }
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-function _<T, S extends Array<T | Promise<T>>>(
-  maybePromiseArray: S | undefined,
-): void {
-  await maybePromiseArray?.[0];
+async function foo() {
+  const myPromise = async () => void 0;
+  const condition = false;
+
+  await (condition || condition || myPromise());
 }
       `,
             },
@@ -3775,766 +3673,677 @@ function _<T, S extends Array<T | Promise<T>>>(
     },
     {
       code: `
-[1, 2, 3].map(() => Promise.reject());
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const array: unknown[];
-array.map(() => Promise.reject());
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-void promiseArray;
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArray' }],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function f() {
-  await promiseArray;
-}
-      `,
-      errors: [{ line: 4, messageId: 'floatingPromiseArray' }],
-      options: [{ ignoreVoid: false }],
-    },
-    {
-      code: `
-[1, 2, Promise.reject(), 3];
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-[1, 2, Promise.reject().catch(() => {}), 3];
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-const data = ['test'];
-data.map(async () => {
-  await new Promise((_res, rej) => setTimeout(rej, 1000));
-});
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-function _<T, S extends Array<T | Array<T | Promise<T>>>>(
-  maybePromiseArrayArray: S | undefined,
-): void {
-  maybePromiseArrayArray?.[0];
-}
-      `,
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-function f<T extends Array<Promise<number>>>(a: T): void {
-  a;
-}
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare const a: Array<Promise<number>> | undefined;
-a;
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-function f<T extends Array<Promise<number>>>(a: T | undefined): void {
-  a;
-}
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-[Promise.reject()] as const;
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-declare function cursed(): [Promise<number>, Promise<string>];
-cursed();
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-[
-  'Type Argument number ',
-  1,
-  'is not',
-  Promise.resolve(),
-  'but it still is flagged',
-] as const;
-      `,
-      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-        declare const arrayOrPromiseTuple:
-          | Array<number>
-          | [number, number, Promise<unknown>, string];
-        arrayOrPromiseTuple;
-      `,
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-        declare const okArrayOrPromiseArray: Array<number> | Array<Promise<unknown>>;
-        okArrayOrPromiseArray;
-      `,
-      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
-    },
-    {
-      code: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
-}
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-promise;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
       errors: [
         {
-          line: 15,
-          messageId: 'floatingVoid',
+          line: 4,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
-}
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-void promise;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+void Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-interface UnsafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): UnsafeThenable<TResult1 | TResult2>;
-}
-let promise: UnsafeThenable<number> = Promise.resolve(5);
-await promise;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+await Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
-          checkThenables: true,
-        },
-      ],
-    },
-    {
-      code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-promise.catch();
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-void promise.catch();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+void Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-await promise.catch();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+await Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-promise().finally();
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 6,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-void promise().finally();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+void Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-class UnsafePromise<T> extends Promise<T> {}
-let promise: () => UnsafePromise<number> = async () => 5;
-await promise().finally();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+await Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-0 ? promise.catch() : 2;
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 7,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-void (0 ? promise.catch() : 2);
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+void Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: UnsafePromise = Promise.resolve(5);
-await (0 ? promise.catch() : 2);
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+await Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-null ?? promise().catch();
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 10,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-void (null ?? promise().catch());
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+void Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-type UnsafePromise = Promise<number> & { hey?: string };
-let promise: () => UnsafePromise = async () => 5;
-await (null ?? promise().catch());
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+await Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: Foo<unknown>[];
-arrayOrPromiseTuple;
-      `,
-      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
-    },
-    // an array containing elements of `Promise` type and a branded Promise type will be treated as just an ordinary `Promise`.
-    // see https://github.com/typescript-eslint/typescript-eslint/pull/8502#issuecomment-2105734406
-    {
-      code: `
-type SafePromise = Promise<number> & { hey?: string };
-let foo: SafePromise = Promise.resolve(1);
-let bar = [Promise.resolve(2), foo];
-bar;
-      `,
-      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
-      ],
-    },
-    {
-      code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
-arrayOrPromiseTuple;
-      `,
-      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
-    },
-    {
-      code: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-myTag\`abc\`;
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 11,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-void myTag\`abc\`;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+void Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-await myTag\`abc\`;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+await Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
-
-        unsafe('...', () => {});
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
-
+          line: 12,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-        void unsafe('...', () => {});
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+void Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        declare function unsafe(...args: unknown[]): Promise<void>;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-        await unsafe('...', () => {});
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+await Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {}).then(() => {});
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 13,
+          messageId: 'floatingUselessRejectionHandlerVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        declare function it(...args: unknown[]): Promise<void>;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-        void it('...', () => {}).then(() => {});
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+void Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        declare function it(...args: unknown[]): Promise<void>;
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
 
-        await it('...', () => {}).then(() => {});
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+await Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {}).finally(() => {});
+Promise.reject() || 3;
       `,
       errors: [
         {
-          line: 4,
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        void it('...', () => {}).finally(() => {});
+void (Promise.reject() || 3);
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        await it('...', () => {}).finally(() => {});
+await (Promise.reject() || 3);
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          allowForKnownSafeCalls: [
-            {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
-            },
-          ],
-        },
-      ],
     },
     {
       code: `
-declare const createPromise: () => PromiseLike<number>;
-createPromise();
+void Promise.resolve().then(() => {}, undefined);
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 2,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const createPromise: () => PromiseLike<number>;
-void createPromise();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const createPromise: () => PromiseLike<number>;
-await createPromise();
+await Promise.resolve().then(() => {}, undefined);
       `,
             },
           ],
         },
       ],
-      options: [{ checkThenables: true }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-createMyThenable();
+declare const maybeCallable: string | (() => void);
+Promise.resolve().then(() => {}, maybeCallable);
       `,
       errors: [
         {
-          line: 8,
-          messageId: 'floatingVoid',
+          line: 3,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-void createMyThenable();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-await createMyThenable();
+declare const maybeCallable: string | (() => void);
+await Promise.resolve().then(() => {}, maybeCallable);
       `,
             },
           ],
         },
       ],
-      options: [{ checkThenables: true }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const createPromise: () => Promise<number>;
-createPromise();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
       errors: [
         {
-          line: 3,
-          messageId: 'floatingVoid',
+          line: 4,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const createPromise: () => Promise<number>;
-void createPromise();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const createPromise: () => Promise<number>;
-await createPromise();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+await Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-createMyPromise();
-      `,
-      errors: [
         {
-          line: 4,
-          messageId: 'floatingVoid',
+          line: 5,
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-void createMyPromise();
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-class MyPromise<T> extends Promise<T> {}
-declare const createMyPromise: () => MyPromise<number>;
-await createMyPromise();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+await Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
-      ],
-    },
-    {
-      code: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-createMyPromise();
-      `,
-      errors: [
         {
           line: 6,
-          messageId: 'floatingVoid',
+          messageId: 'floatingUselessRejectionHandler',
           suggestions: [
             {
-              messageId: 'floatingFixVoid',
+              messageId: 'floatingFixAwait',
               output: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-void createMyPromise();
-      `,
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+await Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
             },
+          ],
+        },
+        {
+          line: 7,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
             {
               messageId: 'floatingFixAwait',
               output: `
-class MyPromise<T> extends Promise<T> {
-  additional: string;
-}
-declare const createMyPromise: () => MyPromise<number>;
-await createMyPromise();
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+await Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
+            },
+          ],
+        },
+        {
+          line: 10,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+await Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
+            },
+          ],
+        },
+        {
+          line: 11,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+await Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
+            },
+          ],
+        },
+        {
+          line: 12,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+await Promise.resolve().catch(3);
+Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
+      `,
+            },
+          ],
+        },
+        {
+          line: 13,
+          messageId: 'floatingUselessRejectionHandler',
+          suggestions: [
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const maybeCallable: string | (() => void);
+declare const definitelyCallable: () => void;
+Promise.resolve().then(() => {}, undefined);
+Promise.resolve().then(() => {}, null);
+Promise.resolve().then(() => {}, 3);
+Promise.resolve().then(() => {}, maybeCallable);
+Promise.resolve().then(() => {}, definitelyCallable);
+
+Promise.resolve().catch(undefined);
+Promise.resolve().catch(null);
+Promise.resolve().catch(3);
+await Promise.resolve().catch(maybeCallable);
+Promise.resolve().catch(definitelyCallable);
       `,
             },
           ],
         },
       ],
-      options: [{ checkThenables: true }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  yield x;
-}
+Promise.reject() || 3;
       `,
       errors: [
         {
-          messageId: 'floatingVoid',
+          line: 2,
+          messageId: 'floating',
           suggestions: [
-            {
-              messageId: 'floatingFixVoid',
-              output: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  void (yield x);
-}
-      `,
-            },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const x: any;
-function* generator(): Generator<number, void, Promise<number>> {
-  await (yield x);
-}
+await (Promise.reject() || 3);
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  yield* x;
-}
+Promise.reject().finally(() => {});
       `,
       errors: [
         {
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  void (yield* x);
-}
+void Promise.reject().finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-declare const x: Generator<number, Promise<number>, void>;
-function* generator(): Generator<number, void, void> {
-  await (yield* x);
-}
+await Promise.reject().finally(() => {});
       `,
             },
           ],
@@ -4543,26 +4352,56 @@ function* generator(): Generator<number, void, void> {
     },
     {
       code: `
-const value = {};
-value as Promise<number>;
+Promise.reject()
+  .finally(() => {})
+  .finally(() => {});
       `,
       errors: [
         {
-          line: 3,
+          line: 2,
+          messageId: 'floating',
+          suggestions: [
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await Promise.reject()
+  .finally(() => {})
+  .finally(() => {});
+      `,
+            },
+          ],
+        },
+      ],
+      options: [{ ignoreVoid: false }],
+    },
+    {
+      code: `
+Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
+      `,
+      errors: [
+        {
+          line: 2,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-const value = {};
-void (value as Promise<number>);
+void Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-const value = {};
-await (value as Promise<number>);
+await Promise.reject()
+  .finally(() => {})
+  .finally(() => {})
+  .finally(() => {});
       `,
             },
           ],
@@ -4571,7 +4410,9 @@ await (value as Promise<number>);
     },
     {
       code: `
-({}) as Promise<number> & number;
+Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
       errors: [
         {
@@ -4581,13 +4422,17 @@ await (value as Promise<number>);
             {
               messageId: 'floatingFixVoid',
               output: `
-void (({}) as Promise<number> & number);
+void Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (({}) as Promise<number> & number);
+await Promise.reject()
+  .then(() => {})
+  .finally(() => {});
       `,
             },
           ],
@@ -4596,23 +4441,26 @@ await (({}) as Promise<number> & number);
     },
     {
       code: `
-({}) as Promise<number> & { yolo?: string };
+declare const returnsPromise: () => Promise<void> | null;
+returnsPromise()?.finally(() => {});
       `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void (({}) as Promise<number> & { yolo?: string });
+declare const returnsPromise: () => Promise<void> | null;
+void returnsPromise()?.finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (({}) as Promise<number> & { yolo?: string });
+declare const returnsPromise: () => Promise<void> | null;
+await returnsPromise()?.finally(() => {});
       `,
             },
           ],
@@ -4621,863 +4469,1014 @@ await (({}) as Promise<number> & { yolo?: string });
     },
     {
       code: `
-<Promise<number>>{};
+const promiseIntersection: Promise<number> & number;
+promiseIntersection.finally(() => {});
       `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'floatingVoid',
           suggestions: [
             {
               messageId: 'floatingFixVoid',
               output: `
-void (<Promise<number>>{});
+const promiseIntersection: Promise<number> & number;
+void promiseIntersection.finally(() => {});
       `,
             },
             {
               messageId: 'floatingFixAwait',
               output: `
-await (<Promise<number>>{});
+const promiseIntersection: Promise<number> & number;
+await promiseIntersection.finally(() => {});
       `,
             },
           ],
         },
       ],
     },
-  ],
-
-  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(() => {});
-  return Promise.resolve('value');
-}
-    `,
     {
       code: `
-async function test() {
-  void Promise.resolve('value');
-}
+Promise.resolve().finally(() => {}), 123;
       `,
-      options: [{ ignoreVoid: true }],
-    },
-    `
-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(() => {});
-  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)().catch(() => {});
-  return (async () => true)();
-}
-    `,
-    `
-async function test() {
-  async function returnsPromise() {}
-  await returnsPromise();
-  returnsPromise().then(
-    () => {},
-    () => {},
-  );
-  returnsPromise()
-    .then(() => {})
-    .catch(() => {});
-  returnsPromise()
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  returnsPromise().catch(() => {});
-  return returnsPromise();
-}
-    `,
-    `
-async function test() {
-  const x = Promise.resolve();
-  const y = x.then(() => {});
-  y.catch(() => {});
-}
-    `,
-    `
-async function test() {
-  Math.random() > 0.5 ? Promise.resolve().catch(() => {}) : null;
-}
-    `,
-    `
-async function test() {
-  Promise.resolve().catch(() => {}), 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(
-      () => {},
-      () => {},
-    );
-}
-    `,
-    `
-declare const promiseValue: Promise<number>;
-async function test() {
-  await promiseValue;
-  promiseValue.then(
-    () => {},
-    () => {},
-  );
-  promiseValue.then(() => {}).catch(() => {});
-  promiseValue
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promiseValue.catch(() => {});
-  return promiseValue;
-}
-    `,
-    `
-declare const promiseUnion: Promise<number> | number;
-async function test() {
-  await promiseUnion;
-  promiseUnion.then(
-    () => {},
-    () => {},
-  );
-  promiseUnion.then(() => {}).catch(() => {});
-  promiseUnion
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promiseUnion.catch(() => {});
-  promiseValue.finally(() => {});
-  return promiseUnion;
-}
-    `,
-    `
-declare const promiseIntersection: Promise<number> & number;
-async function test() {
-  await promiseIntersection;
-  promiseIntersection.then(
-    () => {},
-    () => {},
-  );
-  promiseIntersection.then(() => {}).catch(() => {});
-  promiseIntersection.catch(() => {});
-  return promiseIntersection;
-}
-    `,
-    `
-async function test() {
-  class CanThen extends Promise<number> {}
-  const canThen: CanThen = Foo.resolve(2);
-
-  await canThen;
-  canThen.then(
-    () => {},
-    () => {},
-  );
-  canThen.then(() => {}).catch(() => {});
-  canThen
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  canThen.catch(() => {});
-  return canThen;
-}
-    `,
-    `
-declare const intersectionPromise: Promise<number> & number;
-async function test() {
-  await (Math.random() > 0.5 ? numberPromise : 0);
-  await (Math.random() > 0.5 ? foo : 0);
-  await (Math.random() > 0.5 ? bar : 0);
-
-  await intersectionPromise;
-}
-    `,
-    `
-async function test() {
-  class Thenable {
-    then(callback: () => void): Thenable {
-      return new Thenable();
-    }
-  }
-  const thenable = new Thenable();
-
-  await thenable;
-  thenable;
-  thenable.then(() => {});
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class NonFunctionParamThenable {
-    then(param: string, param2: number): NonFunctionParamThenable {
-      return new NonFunctionParamThenable();
-    }
-  }
-  const thenable = new NonFunctionParamThenable();
-
-  await thenable;
-  thenable;
-  thenable.then('abc', 'def');
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class NonFunctionThenable {
-    then: number;
-  }
-  const thenable = new NonFunctionThenable();
-
-  thenable;
-  thenable.then;
-  return thenable;
-}
-    `,
-    `
-async function test() {
-  class CatchableThenable {
-    then(callback: () => void, callback: () => void): CatchableThenable {
-      return new CatchableThenable();
-    }
-  }
-  const thenable = new CatchableThenable();
-
-  await thenable;
-  return thenable;
-}
-    `,
-    `
-// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
-// Type definitions for promise-polyfill 6.0
-// Project: https://github.com/taylorhakes/promise-polyfill
-// Definitions by: Steve Jenkins <https://github.com/skysteve>
-//                 Daniel Cassidy <https://github.com/djcsdy>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-interface PromisePolyfillConstructor extends PromiseConstructor {
-  _immediateFn?: (handler: (() => void) | string) => void;
-}
-
-declare const PromisePolyfill: PromisePolyfillConstructor;
-
-async function test() {
-  const promise = new PromisePolyfill(() => {});
-
-  await promise;
-  promise.then(
-    () => {},
-    () => {},
-  );
-  promise.then(() => {}).catch(() => {});
-  promise
-    .then(() => {})
-    .catch(() => {})
-    .finally(() => {});
-  promise.catch(() => {});
-  return promise;
-}
-    `,
-
-    // optional chaining
-    `
-declare const returnsPromise: () => Promise<void> | null;
-async function test() {
-  await returnsPromise?.();
-  returnsPromise()?.then(
-    () => {},
-    () => {},
-  );
-  returnsPromise()
-    ?.then(() => {})
-    ?.catch(() => {});
-  returnsPromise()?.catch(() => {});
-  return returnsPromise();
-}
-    `,
-    `
-const doSomething = async (
-  obj1: { a?: { b?: { c?: () => Promise<void> } } },
-  obj2: { a?: { b?: { c: () => Promise<void> } } },
-  obj3: { a?: { b: { c?: () => Promise<void> } } },
-  obj4: { a: { b: { c?: () => Promise<void> } } },
-  obj5: { a?: () => { b?: { c?: () => Promise<void> } } },
-  obj6?: { a: { b: { c?: () => Promise<void> } } },
-  callback?: () => Promise<void>,
-): Promise<void> => {
-  await obj1.a?.b?.c?.();
-  await obj2.a?.b?.c();
-  await obj3.a?.b.c?.();
-  await obj4.a.b.c?.();
-  await obj5.a?.().b?.c?.();
-  await obj6?.a.b.c?.();
-
-  return callback?.();
-};
-
-void doSomething();
-    `,
-    // ignoreIIFE
+      errors: [
+        {
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void (Promise.resolve().finally(() => {}), 123);
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await (Promise.resolve().finally(() => {}), 123);
+      `,
+            },
+          ],
+        },
+      ],
+    },
     {
       code: `
-        (async () => {
-          await something();
-        })();
+(async () => true)().finally();
       `,
-      options: [{ ignoreIIFE: true }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void (async () => true)().finally();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await (async () => true)().finally();
+      `,
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-        (async () => {
-          something();
-        })();
+Promise.reject(new Error('message')).finally(() => {});
       `,
-      options: [{ ignoreIIFE: true }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void Promise.reject(new Error('message')).finally(() => {});
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await Promise.reject(new Error('message')).finally(() => {});
+      `,
+            },
+          ],
+        },
+      ],
     },
     {
-      code: '(async function foo() {})();',
-      options: [{ ignoreIIFE: true }],
+      code: `
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  maybePromiseArray?.[0];
+}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  void maybePromiseArray?.[0];
+}
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+function _<T, S extends Array<T | Promise<T>>>(
+  maybePromiseArray: S | undefined,
+): void {
+  await maybePromiseArray?.[0];
+}
+      `,
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-        function foo() {
-          (async function bar() {})();
-        }
+[1, 2, 3].map(() => Promise.reject());
       `,
-      options: [{ ignoreIIFE: true }],
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-        const foo = () =>
-          new Promise(res => {
-            (async function () {
-              await res(1);
-            })();
-          });
+declare const array: unknown[];
+array.map(() => Promise.reject());
       `,
-      options: [{ ignoreIIFE: true }],
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-        (async function () {
-          await res(1);
-        })();
+declare const promiseArray: Array<Promise<unknown>>;
+void promiseArray;
       `,
-      options: [{ ignoreIIFE: true }],
+      errors: [{ line: 3, messageId: 'floatingPromiseArray' }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  void (condition && myPromise());
+declare const promiseArray: Array<Promise<unknown>>;
+async function f() {
+  await promiseArray;
 }
       `,
+      errors: [{ line: 4, messageId: 'floatingPromiseArray' }],
+      options: [{ ignoreVoid: false }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  await (condition && myPromise());
-}
+[1, 2, Promise.reject(), 3];
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  condition && void myPromise();
-}
+[1, 2, Promise.reject().catch(() => {}), 3];
       `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  const condition = true;
-  condition && (await myPromise());
+const data = ['test'];
+data.map(async () => {
+  await new Promise((_res, rej) => setTimeout(rej, 1000));
+});
+      `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
+    },
+    {
+      code: `
+function _<T, S extends Array<T | Array<T | Promise<T>>>>(
+  maybePromiseArrayArray: S | undefined,
+): void {
+  maybePromiseArrayArray?.[0];
 }
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-async function foo() {
-  const myPromise = async () => void 0;
-  let condition = false;
-  condition && myPromise();
-  condition = true;
-  condition || myPromise();
-  condition ?? myPromise();
+function f<T extends Array<Promise<number>>>(a: T): void {
+  a;
 }
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-declare const definitelyCallable: () => void;
-Promise.reject().catch(definitelyCallable);
+declare const a: Array<Promise<number>> | undefined;
+a;
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {});
+function f<T extends Array<Promise<number>>>(a: T | undefined): void {
+  a;
+}
       `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {})
-  .finally(() => {});
+[Promise.reject()] as const;
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-Promise.reject()
-  .catch(() => {})
-  .finally(() => {})
-  .finally(() => {})
-  .finally(() => {});
+declare function cursed(): [Promise<number>, Promise<string>];
+cursed();
       `,
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-await Promise.all([Promise.resolve(), Promise.resolve()]);
+[
+  'Type Argument number ',
+  1,
+  'is not',
+  Promise.resolve(),
+  'but it still is flagged',
+] as const;
       `,
+      errors: [{ line: 2, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-declare const promiseArray: Array<Promise<unknown>>;
-void promiseArray;
+        declare const arrayOrPromiseTuple:
+          | Array<number>
+          | [number, number, Promise<unknown>, string];
+        arrayOrPromiseTuple;
       `,
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
-      // Expressions aren't checked by this rule, so this just becomes an array
-      // of number | undefined, which is fine regardless of the ignoreVoid setting.
       code: `
-[1, 2, void Promise.reject(), 3];
+        declare const okArrayOrPromiseArray: Array<number> | Array<Promise<unknown>>;
+        okArrayOrPromiseArray;
       `,
-      options: [{ ignoreVoid: false }],
+      errors: [{ line: 3, messageId: 'floatingPromiseArrayVoid' }],
     },
     {
       code: `
-['I', 'am', 'just', 'an', 'array'];
+interface UnsafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): UnsafeThenable<TResult1 | TResult2>;
+}
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+promise;
+      `,
+      errors: [
+        {
+          line: 15,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+interface UnsafeThenable<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
+      | undefined
+      | null,
+  ): UnsafeThenable<TResult1 | TResult2>;
+}
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+void promise;
       `,
-    },
-    {
-      code: `
-interface SafeThenable<T> {
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+interface UnsafeThenable<T> {
   then<TResult1 = T, TResult2 = never>(
     onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
+      | ((value: T) => TResult1 | UnsafeThenable<TResult1>)
       | undefined
       | null,
     onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
+      | ((reason: any) => TResult2 | UnsafeThenable<TResult2>)
       | undefined
       | null,
-  ): SafeThenable<TResult1 | TResult2>;
+  ): UnsafeThenable<TResult1 | TResult2>;
 }
-let promise: SafeThenable<number> = Promise.resolve(5);
-0, promise;
+let promise: UnsafeThenable<number> = Promise.resolve(5);
+await promise;
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          checkThenables: true,
         },
       ],
     },
     {
       code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: SafeThenable<number> = Promise.resolve(5);
-0 ? promise : 3;
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+promise.catch();
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+void promise.catch();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+class SafePromise<T> extends Promise<T> {}
+let promise: SafePromise<number> = Promise.resolve(5);
+await promise.catch();
       `,
+            },
+          ],
+        },
+      ],
       options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+promise().finally();
+      `,
+      errors: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+void promise().finally();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+class UnsafePromise<T> extends Promise<T> {}
+let promise: () => UnsafePromise<number> = async () => 5;
+await promise().finally();
+      `,
+            },
+          ],
         },
       ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
     },
     {
       code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: { a: SafePromise<number> } = { a: Promise.resolve(5) };
-promise.a;
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+0 ? promise.catch() : 2;
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+void (0 ? promise.catch() : 2);
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: UnsafePromise = Promise.resolve(5);
+await (0 ? promise.catch() : 2);
+      `,
+            },
+          ],
+        },
+      ],
+      options: [
+        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      ],
+    },
+    {
+      code: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+null ?? promise().catch();
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+void (null ?? promise().catch());
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+type UnsafePromise = Promise<number> & { hey?: string };
+let promise: () => UnsafePromise = async () => 5;
+await (null ?? promise().catch());
       `,
+            },
+          ],
+        },
+      ],
       options: [
         { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
     },
     {
       code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: SafePromise<number> = Promise.resolve(5);
-promise;
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: Foo<unknown>[];
+arrayOrPromiseTuple;
+      `,
+      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
+    },
+    // an array containing elements of `Promise` type and a branded Promise type will be treated as just an ordinary `Promise`.
+    // see https://github.com/typescript-eslint/typescript-eslint/pull/8502#issuecomment-2105734406
+    {
+      code: `
+type SafePromise = Promise<number> & { hey?: string };
+let foo: SafePromise = Promise.resolve(1);
+let bar = [Promise.resolve(2), foo];
+bar;
       `,
+      errors: [{ line: 5, messageId: 'floatingPromiseArrayVoid' }],
       options: [
         { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
       ],
     },
     {
       code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: Foo = Promise.resolve(5);
-0 || promise;
+type Foo<T> = Promise<T> & { hey?: string };
+declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
+arrayOrPromiseTuple;
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+      errors: [{ line: 4, messageId: 'floatingPromiseArrayVoid' }],
+      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Bar' }] }],
     },
     {
       code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: Foo = Promise.resolve(5);
-promise.finally();
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+myTag\`abc\`;
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+void myTag\`abc\`;
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+type SafePromise = Promise<number> & { __linterBrands?: string };
+declare const myTag: (strings: TemplateStringsArray) => SafePromise;
+await myTag\`abc\`;
       `,
+            },
+          ],
+        },
+      ],
       options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
     },
     {
       code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-0, promise();
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        unsafe('...', () => {});
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        void unsafe('...', () => {});
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+        declare function unsafe(...args: unknown[]): Promise<void>;
+
+        await unsafe('...', () => {});
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          allowForKnownSafeCalls: [
+            {
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
+            },
+          ],
         },
       ],
     },
     {
       code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-0 ? promise() : 3;
+        declare function it(...args: unknown[]): Promise<void>;
+
+        it('...', () => {}).then(() => {});
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        void it('...', () => {}).then(() => {});
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        await it('...', () => {}).then(() => {});
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          allowForKnownSafeCalls: [
+            {
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
+            },
+          ],
         },
       ],
     },
     {
       code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: () => Foo = () => Promise.resolve(5);
-promise();
+        declare function it(...args: unknown[]): Promise<void>;
+
+        it('...', () => {}).finally(() => {});
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type Foo = Promise<number> & { hey?: string };
-let promise: () => Foo = async () => 5;
-promise().finally();
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        void it('...', () => {}).finally(() => {});
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: () => SafePromise<number> = async () => 5;
-0 || promise();
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+        declare function it(...args: unknown[]): Promise<void>;
+
+        await it('...', () => {}).finally(() => {});
       `,
+            },
+          ],
+        },
+      ],
       options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+        {
+          allowForKnownSafeCalls: [
+            {
+              from: 'file',
+              name: 'it',
+              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
+              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
+                ? 'file.ts'
+                : 'tests/fixtures/file.ts',
+            },
+          ],
+        },
       ],
     },
     {
       code: `
-class SafePromise<T> extends Promise<T> {}
-let promise: () => SafePromise<number> = async () => 5;
-null ?? promise();
+declare const createPromise: () => PromiseLike<number>;
+createPromise();
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const createPromise: () => PromiseLike<number>;
+void createPromise();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const createPromise: () => PromiseLike<number>;
+await createPromise();
+      `,
+            },
+          ],
+        },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-let promise: () => PromiseLike<number> = () => Promise.resolve(5);
-promise();
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+createMyThenable();
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'lib', name: 'PromiseLike' }] },
+      errors: [
+        {
+          line: 8,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+void createMyThenable();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+interface MyThenable {
+  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
+}
+
+declare function createMyThenable(): MyThenable;
+
+await createMyThenable();
+      `,
+            },
+          ],
+        },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: Foo<unknown>[];
-arrayOrPromiseTuple;
+declare const createPromise: () => Promise<number>;
+createPromise();
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
-    },
-    {
-      code: `
-type Foo<T> = Promise<T> & { hey?: string };
-declare const arrayOrPromiseTuple: [Foo<unknown>, 5];
-arrayOrPromiseTuple;
+      errors: [
+        {
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const createPromise: () => Promise<number>;
+void createPromise();
       `,
-      options: [{ allowForKnownSafePromises: [{ from: 'file', name: 'Foo' }] }],
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const createPromise: () => Promise<number>;
+await createPromise();
+      `,
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-type SafePromise = Promise<number> & { __linterBrands?: string };
-declare const myTag: (strings: TemplateStringsArray) => SafePromise;
-myTag\`abc\`;
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+createMyPromise();
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+void createMyPromise();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+class MyPromise<T> extends Promise<T> {}
+declare const createMyPromise: () => MyPromise<number>;
+await createMyPromise();
       `,
-      options: [
-        { allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }] },
+            },
+          ],
+        },
       ],
     },
     {
       code: `
-        declare function it(...args: unknown[]): Promise<void>;
-
-        it('...', () => {});
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+createMyPromise();
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafeCalls: [
+          line: 6,
+          messageId: 'floatingVoid',
+          suggestions: [
             {
-              from: 'file',
-              name: 'it',
-              // https://github.com/typescript-eslint/typescript-eslint/pull/9234/files#r1626465054
-              path: process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE
-                ? 'file.ts'
-                : 'tests/fixtures/file.ts',
+              messageId: 'floatingFixVoid',
+              output: `
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+void createMyPromise();
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+class MyPromise<T> extends Promise<T> {
+  additional: string;
+}
+declare const createMyPromise: () => MyPromise<number>;
+await createMyPromise();
+      `,
             },
           ],
         },
       ],
+      options: [{ checkThenables: true }],
     },
     {
       code: `
-declare const myTag: (strings: TemplateStringsArray) => Promise<void>;
-myTag\`abc\`.catch(() => {});
-      `,
-    },
-    {
-      code: `
-declare const myTag: (strings: TemplateStringsArray) => string;
-myTag\`abc\`;
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  yield x;
+}
       `,
-    },
-    {
-      code: `
-declare let x: any;
-declare const promiseArray: Array<Promise<unknown>>;
-x = promiseArray;
+      errors: [
+        {
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  void (yield x);
+}
       `,
-    },
-    {
-      code: `
-declare let x: Promise<number>;
-x = Promise.resolve(2);
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const x: any;
+function* generator(): Generator<number, void, Promise<number>> {
+  await (yield x);
+}
       `,
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function f() {
-  return promiseArray;
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  yield* x;
 }
       `,
-    },
-    {
-      code: `
-declare const promiseArray: Array<Promise<unknown>>;
-async function* generator() {
-  yield* promiseArray;
+      errors: [
+        {
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  void (yield* x);
 }
       `,
-    },
-    {
-      code: `
-async function* generator() {
-  yield Promise.resolve();
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+declare const x: Generator<number, Promise<number>, void>;
+function* generator(): Generator<number, void, void> {
+  await (yield* x);
 }
       `,
+            },
+          ],
+        },
+      ],
     },
     {
       code: `
-interface SafeThenable<T> {
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | SafeThenable<TResult1>)
-      | undefined
-      | null,
-    onrejected?:
-      | ((reason: any) => TResult2 | SafeThenable<TResult2>)
-      | undefined
-      | null,
-  ): SafeThenable<TResult1 | TResult2>;
-}
-let promise: () => SafeThenable<number> = () => Promise.resolve(5);
-promise().then(() => {});
+const value = {};
+value as Promise<number>;
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafeThenable' }],
+          line: 3,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+const value = {};
+void (value as Promise<number>);
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+const value = {};
+await (value as Promise<number>);
+      `,
+            },
+          ],
         },
       ],
     },
-
     {
       code: `
-        declare module 'abc' {
-          export function it(name: string, action: () => void): void;
-        }
-        it('...', () => {});
+({}) as Promise<number> & number;
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafeCalls: [
-            { from: 'package', name: 'it', package: 'abc' },
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void (({}) as Promise<number> & number);
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await (({}) as Promise<number> & number);
+      `,
+            },
           ],
         },
       ],
     },
     {
       code: `
-        declare module 'abc' {
-          export function it(name: string, action: () => void): void;
-        }
-
-        it('...', () => {});
+({}) as Promise<number> & { yolo?: string };
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafeCalls: [
-            { from: 'package', name: 'it', package: 'abc' },
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void (({}) as Promise<number> & { yolo?: string });
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await (({}) as Promise<number> & { yolo?: string });
+      `,
+            },
           ],
         },
       ],
     },
     {
       code: `
-interface SafePromise<T> extends Promise<T> {
-  brand: 'safe';
-}
-
-declare const createSafePromise: () => SafePromise<string>;
-createSafePromise();
+<Promise<number>>{};
       `,
-      options: [
+      errors: [
         {
-          allowForKnownSafePromises: [{ from: 'file', name: 'SafePromise' }],
-          checkThenables: true,
+          line: 2,
+          messageId: 'floatingVoid',
+          suggestions: [
+            {
+              messageId: 'floatingFixVoid',
+              output: `
+void (<Promise<number>>{});
+      `,
+            },
+            {
+              messageId: 'floatingFixAwait',
+              output: `
+await (<Promise<number>>{});
+      `,
+            },
+          ],
         },
       ],
     },
-    `
-declare const createPromiseLike: () => PromiseLike<number>;
-createPromiseLike();
-    `,
-    `
-interface MyThenable {
-  then(onFulfilled: () => void, onRejected: () => void): MyThenable;
-}
-
-declare function createMyThenable(): MyThenable;
-
-createMyThenable();
-    `,
   ],
 });
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 f968f09977d4..98c6d2c7fe37 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
@@ -14,6 +14,18 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-for-in-array', rule, {
+  valid: [
+    `
+for (const x of [3, 4, 5]) {
+  console.log(x);
+}
+    `,
+    `
+for (const x in { a: 1, b: 2, c: 3 }) {
+  console.log(x);
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -165,17 +177,4 @@ for (const x
       ],
     },
   ],
-
-  valid: [
-    `
-for (const x of [3, 4, 5]) {
-  console.log(x);
-}
-    `,
-    `
-for (const x in { a: 1, b: 2, c: 3 }) {
-  console.log(x);
-}
-    `,
-  ],
 });
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 1933657d7433..648e4ffd1d64 100644
--- a/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
@@ -14,365 +14,354 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-implied-eval', rule, {
-  invalid: [
-    {
-      code: `
-setTimeout('x = 1', 0);
-setInterval('x = 1', 0);
-setImmediate('x = 1');
-execScript('x = 1');
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 2,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 3,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-setTimeout(undefined, 0);
-setInterval(undefined, 0);
-setImmediate(undefined);
-execScript(undefined);
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 2,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 3,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-setTimeout(1 + '' + (() => {}), 0);
-setInterval(1 + '' + (() => {}), 0);
-setImmediate(1 + '' + (() => {}));
-execScript(1 + '' + (() => {}));
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 2,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 3,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo = 'x = 1';
+  valid: [
+    'foo.setImmediate(null);',
+    'foo.setInterval(null);',
+    'foo.execScript(null);',
+    'foo.setTimeout(null);',
+    'foo();',
+    '(function () {})();',
+
+    'setTimeout(() => {}, 0);',
+    'window.setTimeout(() => {}, 0);',
+    "window['setTimeout'](() => {}, 0);",
+
+    'setInterval(() => {}, 0);',
+    'window.setInterval(() => {}, 0);',
+    "window['setInterval'](() => {}, 0);",
+
+    'setImmediate(() => {});',
+    'window.setImmediate(() => {});',
+    "window['setImmediate'](() => {});",
+
+    'execScript(() => {});',
+    'window.execScript(() => {});',
+    "window['execScript'](() => {});",
+
+    `
+const foo = () => {};
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
 setImmediate(foo);
 execScript(foo);
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo = function () {
-  return 'x + 1';
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 8,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 9,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo = function () {
-  return () => 'x + 1';
-};
-
-setTimeout(foo()(), 0);
-setInterval(foo()(), 0);
-setImmediate(foo()());
-execScript(foo()());
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 8,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 9,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const fn = function () {};
+    `,
+    `
+const foo = function () {};
 
-setTimeout(fn + '', 0);
-setInterval(fn + '', 0);
-setImmediate(fn + '');
-execScript(fn + '');
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo: string = 'x + 1';
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+    `,
+    `
+function foo() {}
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
 setImmediate(foo);
 execScript(foo);
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo = new String('x + 1');
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: function () {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: function foo() {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn() {},
+};
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+const fn = 'fn';
+
+setTimeout(foo[fn], 0);
+setInterval(foo[fn], 0);
+setImmediate(foo[fn]);
+execScript(foo[fn]);
+    `,
+    `
+const foo = {
+  fn: () => {},
+};
+
+setTimeout(foo['fn'], 0);
+setInterval(foo['fn'], 0);
+setImmediate(foo['fn']);
+execScript(foo['fn']);
+    `,
+    `
+const foo: () => void = () => {};
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
 setImmediate(foo);
 execScript(foo);
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const foo = 'x + 1';
+    `,
+    `
+const foo: () => () => void = () => {
+  return () => {};
+};
 
-setTimeout(foo as any, 0);
-setInterval(foo as any, 0);
-setImmediate(foo as any);
-execScript(foo as any);
-      `,
-      errors: [
-        {
-          column: 12,
-          line: 4,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 13,
-          line: 5,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 14,
-          line: 6,
-          messageId: 'noImpliedEvalError',
-        },
-        {
-          column: 12,
-          line: 7,
-          messageId: 'noImpliedEvalError',
-        },
-      ],
-    },
-    {
-      code: `
-const fn = (foo: string | any) => {
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo: () => () => void = () => () => {};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = () => () => {};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = function foo() {
+  return function foo() {};
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo = function () {
+  return function () {
+    return '';
+  };
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+const foo: () => () => void = function foo() {
+  return function foo() {};
+};
+
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
+    `,
+    `
+function foo() {
+  return function foo() {
+    return () => {};
+  };
+}
+
+setTimeout(foo()(), 0);
+setInterval(foo()(), 0);
+setImmediate(foo()());
+execScript(foo()());
+    `,
+    `
+class Foo {
+  static fn = () => {};
+}
+
+setTimeout(Foo.fn, 0);
+setInterval(Foo.fn, 0);
+setImmediate(Foo.fn);
+execScript(Foo.fn);
+    `,
+    `
+class Foo {
+  fn() {}
+}
+
+const foo = new Foo();
+
+setTimeout(foo.fn, 0);
+setInterval(foo.fn, 0);
+setImmediate(foo.fn);
+execScript(foo.fn);
+    `,
+    `
+class Foo {
+  fn() {}
+}
+const foo = new Foo();
+const fn = foo.fn;
+
+setTimeout(fn.bind(null), 0);
+setInterval(fn.bind(null), 0);
+setImmediate(fn.bind(null));
+execScript(fn.bind(null));
+    `,
+    `
+const fn = (foo: () => void) => {
   setTimeout(foo, 0);
   setInterval(foo, 0);
   setImmediate(foo);
   execScript(foo);
 };
-      `,
+    `,
+    `
+import { Function } from './class';
+new Function('foo');
+    `,
+    `
+const foo = (callback: Function) => {
+  setTimeout(callback, 0);
+};
+    `,
+    `
+const foo = () => {};
+const bar = () => {};
+
+setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
+setTimeout(foo || bar, 500);
+    `,
+    `
+class Foo {
+  func1() {}
+  func2(): void {
+    setTimeout(this.func1.bind(this), 1);
+  }
+}
+    `,
+    `
+class Foo {
+  private a = {
+    b: {
+      c: function () {},
+    },
+  };
+  funcw(): void {
+    setTimeout(this.a.b.c.bind(this), 1);
+  }
+}
+    `,
+    `
+function setTimeout(input: string, value: number) {}
+
+setTimeout('', 0);
+    `,
+    `
+declare module 'my-timers-promises' {
+  export function setTimeout(ms: number): void;
+}
+
+import { setTimeout } from 'my-timers-promises';
+
+setTimeout(1000);
+    `,
+    `
+function setTimeout() {}
+
+{
+  setTimeout(100);
+}
+    `,
+    `
+function setTimeout() {}
+
+{
+  setTimeout("alert('evil!')");
+}
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+setTimeout('x = 1', 0);
+setInterval('x = 1', 0);
+setImmediate('x = 1');
+execScript('x = 1');
+      `,
       errors: [
         {
-          column: 14,
-          line: 3,
+          column: 12,
+          line: 2,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 15,
-          line: 4,
+          column: 13,
+          line: 3,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 16,
-          line: 5,
+          column: 14,
+          line: 4,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 14,
-          line: 6,
+          column: 12,
+          line: 5,
           messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-const foo = 'foo';
-const bar = () => {};
-
-setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
+setTimeout(undefined, 0);
+setInterval(undefined, 0);
+setImmediate(undefined);
+execScript(undefined);
       `,
       errors: [
+        {
+          column: 12,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
         {
           column: 12,
           line: 5,
@@ -382,544 +371,554 @@ setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
     },
     {
       code: `
-window.setTimeout(\`\`, 0);
-window['setTimeout'](\`\`, 0);
-
-window.setInterval(\`\`, 0);
-window['setInterval'](\`\`, 0);
-
-window.setImmediate(\`\`);
-window['setImmediate'](\`\`);
-
-window.execScript(\`\`);
-window['execScript'](\`\`);
+setTimeout(1 + '' + (() => {}), 0);
+setInterval(1 + '' + (() => {}), 0);
+setImmediate(1 + '' + (() => {}));
+execScript(1 + '' + (() => {}));
       `,
       errors: [
         {
-          column: 19,
+          column: 12,
           line: 2,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 22,
+          column: 13,
           line: 3,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 20,
-          line: 5,
+          column: 14,
+          line: 4,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 23,
-          line: 6,
+          column: 12,
+          line: 5,
           messageId: 'noImpliedEvalError',
         },
+      ],
+    },
+    {
+      code: `
+const foo = 'x = 1';
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+      `,
+      errors: [
         {
-          column: 21,
-          line: 8,
+          column: 12,
+          line: 4,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 24,
-          line: 9,
+          column: 13,
+          line: 5,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 19,
-          line: 11,
+          column: 14,
+          line: 6,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 22,
-          line: 12,
+          column: 12,
+          line: 7,
           messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-global.setTimeout(\`\`, 0);
-global['setTimeout'](\`\`, 0);
-
-global.setInterval(\`\`, 0);
-global['setInterval'](\`\`, 0);
-
-global.setImmediate(\`\`);
-global['setImmediate'](\`\`);
+const foo = function () {
+  return 'x + 1';
+};
 
-global.execScript(\`\`);
-global['execScript'](\`\`);
+setTimeout(foo(), 0);
+setInterval(foo(), 0);
+setImmediate(foo());
+execScript(foo());
       `,
       errors: [
         {
-          column: 19,
-          line: 2,
+          column: 12,
+          line: 6,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 22,
-          line: 3,
+          column: 13,
+          line: 7,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 20,
-          line: 5,
+          column: 14,
+          line: 8,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 23,
-          line: 6,
+          column: 12,
+          line: 9,
           messageId: 'noImpliedEvalError',
         },
+      ],
+    },
+    {
+      code: `
+const foo = function () {
+  return () => 'x + 1';
+};
+
+setTimeout(foo()(), 0);
+setInterval(foo()(), 0);
+setImmediate(foo()());
+execScript(foo()());
+      `,
+      errors: [
         {
-          column: 21,
-          line: 8,
+          column: 12,
+          line: 6,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 24,
-          line: 9,
+          column: 13,
+          line: 7,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 19,
-          line: 11,
+          column: 14,
+          line: 8,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 22,
-          line: 12,
+          column: 12,
+          line: 9,
           messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-globalThis.setTimeout(\`\`, 0);
-globalThis['setTimeout'](\`\`, 0);
-
-globalThis.setInterval(\`\`, 0);
-globalThis['setInterval'](\`\`, 0);
-
-globalThis.setImmediate(\`\`);
-globalThis['setImmediate'](\`\`);
+const fn = function () {};
 
-globalThis.execScript(\`\`);
-globalThis['execScript'](\`\`);
+setTimeout(fn + '', 0);
+setInterval(fn + '', 0);
+setImmediate(fn + '');
+execScript(fn + '');
       `,
       errors: [
         {
-          column: 23,
-          line: 2,
+          column: 12,
+          line: 4,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 26,
-          line: 3,
+          column: 13,
+          line: 5,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 24,
-          line: 5,
+          column: 14,
+          line: 6,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 27,
-          line: 6,
+          column: 12,
+          line: 7,
           messageId: 'noImpliedEvalError',
         },
+      ],
+    },
+    {
+      code: `
+const foo: string = 'x + 1';
+
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
+      `,
+      errors: [
         {
-          column: 25,
-          line: 8,
+          column: 12,
+          line: 4,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 28,
-          line: 9,
+          column: 13,
+          line: 5,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 23,
-          line: 11,
+          column: 14,
+          line: 6,
           messageId: 'noImpliedEvalError',
         },
         {
-          column: 26,
-          line: 12,
+          column: 12,
+          line: 7,
           messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
       code: `
-const foo: string | undefined = 'hello';
-const bar = () => {};
+const foo = new String('x + 1');
 
-setTimeout(foo || bar, 500);
+setTimeout(foo, 0);
+setInterval(foo, 0);
+setImmediate(foo);
+execScript(foo);
       `,
       errors: [
         {
           column: 12,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
           line: 5,
           messageId: 'noImpliedEvalError',
         },
-      ],
-    },
-    {
-      code: 'const fn = Function();',
-      errors: [
+        {
+          column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
         {
           column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
-      code: "const fn = new Function('a', 'b', 'return a + b');",
+      code: `
+const foo = 'x + 1';
+
+setTimeout(foo as any, 0);
+setInterval(foo as any, 0);
+setImmediate(foo as any);
+execScript(foo as any);
+      `,
       errors: [
         {
           column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 13,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 12,
+          line: 7,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
-      code: 'const fn = window.Function();',
+      code: `
+const fn = (foo: string | any) => {
+  setTimeout(foo, 0);
+  setInterval(foo, 0);
+  setImmediate(foo);
+  execScript(foo);
+};
+      `,
       errors: [
         {
-          column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          column: 14,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 15,
+          line: 4,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 16,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 14,
+          line: 6,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
-      code: 'const fn = new window.Function();',
+      code: `
+const foo = 'foo';
+const bar = () => {};
+
+setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
+      `,
       errors: [
         {
           column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          line: 5,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
-      code: "const fn = window['Function']();",
+      code: `
+window.setTimeout(\`\`, 0);
+window['setTimeout'](\`\`, 0);
+
+window.setInterval(\`\`, 0);
+window['setInterval'](\`\`, 0);
+
+window.setImmediate(\`\`);
+window['setImmediate'](\`\`);
+
+window.execScript(\`\`);
+window['execScript'](\`\`);
+      `,
       errors: [
         {
-          column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          column: 19,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 22,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 20,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 23,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 21,
+          line: 8,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 24,
+          line: 9,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 19,
+          line: 11,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 22,
+          line: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
     {
-      code: "const fn = new window['Function']();",
+      code: `
+global.setTimeout(\`\`, 0);
+global['setTimeout'](\`\`, 0);
+
+global.setInterval(\`\`, 0);
+global['setInterval'](\`\`, 0);
+
+global.setImmediate(\`\`);
+global['setImmediate'](\`\`);
+
+global.execScript(\`\`);
+global['execScript'](\`\`);
+      `,
       errors: [
         {
-          column: 12,
-          line: 1,
-          messageId: 'noFunctionConstructor',
+          column: 19,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 22,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 20,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 23,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 21,
+          line: 8,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 24,
+          line: 9,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 19,
+          line: 11,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 22,
+          line: 12,
+          messageId: 'noImpliedEvalError',
         },
       ],
     },
-  ],
+    {
+      code: `
+globalThis.setTimeout(\`\`, 0);
+globalThis['setTimeout'](\`\`, 0);
 
-  valid: [
-    'foo.setImmediate(null);',
-    'foo.setInterval(null);',
-    'foo.execScript(null);',
-    'foo.setTimeout(null);',
-    'foo();',
-    '(function () {})();',
+globalThis.setInterval(\`\`, 0);
+globalThis['setInterval'](\`\`, 0);
 
-    'setTimeout(() => {}, 0);',
-    'window.setTimeout(() => {}, 0);',
-    "window['setTimeout'](() => {}, 0);",
-
-    'setInterval(() => {}, 0);',
-    'window.setInterval(() => {}, 0);',
-    "window['setInterval'](() => {}, 0);",
-
-    'setImmediate(() => {});',
-    'window.setImmediate(() => {});',
-    "window['setImmediate'](() => {});",
-
-    'execScript(() => {});',
-    'window.execScript(() => {});',
-    "window['execScript'](() => {});",
-
-    `
-const foo = () => {};
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-const foo = function () {};
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-function foo() {}
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: function () {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: function foo() {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn() {},
-};
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-const fn = 'fn';
-
-setTimeout(foo[fn], 0);
-setInterval(foo[fn], 0);
-setImmediate(foo[fn]);
-execScript(foo[fn]);
-    `,
-    `
-const foo = {
-  fn: () => {},
-};
-
-setTimeout(foo['fn'], 0);
-setInterval(foo['fn'], 0);
-setImmediate(foo['fn']);
-execScript(foo['fn']);
-    `,
-    `
-const foo: () => void = () => {};
-
-setTimeout(foo, 0);
-setInterval(foo, 0);
-setImmediate(foo);
-execScript(foo);
-    `,
-    `
-const foo: () => () => void = () => {
-  return () => {};
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo: () => () => void = () => () => {};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = () => () => {};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = function foo() {
-  return function foo() {};
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo = function () {
-  return function () {
-    return '';
-  };
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-const foo: () => () => void = function foo() {
-  return function foo() {};
-};
-
-setTimeout(foo(), 0);
-setInterval(foo(), 0);
-setImmediate(foo());
-execScript(foo());
-    `,
-    `
-function foo() {
-  return function foo() {
-    return () => {};
-  };
-}
-
-setTimeout(foo()(), 0);
-setInterval(foo()(), 0);
-setImmediate(foo()());
-execScript(foo()());
-    `,
-    `
-class Foo {
-  static fn = () => {};
-}
-
-setTimeout(Foo.fn, 0);
-setInterval(Foo.fn, 0);
-setImmediate(Foo.fn);
-execScript(Foo.fn);
-    `,
-    `
-class Foo {
-  fn() {}
-}
-
-const foo = new Foo();
-
-setTimeout(foo.fn, 0);
-setInterval(foo.fn, 0);
-setImmediate(foo.fn);
-execScript(foo.fn);
-    `,
-    `
-class Foo {
-  fn() {}
-}
-const foo = new Foo();
-const fn = foo.fn;
+globalThis.setImmediate(\`\`);
+globalThis['setImmediate'](\`\`);
 
-setTimeout(fn.bind(null), 0);
-setInterval(fn.bind(null), 0);
-setImmediate(fn.bind(null));
-execScript(fn.bind(null));
-    `,
-    `
-const fn = (foo: () => void) => {
-  setTimeout(foo, 0);
-  setInterval(foo, 0);
-  setImmediate(foo);
-  execScript(foo);
-};
-    `,
-    `
-import { Function } from './class';
-new Function('foo');
-    `,
-    `
-const foo = (callback: Function) => {
-  setTimeout(callback, 0);
-};
-    `,
-    `
-const foo = () => {};
+globalThis.execScript(\`\`);
+globalThis['execScript'](\`\`);
+      `,
+      errors: [
+        {
+          column: 23,
+          line: 2,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 26,
+          line: 3,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 24,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 27,
+          line: 6,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 25,
+          line: 8,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 28,
+          line: 9,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 23,
+          line: 11,
+          messageId: 'noImpliedEvalError',
+        },
+        {
+          column: 26,
+          line: 12,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: `
+const foo: string | undefined = 'hello';
 const bar = () => {};
 
-setTimeout(Math.radom() > 0.5 ? foo : bar, 0);
 setTimeout(foo || bar, 500);
-    `,
-    `
-class Foo {
-  func1() {}
-  func2(): void {
-    setTimeout(this.func1.bind(this), 1);
-  }
-}
-    `,
-    `
-class Foo {
-  private a = {
-    b: {
-      c: function () {},
+      `,
+      errors: [
+        {
+          column: 12,
+          line: 5,
+          messageId: 'noImpliedEvalError',
+        },
+      ],
+    },
+    {
+      code: 'const fn = Function();',
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
+    },
+    {
+      code: "const fn = new Function('a', 'b', 'return a + b');",
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
+    },
+    {
+      code: 'const fn = window.Function();',
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
+    },
+    {
+      code: 'const fn = new window.Function();',
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
+    },
+    {
+      code: "const fn = window['Function']();",
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
+    },
+    {
+      code: "const fn = new window['Function']();",
+      errors: [
+        {
+          column: 12,
+          line: 1,
+          messageId: 'noFunctionConstructor',
+        },
+      ],
     },
-  };
-  funcw(): void {
-    setTimeout(this.a.b.c.bind(this), 1);
-  }
-}
-    `,
-    `
-function setTimeout(input: string, value: number) {}
-
-setTimeout('', 0);
-    `,
-    `
-declare module 'my-timers-promises' {
-  export function setTimeout(ms: number): void;
-}
-
-import { setTimeout } from 'my-timers-promises';
-
-setTimeout(1000);
-    `,
-    `
-function setTimeout() {}
-
-{
-  setTimeout(100);
-}
-    `,
-    `
-function setTimeout() {}
-
-{
-  setTimeout("alert('evil!')");
-}
-    `,
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts b/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
index 5746581d8dc4..38534ccbd03b 100644
--- a/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-import-type-side-effects.test.ts
@@ -5,6 +5,20 @@ import rule from '../../src/rules/no-import-type-side-effects';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-import-type-side-effects', rule, {
+  valid: [
+    "import T from 'mod';",
+    "import * as T from 'mod';",
+    "import { T } from 'mod';",
+    "import type { T } from 'mod';",
+    "import type { T, U } from 'mod';",
+    "import { type T, U } from 'mod';",
+    "import { T, type U } from 'mod';",
+    "import type T from 'mod';",
+    "import type T, { U } from 'mod';",
+    "import T, { type U } from 'mod';",
+    "import type * as T from 'mod';",
+    "import 'mod';",
+  ],
   invalid: [
     {
       code: "import { type A } from 'mod';",
@@ -27,18 +41,4 @@ ruleTester.run('no-import-type-side-effects', rule, {
       output: "import type { A as AA, B as BB } from 'mod';",
     },
   ],
-  valid: [
-    "import T from 'mod';",
-    "import * as T from 'mod';",
-    "import { T } from 'mod';",
-    "import type { T } from 'mod';",
-    "import type { T, U } from 'mod';",
-    "import { type T, U } from 'mod';",
-    "import { T, type U } from 'mod';",
-    "import type T from 'mod';",
-    "import type T, { U } from 'mod';",
-    "import T, { type U } from 'mod';",
-    "import type * as T from 'mod';",
-    "import 'mod';",
-  ],
 });
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 8ec856baf342..61917c98c215 100644
--- a/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
@@ -97,6 +97,70 @@ const invalidTestCases: InvalidTestCase<MessageIds, Options>[] = flatten(
 const ruleTester = new RuleTester();
 
 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') {};",
+    "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;
+}
+    `,
+
+    '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') => {};",
+      options: [{ ignoreParameters: true }],
+    },
+    {
+      code: "function fn(a: number = 5, b: boolean = true, c: string = 'foo') {}",
+      options: [{ ignoreParameters: true }],
+    },
+    {
+      code: "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';
+}
+      `,
+      options: [{ ignoreProperties: true }],
+    },
+    {
+      code: `
+class Foo {
+  a?: number = 5;
+  b?: boolean = true;
+  c?: string = 'foo';
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  constructor(public a = true) {}
+}
+      `,
+    },
+  ],
+
   invalid: [
     ...invalidTestCases,
     {
@@ -256,70 +320,6 @@ class Foo {
       output: `
 class Foo {
   constructor(public a = true) {}
-}
-      `,
-    },
-  ],
-
-  valid: [
-    ...validTestCases,
-
-    "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;
-}
-    `,
-
-    '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') => {};",
-      options: [{ ignoreParameters: true }],
-    },
-    {
-      code: "function fn(a: number = 5, b: boolean = true, c: string = 'foo') {}",
-      options: [{ ignoreParameters: true }],
-    },
-    {
-      code: "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';
-}
-      `,
-      options: [{ ignoreProperties: true }],
-    },
-    {
-      code: `
-class Foo {
-  a?: number = 5;
-  b?: boolean = true;
-  c?: string = 'foo';
-}
-      `,
-    },
-    {
-      code: `
-class Foo {
-  constructor(public a = true) {}
 }
       `,
     },
diff --git a/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts b/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
index 544ca1c90af8..d7577508b593 100644
--- a/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
@@ -10,70 +10,53 @@ const errors = [
 ];
 
 ruleTester.run('no-invalid-this', rule, {
-  invalid: [
-    {
-      code: `
-interface SomeType {
-  prop: string;
+  valid: [
+    `
+describe('foo', () => {
+  it('does something', function (this: Mocha.Context) {
+    this.timeout(100);
+    // done
+  });
+});
+    `,
+    `
+      interface SomeType {
+        prop: string;
+      }
+      function foo(this: SomeType) {
+        this.prop;
+      }
+    `,
+    `
+function foo(this: prop) {
+  this.propMethod();
 }
+    `,
+    `
+z(function (x, this: context) {
+  console.log(x, this);
+});
+    `,
+    // https://github.com/eslint/eslint/issues/3287
+
+    `
 function foo() {
-  this.prop;
+  /** @this Obj*/ return function bar() {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
 }
-      `,
-      errors: [{ messageId: 'unexpectedThis' }],
-    },
-    // Global.
-    {
-      code: `
-console.log(this);
-z(x => console.log(x, this));
-      `,
-      errors,
-    },
-    {
-      code: `
-console.log(this);
-z(x => console.log(x, this));
-      `,
-      errors,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { globalReturn: true },
-        },
-      },
-    },
+    `,
 
-    // IIFE.
-    {
-      code: `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-})();
-      `,
-      errors,
-    },
+    // https://github.com/eslint/eslint/issues/6824
 
-    // Just functions.
-    {
-      code: `
-function foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-      `,
-      errors,
-    },
-    {
-      code: `
-function foo() {
+    `
+var Ctor = function () {
   console.log(this);
   z(x => console.log(x, this));
-}
-      `,
-      errors,
-      options: [{ capIsConstructor: false }], // test that the option doesn't reverse the logic and mistakenly allows lowercase functions
-    },
+};
+    `,
+    // Constructors.
     {
       code: `
 function Foo() {
@@ -81,284 +64,718 @@ function Foo() {
   z(x => console.log(x, this));
 }
       `,
-      errors,
-      options: [{ capIsConstructor: false }],
     },
     {
       code: `
-function foo() {
-  'use strict';
+function Foo() {
   console.log(this);
   z(x => console.log(x, this));
 }
       `,
-      errors,
+      options: [{}], // test the default value in schema
     },
     {
       code: `
 function Foo() {
-  'use strict';
   console.log(this);
   z(x => console.log(x, this));
 }
       `,
-      errors,
-      options: [{ capIsConstructor: false }],
+      options: [{ capIsConstructor: true }], // test explicitly set option to the default value
     },
     {
       code: `
-return function () {
+var Foo = function Foo() {
   console.log(this);
   z(x => console.log(x, this));
 };
       `,
-      errors,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { globalReturn: true },
-        },
-      },
     },
     {
       code: `
-var foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}.bar(obj);
+class A {
+  constructor() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
       `,
-      errors,
     },
 
-    // Functions in methods.
+    // On a property.
     {
       code: `
 var obj = {
   foo: function () {
-    function foo() {
-      console.log(this);
-      z(x => console.log(x, this));
-    }
-    foo();
+    console.log(this);
+    z(x => console.log(x, this));
   },
 };
       `,
-      errors,
     },
     {
       code: `
 var obj = {
   foo() {
-    function foo() {
-      console.log(this);
-      z(x => console.log(x, this));
-    }
-    foo();
+    console.log(this);
+    z(x => console.log(x, this));
   },
 };
       `,
-      errors,
     },
     {
       code: `
 var obj = {
-  foo: function () {
-    return function () {
+  foo:
+    foo ||
+    function () {
       console.log(this);
       z(x => console.log(x, this));
-    };
-  },
+    },
 };
       `,
-      errors,
     },
     {
       code: `
 var obj = {
-  foo: function () {
-    'use strict';
+  foo: hasNative
+    ? foo
+    : function () {
+        console.log(this);
+        z(x => console.log(x, this));
+      },
+};
+      `,
+    },
+    {
+      code: `
+var obj = {
+  foo: (function () {
     return function () {
       console.log(this);
       z(x => console.log(x, this));
     };
-  },
+  })(),
 };
       `,
-      errors,
     },
     {
       code: `
-obj.foo = function () {
-  return function () {
+Object.defineProperty(obj, 'foo', {
+  value: function () {
     console.log(this);
     z(x => console.log(x, this));
-  };
-};
+  },
+});
       `,
-      errors,
     },
     {
       code: `
-obj.foo = function () {
-  'use strict';
-  return function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-};
+Object.defineProperties(obj, {
+  foo: {
+    value: function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    },
+  },
+});
       `,
-      errors,
     },
 
-    // Class Methods.
-
+    // Assigns to a property.
     {
       code: `
-class A {
-  foo() {
-    return function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-  }
-}
+obj.foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+};
       `,
-      errors,
     },
-
-    // Class Properties.
-
     {
       code: `
-class A {
-  b = new Array(1, 2, function () {
+obj.foo =
+  foo ||
+  function () {
     console.log(this);
     z(x => console.log(x, this));
-  });
-}
+  };
       `,
-      errors,
     },
-
     {
       code: `
-class A {
-  b = () => {
-    function c() {
+obj.foo = foo
+  ? bar
+  : function () {
       console.log(this);
       z(x => console.log(x, this));
-    }
-  };
-}
+    };
       `,
-      errors,
     },
-
-    // Class Static methods.
-
     {
       code: `
 obj.foo = (function () {
-  return () => {
+  return function () {
     console.log(this);
     z(x => console.log(x, this));
   };
 })();
       `,
-      errors,
     },
     {
       code: `
-obj.foo = (() => () => {
-  console.log(this);
-  z(x => console.log(x, this));
-})();
+obj.foo = (() =>
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  })();
       `,
-      errors,
     },
-    // Bind/Call/Apply
 
-    {
-      code: `
+    // Bind/Call/Apply
+    `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).call(obj);
+    `,
+    `
 var foo = function () {
   console.log(this);
   z(x => console.log(x, this));
-}.bind(null);
+}.bind(obj);
+    `,
+    `
+Reflect.apply(
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+  obj,
+  [],
+);
+    `,
+    `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).apply(obj);
+    `,
+
+    // Class Instance Methods.
+    `
+class A {
+  foo() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
+    `,
+
+    // Class Properties.
+    `
+class A {
+  b = 0;
+  c = this.b;
+}
+    `,
+
+    `
+class A {
+  b = new Array(this, 1, 2, 3);
+}
+    `,
+
+    `
+class A {
+  b = () => {
+    console.log(this);
+  };
+}
+    `,
+
+    // Array methods.
+
+    `
+Array.from(
+  [],
+  function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+  obj,
+);
+    `,
+
+    `
+foo.every(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.filter(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.find(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.findIndex(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.forEach(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.map(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    `
+foo.some(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}, obj);
+    `,
+
+    // @this tag.
+
+    `
+/** @this Obj */ function foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+    `,
+
+    `
+foo(
+  /* @this Obj */ function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+);
+    `,
+
+    `
+/**
+ * @returns {void}
+ * @this Obj
+ */
+function foo() {
+  console.log(this);
+  z(x => console.log(x, this));
+}
+    `,
+
+    `
+Ctor = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+};
+    `,
+
+    `
+function foo(
+  Ctor = function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+) {}
+    `,
+
+    `
+[
+  obj.method = function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  },
+] = a;
+    `,
+
+    // Static
+
+    `
+class A {
+  static foo() {
+    console.log(this);
+    z(x => console.log(x, this));
+  }
+}
+    `,
+    `
+class A {
+  a = 5;
+  b = this.a;
+  accessor c = this.a;
+}
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+interface SomeType {
+  prop: string;
+}
+function foo() {
+  this.prop;
+}
+      `,
+      errors: [{ messageId: 'unexpectedThis' }],
+    },
+    // Global.
+    {
+      code: `
+console.log(this);
+z(x => console.log(x, this));
       `,
       errors,
     },
-
     {
       code: `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).call(undefined);
+console.log(this);
+z(x => console.log(x, this));
       `,
       errors,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
+      },
     },
 
+    // IIFE.
     {
       code: `
 (function () {
   console.log(this);
   z(x => console.log(x, this));
-}).apply(void 0);
+})();
       `,
       errors,
     },
 
-    // Array methods.
+    // Just functions.
     {
       code: `
-Array.from([], function () {
+function foo() {
   console.log(this);
   z(x => console.log(x, this));
-});
+}
       `,
       errors,
     },
     {
       code: `
-foo.every(function () {
+function foo() {
   console.log(this);
   z(x => console.log(x, this));
-});
+}
       `,
       errors,
+      options: [{ capIsConstructor: false }], // test that the option doesn't reverse the logic and mistakenly allows lowercase functions
     },
     {
       code: `
-foo.filter(function () {
+function Foo() {
   console.log(this);
   z(x => console.log(x, this));
-});
+}
       `,
       errors,
+      options: [{ capIsConstructor: false }],
     },
     {
       code: `
-foo.find(function () {
+function foo() {
+  'use strict';
   console.log(this);
   z(x => console.log(x, this));
-});
+}
       `,
       errors,
     },
     {
       code: `
-foo.findIndex(function () {
+function Foo() {
+  'use strict';
   console.log(this);
   z(x => console.log(x, this));
-});
+}
       `,
       errors,
+      options: [{ capIsConstructor: false }],
     },
     {
       code: `
-foo.forEach(function () {
+return function () {
   console.log(this);
   z(x => console.log(x, this));
-});
+};
+      `,
+      errors,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
+      },
+    },
+    {
+      code: `
+var foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}.bar(obj);
+      `,
+      errors,
+    },
+
+    // Functions in methods.
+    {
+      code: `
+var obj = {
+  foo: function () {
+    function foo() {
+      console.log(this);
+      z(x => console.log(x, this));
+    }
+    foo();
+  },
+};
+      `,
+      errors,
+    },
+    {
+      code: `
+var obj = {
+  foo() {
+    function foo() {
+      console.log(this);
+      z(x => console.log(x, this));
+    }
+    foo();
+  },
+};
+      `,
+      errors,
+    },
+    {
+      code: `
+var obj = {
+  foo: function () {
+    return function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+  },
+};
+      `,
+      errors,
+    },
+    {
+      code: `
+var obj = {
+  foo: function () {
+    'use strict';
+    return function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+  },
+};
+      `,
+      errors,
+    },
+    {
+      code: `
+obj.foo = function () {
+  return function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+};
+      `,
+      errors,
+    },
+    {
+      code: `
+obj.foo = function () {
+  'use strict';
+  return function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+};
+      `,
+      errors,
+    },
+
+    // Class Methods.
+
+    {
+      code: `
+class A {
+  foo() {
+    return function () {
+      console.log(this);
+      z(x => console.log(x, this));
+    };
+  }
+}
+      `,
+      errors,
+    },
+
+    // Class Properties.
+
+    {
+      code: `
+class A {
+  b = new Array(1, 2, function () {
+    console.log(this);
+    z(x => console.log(x, this));
+  });
+}
+      `,
+      errors,
+    },
+
+    {
+      code: `
+class A {
+  b = () => {
+    function c() {
+      console.log(this);
+      z(x => console.log(x, this));
+    }
+  };
+}
+      `,
+      errors,
+    },
+
+    // Class Static methods.
+
+    {
+      code: `
+obj.foo = (function () {
+  return () => {
+    console.log(this);
+    z(x => console.log(x, this));
+  };
+})();
+      `,
+      errors,
+    },
+    {
+      code: `
+obj.foo = (() => () => {
+  console.log(this);
+  z(x => console.log(x, this));
+})();
+      `,
+      errors,
+    },
+    // Bind/Call/Apply
+
+    {
+      code: `
+var foo = function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}.bind(null);
+      `,
+      errors,
+    },
+
+    {
+      code: `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).call(undefined);
+      `,
+      errors,
+    },
+
+    {
+      code: `
+(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+}).apply(void 0);
+      `,
+      errors,
+    },
+
+    // Array methods.
+    {
+      code: `
+Array.from([], function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
+      `,
+      errors,
+    },
+    {
+      code: `
+foo.every(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
+      `,
+      errors,
+    },
+    {
+      code: `
+foo.filter(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
+      `,
+      errors,
+    },
+    {
+      code: `
+foo.find(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
+      `,
+      errors,
+    },
+    {
+      code: `
+foo.findIndex(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
+      `,
+      errors,
+    },
+    {
+      code: `
+foo.forEach(function () {
+  console.log(this);
+  z(x => console.log(x, this));
+});
       `,
       errors,
     },
@@ -496,422 +913,4 @@ function foo(
       errors,
     },
   ],
-
-  valid: [
-    `
-describe('foo', () => {
-  it('does something', function (this: Mocha.Context) {
-    this.timeout(100);
-    // done
-  });
-});
-    `,
-    `
-      interface SomeType {
-        prop: string;
-      }
-      function foo(this: SomeType) {
-        this.prop;
-      }
-    `,
-    `
-function foo(this: prop) {
-  this.propMethod();
-}
-    `,
-    `
-z(function (x, this: context) {
-  console.log(x, this);
-});
-    `,
-    // https://github.com/eslint/eslint/issues/3287
-
-    `
-function foo() {
-  /** @this Obj*/ return function bar() {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-}
-    `,
-
-    // https://github.com/eslint/eslint/issues/6824
-
-    `
-var Ctor = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-    `,
-    // Constructors.
-    {
-      code: `
-function Foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-      `,
-    },
-    {
-      code: `
-function Foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-      `,
-      options: [{}], // test the default value in schema
-    },
-    {
-      code: `
-function Foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-      `,
-      options: [{ capIsConstructor: true }], // test explicitly set option to the default value
-    },
-    {
-      code: `
-var Foo = function Foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-      `,
-    },
-    {
-      code: `
-class A {
-  constructor() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
-      `,
-    },
-
-    // On a property.
-    {
-      code: `
-var obj = {
-  foo: function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-};
-      `,
-    },
-    {
-      code: `
-var obj = {
-  foo() {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-};
-      `,
-    },
-    {
-      code: `
-var obj = {
-  foo:
-    foo ||
-    function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    },
-};
-      `,
-    },
-    {
-      code: `
-var obj = {
-  foo: hasNative
-    ? foo
-    : function () {
-        console.log(this);
-        z(x => console.log(x, this));
-      },
-};
-      `,
-    },
-    {
-      code: `
-var obj = {
-  foo: (function () {
-    return function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-  })(),
-};
-      `,
-    },
-    {
-      code: `
-Object.defineProperty(obj, 'foo', {
-  value: function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-});
-      `,
-    },
-    {
-      code: `
-Object.defineProperties(obj, {
-  foo: {
-    value: function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    },
-  },
-});
-      `,
-    },
-
-    // Assigns to a property.
-    {
-      code: `
-obj.foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-      `,
-    },
-    {
-      code: `
-obj.foo =
-  foo ||
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-      `,
-    },
-    {
-      code: `
-obj.foo = foo
-  ? bar
-  : function () {
-      console.log(this);
-      z(x => console.log(x, this));
-    };
-      `,
-    },
-    {
-      code: `
-obj.foo = (function () {
-  return function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  };
-})();
-      `,
-    },
-    {
-      code: `
-obj.foo = (() =>
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  })();
-      `,
-    },
-
-    // Bind/Call/Apply
-    `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).call(obj);
-    `,
-    `
-var foo = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}.bind(obj);
-    `,
-    `
-Reflect.apply(
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-  obj,
-  [],
-);
-    `,
-    `
-(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}).apply(obj);
-    `,
-
-    // Class Instance Methods.
-    `
-class A {
-  foo() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
-    `,
-
-    // Class Properties.
-    `
-class A {
-  b = 0;
-  c = this.b;
-}
-    `,
-
-    `
-class A {
-  b = new Array(this, 1, 2, 3);
-}
-    `,
-
-    `
-class A {
-  b = () => {
-    console.log(this);
-  };
-}
-    `,
-
-    // Array methods.
-
-    `
-Array.from(
-  [],
-  function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-  obj,
-);
-    `,
-
-    `
-foo.every(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.filter(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.find(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.findIndex(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.forEach(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.map(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    `
-foo.some(function () {
-  console.log(this);
-  z(x => console.log(x, this));
-}, obj);
-    `,
-
-    // @this tag.
-
-    `
-/** @this Obj */ function foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-    `,
-
-    `
-foo(
-  /* @this Obj */ function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-);
-    `,
-
-    `
-/**
- * @returns {void}
- * @this Obj
- */
-function foo() {
-  console.log(this);
-  z(x => console.log(x, this));
-}
-    `,
-
-    `
-Ctor = function () {
-  console.log(this);
-  z(x => console.log(x, this));
-};
-    `,
-
-    `
-function foo(
-  Ctor = function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-) {}
-    `,
-
-    `
-[
-  obj.method = function () {
-    console.log(this);
-    z(x => console.log(x, this));
-  },
-] = a;
-    `,
-
-    // Static
-
-    `
-class A {
-  static foo() {
-    console.log(this);
-    z(x => console.log(x, this));
-  }
-}
-    `,
-    `
-class A {
-  a = 5;
-  b = this.a;
-  accessor c = this.a;
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts b/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
index 2ca40e1de97f..8f2c4b944dfe 100644
--- a/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-invalid-void-type.test.ts
@@ -5,6 +5,29 @@ import rule from '../../src/rules/no-invalid-void-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('allowInGenericTypeArguments: false', rule, {
+  valid: [
+    {
+      code: 'type Generic<T> = [T];',
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/1946
+      code: `
+function foo(): void | never {
+  throw new Error('Test');
+}
+      `,
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      code: 'type voidNeverUnion = void | never;',
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+    {
+      code: 'type neverVoidUnion = never | void;',
+      options: [{ allowInGenericTypeArguments: false }],
+    },
+  ],
   invalid: [
     {
       code: 'type GenericVoid = Generic<void>;',
@@ -72,32 +95,32 @@ ruleTester.run('allowInGenericTypeArguments: false', rule, {
       options: [{ allowInGenericTypeArguments: false }],
     },
   ],
-  valid: [
-    {
-      code: 'type Generic<T> = [T];',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/1946
-      code: `
-function foo(): void | never {
-  throw new Error('Test');
-}
-      `,
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      code: 'type voidNeverUnion = void | never;',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-    {
-      code: 'type neverVoidUnion = never | void;',
-      options: [{ allowInGenericTypeArguments: false }],
-    },
-  ],
 });
 
 ruleTester.run('allowInGenericTypeArguments: true', rule, {
+  valid: [
+    'function func(): void {}',
+    'type NormalType = () => void;',
+    'let normalArrow = (): void => {};',
+    'let ughThisThing = void 0;',
+    'function takeThing(thing: undefined) {}',
+    'takeThing(void 0);',
+    'let voidPromise: Promise<void> = new Promise<void>(() => {});',
+    'let voidMap: Map<string, void> = new Map<string, void>();',
+    `
+      function returnsVoidPromiseDirectly(): Promise<void> {
+        return Promise.resolve();
+      }
+    `,
+    'async function returnsVoidPromiseAsync(): Promise<void> {}',
+    'type UnionType = string | number;',
+    'type GenericVoid = Generic<void>;',
+    'type Generic<T> = [T];',
+    'type voidPromiseUnion = void | Promise<void>;',
+    'type promiseNeverUnion = Promise<void> | never;',
+    'const arrowGeneric1 = <T = void,>(arg: T) => {};',
+    'declare function functionDeclaration1<T = void>(arg: T): void;',
+  ],
   invalid: [
     {
       code: 'function takeVoid(thing: void) {}',
@@ -397,69 +420,9 @@ ruleTester.run('allowInGenericTypeArguments: true', rule, {
       ],
     },
   ],
-  valid: [
-    'function func(): void {}',
-    'type NormalType = () => void;',
-    'let normalArrow = (): void => {};',
-    'let ughThisThing = void 0;',
-    'function takeThing(thing: undefined) {}',
-    'takeThing(void 0);',
-    'let voidPromise: Promise<void> = new Promise<void>(() => {});',
-    'let voidMap: Map<string, void> = new Map<string, void>();',
-    `
-      function returnsVoidPromiseDirectly(): Promise<void> {
-        return Promise.resolve();
-      }
-    `,
-    'async function returnsVoidPromiseAsync(): Promise<void> {}',
-    'type UnionType = string | number;',
-    'type GenericVoid = Generic<void>;',
-    'type Generic<T> = [T];',
-    'type voidPromiseUnion = void | Promise<void>;',
-    'type promiseNeverUnion = Promise<void> | never;',
-    'const arrowGeneric1 = <T = void,>(arg: T) => {};',
-    'declare function functionDeclaration1<T = void>(arg: T): void;',
-  ],
 });
 
 ruleTester.run('allowInGenericTypeArguments: whitelist', rule, {
-  invalid: [
-    {
-      code: 'type BannedVoid = Banned<void>;',
-      errors: [
-        {
-          column: 26,
-          data: { generic: 'Banned' },
-          line: 1,
-          messageId: 'invalidVoidForGeneric',
-        },
-      ],
-      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
-    },
-    {
-      code: 'type BannedVoid = Ex.Mx.Tx<void>;',
-      errors: [
-        {
-          column: 28,
-          data: { generic: 'Ex.Mx.Tx' },
-          line: 1,
-          messageId: 'invalidVoidForGeneric',
-        },
-      ],
-      options: [{ allowInGenericTypeArguments: ['Tx'] }],
-    },
-    {
-      code: 'function takeVoid(thing: void) {}',
-      errors: [
-        {
-          column: 26,
-          line: 1,
-          messageId: 'invalidVoidNotReturnOrGeneric',
-        },
-      ],
-      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
-    },
-  ],
   valid: [
     'type Allowed<T> = [T];',
     'type Banned<T> = [T];',
@@ -511,9 +474,61 @@ async function foo(bar: () => void | Promise<void>) {
       options: [{ allowInGenericTypeArguments: ['Promise'] }],
     },
   ],
+  invalid: [
+    {
+      code: 'type BannedVoid = Banned<void>;',
+      errors: [
+        {
+          column: 26,
+          data: { generic: 'Banned' },
+          line: 1,
+          messageId: 'invalidVoidForGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+    },
+    {
+      code: 'type BannedVoid = Ex.Mx.Tx<void>;',
+      errors: [
+        {
+          column: 28,
+          data: { generic: 'Ex.Mx.Tx' },
+          line: 1,
+          messageId: 'invalidVoidForGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Tx'] }],
+    },
+    {
+      code: 'function takeVoid(thing: void) {}',
+      errors: [
+        {
+          column: 26,
+          line: 1,
+          messageId: 'invalidVoidNotReturnOrGeneric',
+        },
+      ],
+      options: [{ allowInGenericTypeArguments: ['Allowed'] }],
+    },
+  ],
 });
 
 ruleTester.run('allowAsThisParameter: true', rule, {
+  valid: [
+    {
+      code: 'function f(this: void) {}',
+      options: [{ allowAsThisParameter: true }],
+    },
+    {
+      code: `
+class Test {
+  public static helper(this: void) {}
+  method(this: void) {}
+}
+      `,
+      options: [{ allowAsThisParameter: true }],
+    },
+  ],
   invalid: [
     {
       code: 'type alias = void;',
@@ -549,19 +564,4 @@ ruleTester.run('allowAsThisParameter: true', rule, {
       ],
     },
   ],
-  valid: [
-    {
-      code: 'function f(this: void) {}',
-      options: [{ allowAsThisParameter: true }],
-    },
-    {
-      code: `
-class Test {
-  public static helper(this: void) {}
-  method(this: void) {}
-}
-      `,
-      options: [{ allowAsThisParameter: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-loop-func.test.ts b/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
index 91aa77a2b3a4..544e8615a395 100644
--- a/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
@@ -6,7 +6,6 @@ import rule from '../../src/rules/no-loop-func';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-loop-func', rule, {
-  invalid: [],
   valid: [
     `
 let someArray: MyType[] = [];
@@ -48,10 +47,231 @@ for (let i = 0; i < 10; i += 1) {
 }
     `,
   ],
+  invalid: [],
 });
 
 // Forked from https://github.com/eslint/eslint/blob/bf2e367bf4f6fde9930af9de8b8d8bc3d8b5782f/tests/lib/rules/no-loop-func.js
 ruleTester.run('no-loop-func ESLint tests', rule, {
+  valid: [
+    "string = 'function a() {}';",
+    `
+for (var i = 0; i < l; i++) {}
+var a = function () {
+  i;
+};
+    `,
+    `
+for (
+  var i = 0,
+    a = function () {
+      i;
+    };
+  i < l;
+  i++
+) {}
+    `,
+    `
+for (var x in xs.filter(function (x) {
+  return x != upper;
+})) {
+}
+    `,
+    {
+      code: `
+for (var x of xs.filter(function (x) {
+  return x != upper;
+})) {
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+
+    // no refers to variables that declared on upper scope.
+    `
+for (var i = 0; i < l; i++) {
+  (function () {});
+}
+    `,
+    `
+for (var i in {}) {
+  (function () {});
+}
+    `,
+    {
+      code: `
+for (var i of {}) {
+  (function () {});
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+
+    // functions which are using unmodified variables are OK.
+    {
+      code: `
+for (let i = 0; i < l; i++) {
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (let i in {}) {
+  i = 7;
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (const i of {}) {
+  (function () {
+    i;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+for (let i = 0; i < 10; ++i) {
+  for (let x in xs.filter(x => x != i)) {
+  }
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i in {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i of {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    (function () {
+      a;
+    });
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i in {}) {
+  function foo() {
+    (function () {
+      a;
+    });
+  }
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+let a = 0;
+for (let i of {}) {
+  () => {
+    (function () {
+      a;
+    });
+  };
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i = 0; i < l; i++) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i in {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: `
+var a = 0;
+for (let i of {}) {
+  (function () {
+    a;
+  });
+}
+      `,
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: [
+        'let result = {};',
+        'for (const score in scores) {',
+        '  const letters = scores[score];',
+        "  letters.split('').forEach(letter => {",
+        '    result[letter] = score;',
+        '  });',
+        '}',
+        'result.__default = 6;',
+      ].join('\n'),
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: ['while (true) {', '    (function() { a; });', '}', 'let a;'].join(
+        '\n',
+      ),
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+  ],
   invalid: [
     {
       code: `
@@ -518,224 +738,4 @@ foo();
       languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
   ],
-  valid: [
-    "string = 'function a() {}';",
-    `
-for (var i = 0; i < l; i++) {}
-var a = function () {
-  i;
-};
-    `,
-    `
-for (
-  var i = 0,
-    a = function () {
-      i;
-    };
-  i < l;
-  i++
-) {}
-    `,
-    `
-for (var x in xs.filter(function (x) {
-  return x != upper;
-})) {
-}
-    `,
-    {
-      code: `
-for (var x of xs.filter(function (x) {
-  return x != upper;
-})) {
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-
-    // no refers to variables that declared on upper scope.
-    `
-for (var i = 0; i < l; i++) {
-  (function () {});
-}
-    `,
-    `
-for (var i in {}) {
-  (function () {});
-}
-    `,
-    {
-      code: `
-for (var i of {}) {
-  (function () {});
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-
-    // functions which are using unmodified variables are OK.
-    {
-      code: `
-for (let i = 0; i < l; i++) {
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (let i in {}) {
-  i = 7;
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (const i of {}) {
-  (function () {
-    i;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-for (let i = 0; i < 10; ++i) {
-  for (let x in xs.filter(x => x != i)) {
-  }
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i in {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i of {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    (function () {
-      a;
-    });
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i in {}) {
-  function foo() {
-    (function () {
-      a;
-    });
-  }
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-let a = 0;
-for (let i of {}) {
-  () => {
-    (function () {
-      a;
-    });
-  };
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i = 0; i < l; i++) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i in {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: `
-var a = 0;
-for (let i of {}) {
-  (function () {
-    a;
-  });
-}
-      `,
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: [
-        'let result = {};',
-        'for (const score in scores) {',
-        '  const letters = scores[score];',
-        "  letters.split('').forEach(letter => {",
-        '    result[letter] = score;',
-        '  });',
-        '}',
-        'result.__default = 6;',
-      ].join('\n'),
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-    {
-      code: ['while (true) {', '    (function() { a; });', '}', 'let a;'].join(
-        '\n',
-      ),
-      languageOptions: { parserOptions: { ecmaVersion: 6 } },
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts b/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
index 2a1547b59cf1..105eacfc2250 100644
--- a/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-loss-of-precision.test.ts
@@ -5,6 +5,14 @@ import rule from '../../src/rules/no-loss-of-precision';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-loss-of-precision', rule, {
+  valid: [
+    'const x = 12345;',
+    'const x = 123.456;',
+    'const x = -123.456;',
+    'const x = 123_456;',
+    'const x = 123_00_000_000_000_000_000_000_000;',
+    'const x = 123.000_000_000_000_000_000_000_0;',
+  ],
   invalid: [
     {
       code: 'const x = 9007199254740993;',
@@ -23,12 +31,4 @@ ruleTester.run('no-loss-of-precision', rule, {
       errors: [{ messageId: 'noLossOfPrecision' }],
     },
   ],
-  valid: [
-    'const x = 12345;',
-    'const x = 123.456;',
-    'const x = -123.456;',
-    'const x = 123_456;',
-    'const x = 123_00_000_000_000_000_000_000_000;',
-    'const x = 123.000_000_000_000_000_000_000_0;',
-  ],
 });
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 da2f2ab6d46c..832d03558e63 100644
--- a/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
@@ -5,6 +5,236 @@ import rule from '../../src/rules/no-magic-numbers';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-magic-numbers', rule, {
+  valid: [
+    {
+      code: 'const FOO = 10;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: "type Foo = 'bar';",
+    },
+    {
+      code: 'type Foo = true;',
+    },
+    {
+      code: 'type Foo = 1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = -1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: 'type Foo = 1 | -1;',
+      options: [{ ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: `
+        enum foo {
+          SECOND = 1000,
+          NUM = '0123456789',
+          NEG = -1,
+          POS = +1,
+        }
+      `,
+      options: [{ ignoreEnums: true }],
+    },
+    {
+      code: `
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+  readonly E = -1;
+  readonly F = +1;
+  private readonly G = 100n;
+}
+      `,
+      options: [{ ignoreReadonlyClassProperties: true }],
+    },
+    {
+      code: 'type Foo = Bar[0];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[-1];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[0xab];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[5.6e1];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[10n];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 | -2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 & -2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[1 & number];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Bar[((1 & -2) | 3) | 4];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = Parameters<Bar>[2];',
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: "type Foo = Bar['baz'];",
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: "type Foo = Bar['baz'];",
+      options: [{ ignoreTypeIndexes: false }],
+    },
+    {
+      code: `
+type Others = [['a'], ['b']];
+
+type Foo = {
+  [K in keyof Others[0]]: Others[K];
+};
+      `,
+      options: [{ ignoreTypeIndexes: true }],
+    },
+    {
+      code: 'type Foo = 1;',
+      options: [{ ignore: [1] }],
+    },
+    {
+      code: 'type Foo = -2;',
+      options: [{ ignore: [-2] }],
+    },
+    {
+      code: 'type Foo = 3n;',
+      options: [{ ignore: ['3n'] }],
+    },
+    {
+      code: 'type Foo = -4n;',
+      options: [{ ignore: ['-4n'] }],
+    },
+    {
+      code: 'type Foo = 5.6;',
+      options: [{ ignore: [5.6] }],
+    },
+    {
+      code: 'type Foo = -7.8;',
+      options: [{ ignore: [-7.8] }],
+    },
+    {
+      code: 'type Foo = 0x0a;',
+      options: [{ ignore: [0x0a] }],
+    },
+    {
+      code: 'type Foo = -0xbc;',
+      options: [{ ignore: [-0xbc] }],
+    },
+    {
+      code: 'type Foo = 1e2;',
+      options: [{ ignore: [1e2] }],
+    },
+    {
+      code: 'type Foo = -3e4;',
+      options: [{ ignore: [-3e4] }],
+    },
+    {
+      code: 'type Foo = 5e-6;',
+      options: [{ ignore: [5e-6] }],
+    },
+    {
+      code: 'type Foo = -7e-8;',
+      options: [{ ignore: [-7e-8] }],
+    },
+    {
+      code: 'type Foo = 1.1e2;',
+      options: [{ ignore: [1.1e2] }],
+    },
+    {
+      code: 'type Foo = -3.1e4;',
+      options: [{ ignore: [-3.1e4] }],
+    },
+    {
+      code: 'type Foo = 5.1e-6;',
+      options: [{ ignore: [5.1e-6] }],
+    },
+    {
+      code: 'type Foo = -7.1e-8;',
+      options: [{ ignore: [-7.1e-8] }],
+    },
+    {
+      code: `
+interface Foo {
+  bar: 1;
+}
+      `,
+      options: [{ ignore: [1], ignoreNumericLiteralTypes: true }],
+    },
+    {
+      code: `
+enum foo {
+  SECOND = 1000,
+  NUM = '0123456789',
+  NEG = -1,
+  POS = +2,
+}
+      `,
+      options: [{ ignore: [1000, -1, 2], ignoreEnums: false }],
+    },
+    {
+      code: `
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 3;
+  static readonly D = 4;
+  readonly E = -5;
+  readonly F = +6;
+  private readonly G = 100n;
+  private static readonly H = -2000n;
+}
+      `,
+      options: [
+        {
+          ignore: [1, 2, 3, 4, -5, 6, '100n', '-2000n'],
+          ignoreReadonlyClassProperties: false,
+        },
+      ],
+    },
+    {
+      code: 'type Foo = Bar[0];',
+      options: [{ ignore: [0], ignoreTypeIndexes: false }],
+    },
+    {
+      code: `
+type Other = {
+  [0]: 3;
+};
+
+type Foo = {
+  [K in keyof Other]: \`\${K & number}\`;
+};
+      `,
+      options: [{ ignore: [0, 3], ignoreTypeIndexes: true }],
+    },
+  ],
   invalid: [
     {
       code: 'type Foo = 1;',
@@ -710,235 +940,4 @@ type Foo = {
       options: [{ ignore: [7.1e-8] }],
     },
   ],
-
-  valid: [
-    {
-      code: 'const FOO = 10;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: "type Foo = 'bar';",
-    },
-    {
-      code: 'type Foo = true;',
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = -1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: 'type Foo = 1 | -1;',
-      options: [{ ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: `
-        enum foo {
-          SECOND = 1000,
-          NUM = '0123456789',
-          NEG = -1,
-          POS = +1,
-        }
-      `,
-      options: [{ ignoreEnums: true }],
-    },
-    {
-      code: `
-class Foo {
-  readonly A = 1;
-  readonly B = 2;
-  public static readonly C = 1;
-  static readonly D = 1;
-  readonly E = -1;
-  readonly F = +1;
-  private readonly G = 100n;
-}
-      `,
-      options: [{ ignoreReadonlyClassProperties: true }],
-    },
-    {
-      code: 'type Foo = Bar[0];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[-1];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[0xab];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[5.6e1];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[10n];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 | -2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 & -2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[1 & number];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Bar[((1 & -2) | 3) | 4];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = Parameters<Bar>[2];',
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: "type Foo = Bar['baz'];",
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: "type Foo = Bar['baz'];",
-      options: [{ ignoreTypeIndexes: false }],
-    },
-    {
-      code: `
-type Others = [['a'], ['b']];
-
-type Foo = {
-  [K in keyof Others[0]]: Others[K];
-};
-      `,
-      options: [{ ignoreTypeIndexes: true }],
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ ignore: [1] }],
-    },
-    {
-      code: 'type Foo = -2;',
-      options: [{ ignore: [-2] }],
-    },
-    {
-      code: 'type Foo = 3n;',
-      options: [{ ignore: ['3n'] }],
-    },
-    {
-      code: 'type Foo = -4n;',
-      options: [{ ignore: ['-4n'] }],
-    },
-    {
-      code: 'type Foo = 5.6;',
-      options: [{ ignore: [5.6] }],
-    },
-    {
-      code: 'type Foo = -7.8;',
-      options: [{ ignore: [-7.8] }],
-    },
-    {
-      code: 'type Foo = 0x0a;',
-      options: [{ ignore: [0x0a] }],
-    },
-    {
-      code: 'type Foo = -0xbc;',
-      options: [{ ignore: [-0xbc] }],
-    },
-    {
-      code: 'type Foo = 1e2;',
-      options: [{ ignore: [1e2] }],
-    },
-    {
-      code: 'type Foo = -3e4;',
-      options: [{ ignore: [-3e4] }],
-    },
-    {
-      code: 'type Foo = 5e-6;',
-      options: [{ ignore: [5e-6] }],
-    },
-    {
-      code: 'type Foo = -7e-8;',
-      options: [{ ignore: [-7e-8] }],
-    },
-    {
-      code: 'type Foo = 1.1e2;',
-      options: [{ ignore: [1.1e2] }],
-    },
-    {
-      code: 'type Foo = -3.1e4;',
-      options: [{ ignore: [-3.1e4] }],
-    },
-    {
-      code: 'type Foo = 5.1e-6;',
-      options: [{ ignore: [5.1e-6] }],
-    },
-    {
-      code: 'type Foo = -7.1e-8;',
-      options: [{ ignore: [-7.1e-8] }],
-    },
-    {
-      code: `
-interface Foo {
-  bar: 1;
-}
-      `,
-      options: [{ ignore: [1], ignoreNumericLiteralTypes: true }],
-    },
-    {
-      code: `
-enum foo {
-  SECOND = 1000,
-  NUM = '0123456789',
-  NEG = -1,
-  POS = +2,
-}
-      `,
-      options: [{ ignore: [1000, -1, 2], ignoreEnums: false }],
-    },
-    {
-      code: `
-class Foo {
-  readonly A = 1;
-  readonly B = 2;
-  public static readonly C = 3;
-  static readonly D = 4;
-  readonly E = -5;
-  readonly F = +6;
-  private readonly G = 100n;
-  private static readonly H = -2000n;
-}
-      `,
-      options: [
-        {
-          ignore: [1, 2, 3, 4, -5, 6, '100n', '-2000n'],
-          ignoreReadonlyClassProperties: false,
-        },
-      ],
-    },
-    {
-      code: 'type Foo = Bar[0];',
-      options: [{ ignore: [0], ignoreTypeIndexes: false }],
-    },
-    {
-      code: `
-type Other = {
-  [0]: 3;
-};
-
-type Foo = {
-  [K in keyof Other]: \`\${K & number}\`;
-};
-      `,
-      options: [{ ignore: [0, 3], ignoreTypeIndexes: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts b/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
index db16bc4915ff..38c5a239740a 100644
--- a/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-meaningless-void-operator.test.ts
@@ -15,6 +15,25 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-meaningless-void-operator', rule, {
+  valid: [
+    `
+(() => {})();
+
+function foo() {}
+foo(); // nothing to discard
+
+function bar(x: number) {
+  void x;
+  return 2;
+}
+void bar(); // discarding a number
+    `,
+    `
+function bar(x: never) {
+  void x;
+}
+    `,
+  ],
   invalid: [
     {
       code: 'void (() => {})();',
@@ -71,23 +90,4 @@ function bar(x: never) {
       output: null,
     },
   ],
-  valid: [
-    `
-(() => {})();
-
-function foo() {}
-foo(); // nothing to discard
-
-function bar(x: number) {
-  void x;
-  return 2;
-}
-void bar(); // discarding a number
-    `,
-    `
-function bar(x: never) {
-  void x;
-}
-    `,
-  ],
 });
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 c40c195fc858..3fccc04ea657 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
@@ -5,6 +5,74 @@ import rule from '../../src/rules/no-misused-new';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-misused-new', rule, {
+  valid: [
+    `
+declare abstract class C {
+  foo() {}
+  get new();
+  bar();
+}
+    `,
+    `
+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() {}
+};
+    `,
+    // OK if return type is not the interface.
+    `
+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';
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -99,72 +167,4 @@ interface I {
       ],
     },
   ],
-  valid: [
-    `
-declare abstract class C {
-  foo() {}
-  get new();
-  bar();
-}
-    `,
-    `
-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() {}
-};
-    `,
-    // OK if return type is not the interface.
-    `
-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';
-}
-    `,
-  ],
 });
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 d5aa959f11ef..f38b73453e8b 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
@@ -15,19 +15,24 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-misused-promises', rule, {
-  invalid: [
+  valid: [
+    `
+if (true) {
+}
+    `,
     {
       code: `
 if (Promise.resolve()) {
 }
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    `
+if (true) {
+} else if (false) {
+} else {
+}
+    `,
     {
       code: `
 if (Promise.resolve()) {
@@ -35,490 +40,294 @@ if (Promise.resolve()) {
 } else {
 }
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    'for (;;) {}',
+    'for (let i; i < 10; i++) {}',
     {
       code: 'for (let i; Promise.resolve(); i++) {}',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    'do {} while (true);',
     {
       code: 'do {} while (Promise.resolve());',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    'while (true) {}',
     {
       code: 'while (Promise.resolve()) {}',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    'true ? 123 : 456;',
     {
       code: 'Promise.resolve() ? 123 : 456;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    `
+if (!true) {
+}
+    `,
     {
       code: `
 if (!Promise.resolve()) {
 }
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'conditional',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    '(await Promise.resolve()) || false;',
     {
       code: 'Promise.resolve() || false;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'conditional',
-        },
-      ],
-    },
-    {
-      code: `
-[Promise.resolve(), Promise.reject()].forEach(async val => {
-  await val;
-});
-      `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-new Promise(async (resolve, reject) => {
-  await Promise.resolve();
-  resolve();
-});
-      `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
-
-fnWithCallback('val', async (err, res) => {
-  await res;
-});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
-
-fnWithCallback('val', (err, res) => Promise.resolve(res));
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
-  cb(null, arg);
-};
-
-fnWithCallback('val', (err, res) => {
-  if (err) {
-    return 'abc';
-  } else {
-    return Promise.resolve(res);
-  }
-});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-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: 8,
-          messageId: 'voidReturnArgument',
-        },
-      ],
+      options: [{ checksConditionals: false }],
     },
+    '(true && (await Promise.resolve())) || false;',
     {
-      code: `
-const fnWithCallback:
-  | ((arg: string, cb: (err: any, res: string) => void) => void)
-  | null = (arg, cb) => {
-  cb(null, arg);
-};
-
-fnWithCallback('val', (err, res) => {
-  if (err) {
-    return 'abc';
-  } else {
-    return Promise.resolve(res);
-  }
-});
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'voidReturnArgument',
-        },
-      ],
+      code: '(true && Promise.resolve()) || false;',
+      options: [{ checksConditionals: false }],
     },
-    {
-      code: `
-function test(bool: boolean, p: Promise<void>) {
-  if (bool || p) {
+    'false || (true && Promise.resolve());',
+    '(true && Promise.resolve()) || false;',
+    `
+async function test() {
+  if (await Promise.resolve()) {
   }
 }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
-    },
-    {
-      code: `
-function test(bool: boolean, p: Promise<void>) {
-  if (bool && p) {
+    `,
+    `
+async function test() {
+  const mixed: Promise | undefined = Promise.resolve();
+  if (mixed) {
+    await mixed;
   }
 }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
+    `,
+    `
+if (~Promise.resolve()) {
+}
+    `,
+    `
+interface NotQuiteThenable {
+  then(param: string): void;
+  then(): void;
+}
+const value: NotQuiteThenable = { then() {} };
+if (value) {
+}
+    `,
+    '[1, 2, 3].forEach(val => {});',
+    {
+      code: '[1, 2, 3].forEach(async val => {});',
+      options: [{ checksVoidReturn: false }],
     },
+    'new Promise((resolve, reject) => resolve());',
     {
-      code: `
-function test(a: any, p: Promise<void>) {
-  if (a ?? p) {
+      code: 'new Promise(async (resolve, reject) => resolve());',
+      options: [{ checksVoidReturn: false }],
+    },
+    `
+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: { call: () => Promise<void> } | null;
+if (returnsPromise?.call()) {
+}
+    `,
+    'Promise.resolve() ?? false;',
+    `
+function test(a: Promise<void> | undefinded) {
+  const foo = a ?? Promise.reject();
+}
+    `,
+    `
+function test(p: Promise<boolean> | undefined, bool: boolean) {
+  if (p ?? bool) {
   }
 }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
-    },
-    {
-      code: `
-function test(p: Promise<void> | undefined) {
-  if (p ?? Promise.reject()) {
+    `,
+    `
+async function test(p: Promise<boolean | undefined>, bool: boolean) {
+  if ((await p) ?? bool) {
   }
 }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'conditional',
-        },
-      ],
-    },
+    `,
+    `
+async function test(p: Promise<boolean> | undefined) {
+  if (await (p ?? Promise.reject())) {
+  }
+}
+    `,
+    `
+let f;
+f = async () => 10;
+    `,
+    `
+let f: () => Promise<void>;
+f = async () => 10;
+const g = async () => 0;
+const h: () => Promise<void> = async () => 10;
+    `,
+    `
+const obj = {
+  f: async () => 10,
+};
+    `,
+    `
+const f = async () => 123;
+const obj = {
+  f,
+};
+    `,
+    `
+const obj = {
+  async f() {
+    return 0;
+  },
+};
+    `,
+    `
+type O = { f: () => Promise<void>; g: () => Promise<void> };
+const g = async () => 0;
+const obj: O = {
+  f: async () => 10,
+  g,
+};
+    `,
+    `
+type O = { f: () => Promise<void> };
+const name = 'f';
+const obj: O = {
+  async [name]() {
+    return 10;
+  },
+};
+    `,
+    `
+const obj: number = {
+  g() {
+    return 10;
+  },
+};
+    `,
+    `
+const obj = {
+  f: async () => 'foo',
+  async g() {
+    return 0;
+  },
+};
+    `,
+    `
+function f() {
+  return async () => 0;
+}
+function g() {
+  return;
+}
+    `,
     {
       code: `
-let f: () => void;
-f = async () => {
-  return 3;
+type O = {
+  bool: boolean;
+  func: () => Promise<void>;
 };
+const Component = (obj: O) => null;
+<Component bool func={async () => 10} />;
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnVariable',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
+      },
     },
     {
       code: `
-let f: () => void;
-f = async () => {
-  return 3;
-};
+const Component: any = () => null;
+<Component func={async () => 10} />;
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnVariable',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
-      options: [{ checksVoidReturn: { variables: true } }],
+      },
     },
     {
       code: `
-const f: () => void = async () => {
-  return 0;
-};
-const g = async () => 1,
-  h: () => void = async () => {};
+interface ItLike {
+  (name: string, callback: () => Promise<void>): void;
+  (name: string, callback: () => void): void;
+}
+
+declare const it: ItLike;
+
+it('', async () => {});
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'voidReturnVariable',
-        },
-        {
-          line: 6,
-          messageId: 'voidReturnVariable',
-        },
-      ],
     },
     {
       code: `
-const obj: {
-  f?: () => void;
-} = {};
-obj.f = async () => {
-  return 0;
-};
+interface ItLike {
+  (name: string, callback: () => void): void;
+  (name: string, callback: () => Promise<void>): void;
+}
+
+declare const it: ItLike;
+
+it('', async () => {});
       `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'voidReturnVariable',
-        },
-      ],
     },
     {
       code: `
-type O = { f: () => void };
-const obj: O = {
-  f: async () => 'foo',
-};
+interface ItLike {
+  (name: string, callback: () => void): void;
+}
+interface ItLike {
+  (name: string, callback: () => Promise<void>): void;
+}
+
+declare const it: ItLike;
+
+it('', async () => {});
       `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'voidReturnProperty',
-        },
-      ],
     },
     {
       code: `
-type O = { f: () => void };
-const obj: O = {
-  f: async () => 'foo',
-};
+interface ItLike {
+  (name: string, callback: () => Promise<void>): void;
+}
+interface ItLike {
+  (name: string, callback: () => void): void;
+}
+
+declare const it: ItLike;
+
+it('', async () => {});
       `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'voidReturnProperty',
-        },
-      ],
-      options: [{ checksVoidReturn: { properties: true } }],
     },
     {
       code: `
-type O = { f: () => void };
-const f = async () => 0;
-const obj: O = {
-  f,
-};
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'voidReturnProperty',
-        },
-      ],
-    },
-    {
-      code: `
-type O = { f: () => void };
-const obj: O = {
-  async f() {
-    return 0;
-  },
-};
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'voidReturnProperty',
-        },
-      ],
-    },
-    {
-      code: `
-type O = { f: () => void; g: () => void; h: () => void };
-function f(): O {
-  const h = async () => 0;
-  return {
-    async f() {
-      return 123;
-    },
-    g: async () => 0,
-    h,
-  };
-}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnProperty',
-        },
-        {
-          line: 9,
-          messageId: 'voidReturnProperty',
-        },
-        {
-          line: 10,
-          messageId: 'voidReturnProperty',
-        },
-      ],
-    },
-    {
-      code: `
-function f(): () => void {
-  return async () => 0;
-}
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnReturnValue',
-        },
-      ],
-    },
-    {
-      code: `
-function f(): () => void {
-  return async () => 0;
+interface Props {
+  onEvent: (() => void) | (() => Promise<void>);
 }
+
+declare function Component(props: Props): any;
+
+const _ = <Component onEvent={async () => {}} />;
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'voidReturnReturnValue',
-        },
-      ],
-      options: [{ checksVoidReturn: { returns: true } }],
-    },
-    {
-      code: `
-type O = {
-  func: () => void;
-};
-const Component = (obj: O) => null;
-<Component func={async () => 0} />;
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    {
-      code: `
-type O = {
-  func: () => void;
-};
-const Component = (obj: O) => null;
-<Component func={async () => 0} />;
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      options: [{ checksVoidReturn: { attributes: true } }],
-    },
-    {
-      code: `
-type O = {
-  func: () => void;
-};
-const g = async () => 'foo';
-const Component = (obj: O) => null;
-<Component func={g} />;
-      `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'voidReturnAttribute',
-        },
-      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -527,74 +336,33 @@ const Component = (obj: O) => null;
         },
       },
     },
-    {
-      code: `
-interface ItLike {
-  (name: string, callback: () => number): void;
-  (name: string, callback: () => void): void;
-}
-
-declare const it: ItLike;
-
-it('', async () => {});
-      `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-interface ItLike {
-  (name: string, callback: () => number): void;
-}
-interface ItLike {
-  (name: string, callback: () => void): void;
-}
-
-declare const it: ItLike;
-
-it('', async () => {});
-      `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
-    {
-      code: `
-interface ItLike {
-  (name: string, callback: () => void): void;
-}
-interface ItLike {
-  (name: string, callback: () => number): void;
-}
+    `
+console.log({ ...(await Promise.resolve({ key: 42 })) });
+    `,
+    `
+const getData = () => Promise.resolve({ key: 42 });
 
-declare const it: ItLike;
+console.log({
+  someData: 42,
+  ...(await getData()),
+});
+    `,
+    `
+declare const condition: boolean;
 
-it('', async () => {});
-      `,
-      errors: [
-        {
-          line: 11,
-          messageId: 'voidReturnArgument',
-        },
-      ],
-    },
+console.log({ ...(condition && (await Promise.resolve({ key: 42 }))) });
+console.log({ ...(condition || (await Promise.resolve({ key: 42 }))) });
+console.log({ ...(condition ? {} : await Promise.resolve({ key: 42 })) });
+console.log({ ...(condition ? await Promise.resolve({ key: 42 }) : {}) });
+    `,
+    `
+console.log([...(await Promise.resolve(42))]);
+    `,
     {
       code: `
 console.log({ ...Promise.resolve({ key: 42 }) });
       `,
-      errors: [
-        {
-          line: 2,
-          messageId: 'spread',
-        },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
@@ -605,12 +373,7 @@ console.log({
   ...getData(),
 });
       `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'spread',
-        },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
@@ -621,178 +384,161 @@ console.log({ ...(condition || Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? {} : Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? Promise.resolve({ key: 42 }) : {}) });
       `,
-      errors: [
-        { line: 4, messageId: 'spread' },
-        { line: 5, messageId: 'spread' },
-        { line: 6, messageId: 'spread' },
-        { line: 7, messageId: 'spread' },
-      ],
+      options: [{ checksSpreads: false }],
     },
     {
       code: `
-function restPromises(first: Boolean, ...callbacks: Array<() => void>): void {}
+// This is invalid Typescript, but it shouldn't trigger this linter specifically
+console.log([...Promise.resolve(42)]);
+      `,
+      options: [{ checksSpreads: false }],
+    },
+    `
+function spreadAny(..._args: any): void {}
 
-restPromises(
+spreadAny(
   true,
-  () => Promise.resolve(true),
-  () => Promise.resolve(null),
-  () => true,
-  () => Promise.resolve('Hello'),
+  () => Promise.resolve(1),
+  () => Promise.resolve(false),
 );
-      `,
-      errors: [
-        { line: 6, messageId: 'voidReturnArgument' },
-        { line: 7, messageId: 'voidReturnArgument' },
-        { line: 9, messageId: 'voidReturnArgument' },
-      ],
-    },
-    {
-      code: `
-type MyUnion = (() => void) | boolean;
+    `,
+    `
+function spreadArrayAny(..._args: Array<any>): void {}
 
-function restUnion(first: string, ...callbacks: Array<MyUnion>): void {}
-restUnion('Testing', false, () => Promise.resolve(true));
-      `,
-      errors: [{ line: 5, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleOne(first: string, ...callbacks: [() => void]): void {}
-restTupleOne('My string', () => Promise.resolve(1));
-      `,
-      errors: [{ line: 3, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleTwo(
-  first: boolean,
-  ...callbacks: [undefined, () => void, undefined]
-): void {}
+spreadArrayAny(
+  true,
+  () => Promise.resolve(1),
+  () => Promise.resolve(false),
+);
+    `,
+    `
+function spreadArrayUnknown(..._args: Array<unknown>): void {}
 
-restTupleTwo(true, undefined, () => Promise.resolve(true), undefined);
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-function restTupleFour(
-  first: number,
-  ...callbacks: [() => void, boolean, () => void, () => void]
-): void;
+spreadArrayUnknown(() => Promise.resolve(true), 1, 2);
 
-restTupleFour(
-  1,
-  () => Promise.resolve(true),
-  false,
-  () => {},
-  () => Promise.resolve(1),
+function spreadArrayFuncPromise(
+  ..._args: Array<() => Promise<undefined>>
+): void {}
+
+spreadArrayFuncPromise(
+  () => Promise.resolve(undefined),
+  () => Promise.resolve(undefined),
 );
-      `,
-      errors: [
-        { line: 9, messageId: 'voidReturnArgument' },
-        { line: 12, messageId: 'voidReturnArgument' },
-      ],
-    },
-    {
-      // Prettier adds a () but this tests arguments being undefined, not []
-      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
-      code: `
-class TakesVoidCb {
-  constructor(first: string, ...args: Array<() => void>);
+    `,
+    // Prettier adds a () but this tests arguments being undefined, not []
+    // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
+    `
+class TakeCallbacks {
+  constructor(...callbacks: Array<() => void>) {}
 }
 
-new TakesVoidCb;
-new TakesVoidCb();
-new TakesVoidCb(
-  'Testing',
-  () => {},
-  () => Promise.resolve(true),
+new TakeCallbacks;
+new TakeCallbacks();
+new TakeCallbacks(
+  () => 1,
+  () => true,
 );
-      `,
-      errors: [{ line: 11, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
+    `,
+    `
 function restTuple(...args: []): void;
-function restTuple(...args: [boolean, () => void]): void;
-function restTuple(..._args: any[]): void {}
+function restTuple(...args: [string]): void;
+function restTuple(..._args: string[]): void {}
 
 restTuple();
-restTuple(true, () => Promise.resolve(1));
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-type ReturnsRecord = () => Record<string, () => void>;
+restTuple('Hello');
+    `,
+    `
+      let value: Record<string, () => void>;
+      value.sync = () => {};
+    `,
+    `
+      type ReturnsRecord = () => Record<string, () => void>;
 
-const test: ReturnsRecord = () => {
-  return { asynchronous: async () => {} };
-};
-      `,
-      errors: [{ line: 5, messageId: 'voidReturnProperty' }],
-    },
-    {
-      code: `
-let value: Record<string, () => void>;
-value.asynchronous = async () => {};
-      `,
-      errors: [{ line: 3, messageId: 'voidReturnVariable' }],
-    },
-    {
-      code: `
-type ReturnsRecord = () => Record<string, () => void>;
+      const test: ReturnsRecord = () => {
+        return { sync: () => {} };
+      };
+    `,
+    `
+      type ReturnsRecord = () => Record<string, () => void>;
 
-async function asynchronous() {}
+      function sync() {}
 
-const test: ReturnsRecord = () => {
-  return { asynchronous };
-};
-      `,
-      errors: [{ line: 7, messageId: 'voidReturnProperty' }],
-    },
-    {
-      code: `
+      const test: ReturnsRecord = () => {
+        return { sync };
+      };
+    `,
+    `
+      function withTextRecurser<Text extends string>(
+        recurser: (text: Text) => void,
+      ): (text: Text) => void {
+        return (text: Text): void => {
+          if (text.length) {
+            return;
+          }
+
+          return recurser(node);
+        };
+      }
+    `,
+    `
 declare function foo(cb: undefined | (() => void));
-declare const bar: undefined | (() => Promise<void>);
-foo(bar);
-      `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
-    },
-    {
-      code: `
-declare function foo(cb: string & (() => void));
-declare const bar: string & (() => Promise<void>);
+declare const bar: undefined | (() => void);
 foo(bar);
-      `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
-    },
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6637
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs: Array<() => Promise<boolean>> = [
-  () => Promise.resolve(true),
-  () => Promise.resolve(true),
-];
-consume(...cbs);
+        type OnSelectNodeFn = (node: string | null) => void;
+
+        interface ASTViewerBaseProps {
+          readonly onSelectNode?: OnSelectNodeFn;
+        }
+
+        declare function ASTViewer(props: ASTViewerBaseProps): null;
+        declare const onSelectFn: OnSelectNodeFn;
+
+        <ASTViewer onSelectNode={onSelectFn} />;
       `,
-      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+      options: [{ checksVoidReturn: { attributes: true } }],
     },
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)] as const;
-consume(...cbs);
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  setThing(): void {
+    return;
+  }
+}
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-function consume(..._callbacks: Array<() => void>): void {}
-let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)];
-consume(...cbs);
+class MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
+
+class MySubclassExtendsMyClass extends MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
+}
       `,
-      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -808,13 +554,7 @@ class MySubclassExtendsMyClass extends MyClass {
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClass' },
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -825,16 +565,38 @@ class MyClass {
 }
 
 abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): Promise<void>;
+  abstract setThing(): void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClass' },
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+abstract class MyAbstractClassExtendsMyClass extends MyClass {
+  abstract setThing(): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+class MyClass {
+  setThing(): void {
+    return;
+  }
+}
+
+interface MyInterfaceExtendsMyClass extends MyClass {
+  setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -848,13 +610,21 @@ interface MyInterfaceExtendsMyClass extends MyClass {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClass' },
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -868,13 +638,19 @@ class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyAbstractClass' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
+  abstract setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -886,13 +662,19 @@ abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass
   abstract setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyAbstractClass' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+abstract class MyAbstractClass {
+  abstract setThing(): void;
+}
+
+interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
+  setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -904,13 +686,7 @@ interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyAbstractClass' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -918,19 +694,51 @@ interface MyInterface {
   setThing(): void;
 }
 
-class MyInterfaceSubclass implements MyInterface {
+interface MySubInterfaceExtendsMyInterface extends MyInterface {
+  setThing(): void;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+interface MySubInterfaceExtendsMyInterface extends MyInterface {
+  setThing(): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+class MyClassImplementsMyInterface implements MyInterface {
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MyInterface {
+  setThing(): void;
+}
+
+class MyClassImplementsMyInterface implements MyInterface {
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyInterface' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -939,16 +747,10 @@ interface MyInterface {
 }
 
 abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): Promise<void>;
+  abstract setThing(): void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyInterface' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -956,36 +758,49 @@ interface MyInterface {
   setThing(): void;
 }
 
-interface MySubInterface extends MyInterface {
-  setThing(): Promise<void>;
+abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
+  abstract setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyInterface' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
-type MyTypeIntersection = { setThing(): void } & { thing: number };
+type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
 
-class MyClassImplementsMyTypeIntersection implements MyTypeIntersection {
+class MyClass implements MyTypeLiteralsIntersection {
+  thing = 1;
+  setThing(): void {
+    return;
+  }
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
+
+class MyClass implements MyTypeLiteralsIntersection {
   thing = 1;
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyTypeIntersection' },
-          line: 6,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+    },
+    {
+      code: `
+type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
+  ? { setThing(): Promise<void> }
+  : { setThing(): void };
+
+interface MyAsyncInterface extends MyGenericType {
+  setThing(): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -997,13 +812,7 @@ interface MyAsyncInterface extends MyGenericType<false> {
   setThing(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: '{ setThing(): void; }' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: false } }],
     },
     {
       code: `
@@ -1016,21 +825,10 @@ interface MyOtherInterface {
 }
 
 interface MyThirdInterface extends MyInterface, MyOtherInterface {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyInterface' },
-          line: 11,
-          messageId: 'voidReturnInheritedMethod',
-        },
-        {
-          data: { heritageTypeName: 'MyOtherInterface' },
-          line: 11,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1047,29 +845,18 @@ class MyOtherClass {
 }
 
 interface MyInterface extends MyClass, MyOtherClass {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClass' },
-          line: 15,
-          messageId: 'voidReturnInheritedMethod',
-        },
-        {
-          data: { heritageTypeName: 'MyOtherClass' },
-          line: 15,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MyAsyncInterface {
-  setThing(): Promise<void>;
+interface MyInterface {
+  setThing(): void;
 }
 
-interface MySyncInterface {
+interface MyOtherInterface {
   setThing(): void;
 }
 
@@ -1079,44 +866,29 @@ class MyClass {
   }
 }
 
-class MySubclass extends MyClass implements MyAsyncInterface, MySyncInterface {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
+class MySubclass extends MyClass implements MyInterface, MyOtherInterface {
+  setThing(): void {
+    return;
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClass' },
-          line: 17,
-          messageId: 'voidReturnInheritedMethod',
-        },
-        {
-          data: { heritageTypeName: 'MySyncInterface' },
-          line: 17,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
+class MyClass {
+  setThing(): void {
+    return;
+  }
 }
 
-const MyClassExpressionExtendsMyClass = class implements MyInterface {
-  setThing(): Promise<void> {
-    await Promise.resolve();
+const MyClassExpressionExtendsMyClass = class extends MyClass {
+  setThing(): void {
+    return;
   }
 };
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyInterface' },
-          line: 7,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1127,18 +899,12 @@ const MyClassExpression = class {
 };
 
 class MyClassExtendsMyClassExpression extends MyClassExpression {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
+  setThing(): void {
+    return;
   }
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyClassExpression' },
-          line: 9,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1150,43 +916,68 @@ const MyClassExpression = class {
 type MyClassExpressionType = typeof MyClassExpression;
 
 interface MyInterfaceExtendsMyClassExpression extends MyClassExpressionType {
-  setThing(): Promise<void>;
+  setThing(): void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'typeof MyClassExpression' },
-          line: 10,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
-interface MySyncInterface {
+interface MySyncCallSignatures {
+  (): void;
+  (arg: string): void;
+}
+interface MyAsyncInterface extends MySyncCallSignatures {
+  (): Promise<void>;
+  (arg: string): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncConstructSignatures {
+  new (): void;
+  new (arg: string): void;
+}
+interface ThisIsADifferentIssue extends MySyncConstructSignatures {
+  new (): Promise<void>;
+  new (arg: string): Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncIndexSignatures {
+  [key: string]: void;
+  [key: number]: void;
+}
+interface ThisIsADifferentIssue extends MySyncIndexSignatures {
+  [key: string]: Promise<void>;
+  [key: number]: Promise<void>;
+}
+      `,
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+    },
+    {
+      code: `
+interface MySyncInterfaceSignatures {
   (): void;
   (arg: string): void;
   new (): void;
   [key: string]: () => void;
   [key: number]: () => void;
-  myMethod(): void;
 }
-interface MyAsyncInterface extends MySyncInterface {
+interface MyAsyncInterface extends MySyncInterfaceSignatures {
   (): Promise<void>;
   (arg: string): Promise<void>;
   new (): Promise<void>;
   [key: string]: () => Promise<void>;
   [key: number]: () => Promise<void>;
-  myMethod(): Promise<void>;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MySyncInterface' },
-          line: 16,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
     {
       code: `
@@ -1212,49 +1003,37 @@ interface MyMethods {
 }
 interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
   (): void;
-  (arg: string): Promise<void>;
+  (arg: string): void;
   new (): void;
   new (arg: string): void;
-  [key: string]: () => Promise<void>;
+  [key: string]: () => void;
   [key: number]: () => void;
-  doSyncThing(): Promise<void>;
+  doSyncThing(): void;
   doAsyncThing(): Promise<void>;
-  syncMethodProperty: () => Promise<void>;
+  syncMethodProperty: () => void;
 }
       `,
-      errors: [
-        {
-          data: { heritageTypeName: 'MyMethods' },
-          line: 29,
-          messageId: 'voidReturnInheritedMethod',
-        },
-        {
-          data: { heritageTypeName: 'MyMethods' },
-          line: 31,
-          messageId: 'voidReturnInheritedMethod',
-        },
-      ],
+      options: [{ checksVoidReturn: { inheritedMethods: true } }],
     },
+    "const notAFn1: string = '';",
+    'const notAFn2: number = 1;',
+    'const notAFn3: boolean = true;',
+    'const notAFn4: { prop: 1 } = { prop: 1 };',
+    'const notAFn5: {} = {};',
   ],
-
-  valid: [
-    `
-if (true) {
-}
-    `,
+  invalid: [
     {
       code: `
 if (Promise.resolve()) {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+      ],
     },
-    `
-if (true) {
-} else if (false) {
-} else {
-}
-    `,
     {
       code: `
 if (Promise.resolve()) {
@@ -1262,211 +1041,466 @@ if (Promise.resolve()) {
 } else {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'for (;;) {}',
-    'for (let i; i < 10; i++) {}',
     {
       code: 'for (let i; Promise.resolve(); i++) {}',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'do {} while (true);',
     {
       code: 'do {} while (Promise.resolve());',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'while (true) {}',
     {
       code: 'while (Promise.resolve()) {}',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    'true ? 123 : 456;',
     {
       code: 'Promise.resolve() ? 123 : 456;',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    `
-if (!true) {
-}
-    `,
     {
       code: `
 if (!Promise.resolve()) {
 }
       `,
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'conditional',
+        },
+      ],
     },
-    '(await Promise.resolve()) || false;',
     {
       code: 'Promise.resolve() || false;',
-      options: [{ checksConditionals: false }],
+      errors: [
+        {
+          line: 1,
+          messageId: 'conditional',
+        },
+      ],
     },
-    '(true && (await Promise.resolve())) || false;',
     {
-      code: '(true && Promise.resolve()) || false;',
-      options: [{ checksConditionals: false }],
+      code: `
+[Promise.resolve(), Promise.reject()].forEach(async val => {
+  await val;
+});
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
-    'false || (true && Promise.resolve());',
-    '(true && Promise.resolve()) || false;',
-    `
-async function test() {
-  if (await Promise.resolve()) {
-  }
-}
-    `,
-    `
-async function test() {
-  const mixed: Promise | undefined = Promise.resolve();
-  if (mixed) {
-    await mixed;
-  }
-}
-    `,
-    `
-if (~Promise.resolve()) {
-}
-    `,
-    `
-interface NotQuiteThenable {
-  then(param: string): void;
-  then(): void;
-}
-const value: NotQuiteThenable = { then() {} };
-if (value) {
-}
-    `,
-    '[1, 2, 3].forEach(val => {});',
     {
-      code: '[1, 2, 3].forEach(async val => {});',
-      options: [{ checksVoidReturn: false }],
+      code: `
+new Promise(async (resolve, reject) => {
+  await Promise.resolve();
+  resolve();
+});
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
-    'new Promise((resolve, reject) => resolve());',
     {
-      code: 'new Promise(async (resolve, reject) => resolve());',
-      options: [{ checksVoidReturn: false }],
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
+};
+
+fnWithCallback('val', async (err, res) => {
+  await res;
+});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
-    `
-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: { call: () => Promise<void> } | null;
-if (returnsPromise?.call()) {
-}
-    `,
-    'Promise.resolve() ?? false;',
-    `
-function test(a: Promise<void> | undefinded) {
-  const foo = a ?? Promise.reject();
+    {
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
+};
+
+fnWithCallback('val', (err, res) => Promise.resolve(res));
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
+  cb(null, arg);
+};
+
+fnWithCallback('val', (err, res) => {
+  if (err) {
+    return 'abc';
+  } else {
+    return Promise.resolve(res);
+  }
+});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+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: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+const fnWithCallback:
+  | ((arg: string, cb: (err: any, res: string) => void) => void)
+  | null = (arg, cb) => {
+  cb(null, arg);
+};
+
+fnWithCallback('val', (err, res) => {
+  if (err) {
+    return 'abc';
+  } else {
+    return Promise.resolve(res);
+  }
+});
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+function test(bool: boolean, p: Promise<void>) {
+  if (bool || p) {
+  }
 }
-    `,
-    `
-function test(p: Promise<boolean> | undefined, bool: boolean) {
-  if (p ?? bool) {
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
+    },
+    {
+      code: `
+function test(bool: boolean, p: Promise<void>) {
+  if (bool && p) {
   }
 }
-    `,
-    `
-async function test(p: Promise<boolean | undefined>, bool: boolean) {
-  if ((await p) ?? bool) {
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
+    },
+    {
+      code: `
+function test(a: any, p: Promise<void>) {
+  if (a ?? p) {
   }
 }
-    `,
-    `
-async function test(p: Promise<boolean> | undefined) {
-  if (await (p ?? Promise.reject())) {
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
+    },
+    {
+      code: `
+function test(p: Promise<void> | undefined) {
+  if (p ?? Promise.reject()) {
   }
 }
-    `,
-    `
-let f;
-f = async () => 10;
-    `,
-    `
-let f: () => Promise<void>;
-f = async () => 10;
-const g = async () => 0;
-const h: () => Promise<void> = async () => 10;
-    `,
-    `
-const obj = {
-  f: async () => 10,
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'conditional',
+        },
+      ],
+    },
+    {
+      code: `
+let f: () => void;
+f = async () => {
+  return 3;
 };
-    `,
-    `
-const f = async () => 123;
-const obj = {
-  f,
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnVariable',
+        },
+      ],
+    },
+    {
+      code: `
+let f: () => void;
+f = async () => {
+  return 3;
 };
-    `,
-    `
-const obj = {
-  async f() {
-    return 0;
-  },
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnVariable',
+        },
+      ],
+      options: [{ checksVoidReturn: { variables: true } }],
+    },
+    {
+      code: `
+const f: () => void = async () => {
+  return 0;
 };
-    `,
-    `
-type O = { f: () => Promise<void>; g: () => Promise<void> };
-const g = async () => 0;
+const g = async () => 1,
+  h: () => void = async () => {};
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'voidReturnVariable',
+        },
+        {
+          line: 6,
+          messageId: 'voidReturnVariable',
+        },
+      ],
+    },
+    {
+      code: `
+const obj: {
+  f?: () => void;
+} = {};
+obj.f = async () => {
+  return 0;
+};
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'voidReturnVariable',
+        },
+      ],
+    },
+    {
+      code: `
+type O = { f: () => void };
 const obj: O = {
-  f: async () => 10,
-  g,
+  f: async () => 'foo',
 };
-    `,
-    `
-type O = { f: () => Promise<void> };
-const name = 'f';
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+    },
+    {
+      code: `
+type O = { f: () => void };
 const obj: O = {
-  async [name]() {
-    return 10;
-  },
+  f: async () => 'foo',
 };
-    `,
-    `
-const obj: number = {
-  g() {
-    return 10;
-  },
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+      options: [{ checksVoidReturn: { properties: true } }],
+    },
+    {
+      code: `
+type O = { f: () => void };
+const f = async () => 0;
+const obj: O = {
+  f,
 };
-    `,
-    `
-const obj = {
-  f: async () => 'foo',
-  async g() {
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+    },
+    {
+      code: `
+type O = { f: () => void };
+const obj: O = {
+  async f() {
     return 0;
   },
 };
-    `,
-    `
-function f() {
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+    },
+    {
+      code: `
+type O = { f: () => void; g: () => void; h: () => void };
+function f(): O {
+  const h = async () => 0;
+  return {
+    async f() {
+      return 123;
+    },
+    g: async () => 0,
+    h,
+  };
+}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnProperty',
+        },
+        {
+          line: 9,
+          messageId: 'voidReturnProperty',
+        },
+        {
+          line: 10,
+          messageId: 'voidReturnProperty',
+        },
+      ],
+    },
+    {
+      code: `
+function f(): () => void {
   return async () => 0;
 }
-function g() {
-  return;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnReturnValue',
+        },
+      ],
+    },
+    {
+      code: `
+function f(): () => void {
+  return async () => 0;
 }
-    `,
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'voidReturnReturnValue',
+        },
+      ],
+      options: [{ checksVoidReturn: { returns: true } }],
+    },
     {
       code: `
 type O = {
-  bool: boolean;
-  func: () => Promise<void>;
+  func: () => void;
 };
 const Component = (obj: O) => null;
-<Component bool func={async () => 10} />;
+<Component func={async () => 0} />;
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+type O = {
+  func: () => void;
+};
+const Component = (obj: O) => null;
+<Component func={async () => 0} />;
       `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1474,12 +1508,23 @@ const Component = (obj: O) => null;
           },
         },
       },
+      options: [{ checksVoidReturn: { attributes: true } }],
     },
     {
       code: `
-const Component: any = () => null;
-<Component func={async () => 10} />;
+type O = {
+  func: () => void;
+};
+const g = async () => 'foo';
+const Component = (obj: O) => null;
+<Component func={g} />;
       `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'voidReturnAttribute',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1491,7 +1536,7 @@ const Component: any = () => null;
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
+  (name: string, callback: () => number): void;
   (name: string, callback: () => void): void;
 }
 
@@ -1499,92 +1544,63 @@ declare const it: ItLike;
 
 it('', async () => {});
       `,
+      errors: [
+        {
+          line: 9,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => void): void;
-  (name: string, callback: () => Promise<void>): void;
+  (name: string, callback: () => number): void;
 }
-
-declare const it: ItLike;
-
-it('', async () => {});
-      `,
-    },
-    {
-      code: `
 interface ItLike {
   (name: string, callback: () => void): void;
 }
-interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
-}
 
 declare const it: ItLike;
 
 it('', async () => {});
       `,
+      errors: [
+        {
+          line: 11,
+          messageId: 'voidReturnArgument',
+        },
+      ],
     },
     {
       code: `
 interface ItLike {
-  (name: string, callback: () => Promise<void>): void;
+  (name: string, callback: () => void): void;
 }
 interface ItLike {
-  (name: string, callback: () => void): void;
+  (name: string, callback: () => number): void;
 }
 
 declare const it: ItLike;
 
 it('', async () => {});
       `,
-    },
-    {
-      code: `
-interface Props {
-  onEvent: (() => void) | (() => Promise<void>);
-}
-
-declare function Component(props: Props): any;
-
-const _ = <Component onEvent={async () => {}} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          line: 11,
+          messageId: 'voidReturnArgument',
         },
-      },
+      ],
     },
-    `
-console.log({ ...(await Promise.resolve({ key: 42 })) });
-    `,
-    `
-const getData = () => Promise.resolve({ key: 42 });
-
-console.log({
-  someData: 42,
-  ...(await getData()),
-});
-    `,
-    `
-declare const condition: boolean;
-
-console.log({ ...(condition && (await Promise.resolve({ key: 42 }))) });
-console.log({ ...(condition || (await Promise.resolve({ key: 42 }))) });
-console.log({ ...(condition ? {} : await Promise.resolve({ key: 42 })) });
-console.log({ ...(condition ? await Promise.resolve({ key: 42 }) : {}) });
-    `,
-    `
-console.log([...(await Promise.resolve(42))]);
-    `,
     {
       code: `
 console.log({ ...Promise.resolve({ key: 42 }) });
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        {
+          line: 2,
+          messageId: 'spread',
+        },
+      ],
     },
     {
       code: `
@@ -1595,7 +1611,12 @@ console.log({
   ...getData(),
 });
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        {
+          line: 6,
+          messageId: 'spread',
+        },
+      ],
     },
     {
       code: `
@@ -1606,191 +1627,178 @@ console.log({ ...(condition || Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? {} : Promise.resolve({ key: 42 })) });
 console.log({ ...(condition ? Promise.resolve({ key: 42 }) : {}) });
       `,
-      options: [{ checksSpreads: false }],
+      errors: [
+        { line: 4, messageId: 'spread' },
+        { line: 5, messageId: 'spread' },
+        { line: 6, messageId: 'spread' },
+        { line: 7, messageId: 'spread' },
+      ],
     },
     {
       code: `
-// This is invalid Typescript, but it shouldn't trigger this linter specifically
-console.log([...Promise.resolve(42)]);
-      `,
-      options: [{ checksSpreads: false }],
-    },
-    `
-function spreadAny(..._args: any): void {}
-
-spreadAny(
-  true,
-  () => Promise.resolve(1),
-  () => Promise.resolve(false),
-);
-    `,
-    `
-function spreadArrayAny(..._args: Array<any>): void {}
+function restPromises(first: Boolean, ...callbacks: Array<() => void>): void {}
 
-spreadArrayAny(
+restPromises(
   true,
-  () => Promise.resolve(1),
-  () => Promise.resolve(false),
+  () => Promise.resolve(true),
+  () => Promise.resolve(null),
+  () => true,
+  () => Promise.resolve('Hello'),
 );
-    `,
-    `
-function spreadArrayUnknown(..._args: Array<unknown>): void {}
-
-spreadArrayUnknown(() => Promise.resolve(true), 1, 2);
+      `,
+      errors: [
+        { line: 6, messageId: 'voidReturnArgument' },
+        { line: 7, messageId: 'voidReturnArgument' },
+        { line: 9, messageId: 'voidReturnArgument' },
+      ],
+    },
+    {
+      code: `
+type MyUnion = (() => void) | boolean;
 
-function spreadArrayFuncPromise(
-  ..._args: Array<() => Promise<undefined>>
+function restUnion(first: string, ...callbacks: Array<MyUnion>): void {}
+restUnion('Testing', false, () => Promise.resolve(true));
+      `,
+      errors: [{ line: 5, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+function restTupleOne(first: string, ...callbacks: [() => void]): void {}
+restTupleOne('My string', () => Promise.resolve(1));
+      `,
+      errors: [{ line: 3, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+function restTupleTwo(
+  first: boolean,
+  ...callbacks: [undefined, () => void, undefined]
 ): void {}
 
-spreadArrayFuncPromise(
-  () => Promise.resolve(undefined),
-  () => Promise.resolve(undefined),
+restTupleTwo(true, undefined, () => Promise.resolve(true), undefined);
+      `,
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+function restTupleFour(
+  first: number,
+  ...callbacks: [() => void, boolean, () => void, () => void]
+): void;
+
+restTupleFour(
+  1,
+  () => Promise.resolve(true),
+  false,
+  () => {},
+  () => Promise.resolve(1),
 );
-    `,
-    // Prettier adds a () but this tests arguments being undefined, not []
-    // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
-    `
-class TakeCallbacks {
-  constructor(...callbacks: Array<() => void>) {}
+      `,
+      errors: [
+        { line: 9, messageId: 'voidReturnArgument' },
+        { line: 12, messageId: 'voidReturnArgument' },
+      ],
+    },
+    {
+      // Prettier adds a () but this tests arguments being undefined, not []
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
+      code: `
+class TakesVoidCb {
+  constructor(first: string, ...args: Array<() => void>);
 }
 
-new TakeCallbacks;
-new TakeCallbacks();
-new TakeCallbacks(
-  () => 1,
-  () => true,
+new TakesVoidCb;
+new TakesVoidCb();
+new TakesVoidCb(
+  'Testing',
+  () => {},
+  () => Promise.resolve(true),
 );
-    `,
-    `
+      `,
+      errors: [{ line: 11, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
 function restTuple(...args: []): void;
-function restTuple(...args: [string]): void;
-function restTuple(..._args: string[]): void {}
-
-restTuple();
-restTuple('Hello');
-    `,
-    `
-      let value: Record<string, () => void>;
-      value.sync = () => {};
-    `,
-    `
-      type ReturnsRecord = () => Record<string, () => void>;
-
-      const test: ReturnsRecord = () => {
-        return { sync: () => {} };
-      };
-    `,
-    `
-      type ReturnsRecord = () => Record<string, () => void>;
-
-      function sync() {}
-
-      const test: ReturnsRecord = () => {
-        return { sync };
-      };
-    `,
-    `
-      function withTextRecurser<Text extends string>(
-        recurser: (text: Text) => void,
-      ): (text: Text) => void {
-        return (text: Text): void => {
-          if (text.length) {
-            return;
-          }
+function restTuple(...args: [boolean, () => void]): void;
+function restTuple(..._args: any[]): void {}
 
-          return recurser(node);
-        };
-      }
-    `,
-    `
-declare function foo(cb: undefined | (() => void));
-declare const bar: undefined | (() => void);
-foo(bar);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6637
+restTuple();
+restTuple(true, () => Promise.resolve(1));
+      `,
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
+    },
     {
       code: `
-        type OnSelectNodeFn = (node: string | null) => void;
+type ReturnsRecord = () => Record<string, () => void>;
 
-        interface ASTViewerBaseProps {
-          readonly onSelectNode?: OnSelectNodeFn;
-        }
+const test: ReturnsRecord = () => {
+  return { asynchronous: async () => {} };
+};
+      `,
+      errors: [{ line: 5, messageId: 'voidReturnProperty' }],
+    },
+    {
+      code: `
+let value: Record<string, () => void>;
+value.asynchronous = async () => {};
+      `,
+      errors: [{ line: 3, messageId: 'voidReturnVariable' }],
+    },
+    {
+      code: `
+type ReturnsRecord = () => Record<string, () => void>;
 
-        declare function ASTViewer(props: ASTViewerBaseProps): null;
-        declare const onSelectFn: OnSelectNodeFn;
+async function asynchronous() {}
 
-        <ASTViewer onSelectNode={onSelectFn} />;
+const test: ReturnsRecord = () => {
+  return { asynchronous };
+};
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-      options: [{ checksVoidReturn: { attributes: true } }],
+      errors: [{ line: 7, messageId: 'voidReturnProperty' }],
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  setThing(): void {
-    return;
-  }
-}
+declare function foo(cb: undefined | (() => void));
+declare const bar: undefined | (() => Promise<void>);
+foo(bar);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-class MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
+declare function foo(cb: string & (() => void));
+declare const bar: string & (() => Promise<void>);
+foo(bar);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-class MySubclassExtendsMyClass extends MyClass {
-  async setThing(): Promise<void> {
-    await Promise.resolve();
-  }
-}
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs: Array<() => Promise<boolean>> = [
+  () => Promise.resolve(true),
+  () => Promise.resolve(true),
+];
+consume(...cbs);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [{ line: 7, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
-}
-
-abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): void;
-}
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)] as const;
+consume(...cbs);
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
+    },
+    {
+      code: `
+function consume(..._callbacks: Array<() => void>): void {}
+let cbs = [() => Promise.resolve(true), () => Promise.resolve(true)];
+consume(...cbs);
+      `,
+      errors: [{ line: 4, messageId: 'voidReturnArgument' }],
     },
     {
       code: `
@@ -1800,11 +1808,19 @@ class MyClass {
   }
 }
 
-abstract class MyAbstractClassExtendsMyClass extends MyClass {
-  abstract setThing(): Promise<void>;
+class MySubclassExtendsMyClass extends MyClass {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
+  }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1814,11 +1830,17 @@ class MyClass {
   }
 }
 
-interface MyInterfaceExtendsMyClass extends MyClass {
-  setThing(): void;
+abstract class MyAbstractClassExtendsMyClass extends MyClass {
+  abstract setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1832,21 +1854,13 @@ interface MyInterfaceExtendsMyClass extends MyClass {
   setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
-  setThing(): void {
-    return;
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClass' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1860,19 +1874,13 @@ class MySubclassExtendsMyAbstractClass extends MyAbstractClass {
   }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass {
-  abstract setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1884,19 +1892,13 @@ abstract class MyAbstractSubclassExtendsMyAbstractClass extends MyAbstractClass
   abstract setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-abstract class MyAbstractClass {
-  abstract setThing(): void;
-}
-
-interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1908,45 +1910,13 @@ interface MyInterfaceExtendsMyAbstractClass extends MyAbstractClass {
   setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-interface MySubInterfaceExtendsMyInterface extends MyInterface {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-interface MySubInterfaceExtendsMyInterface extends MyInterface {
-  setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-interface MyInterface {
-  setThing(): void;
-}
-
-class MyClassImplementsMyInterface implements MyInterface {
-  setThing(): void {
-    return;
-  }
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyAbstractClass' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1954,13 +1924,19 @@ interface MyInterface {
   setThing(): void;
 }
 
-class MyClassImplementsMyInterface implements MyInterface {
+class MyInterfaceSubclass implements MyInterface {
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1969,10 +1945,16 @@ interface MyInterface {
 }
 
 abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): void;
+  abstract setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -1980,49 +1962,36 @@ interface MyInterface {
   setThing(): void;
 }
 
-abstract class MyAbstractClassImplementsMyInterface implements MyInterface {
-  abstract setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
-
-class MyClass implements MyTypeLiteralsIntersection {
-  thing = 1;
-  setThing(): void {
-    return;
-  }
+interface MySubInterface extends MyInterface {
+  setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
-type MyTypeLiteralsIntersection = { setThing(): void } & { thing: number };
+type MyTypeIntersection = { setThing(): void } & { thing: number };
 
-class MyClass implements MyTypeLiteralsIntersection {
+class MyClassImplementsMyTypeIntersection implements MyTypeIntersection {
   thing = 1;
   async setThing(): Promise<void> {
     await Promise.resolve();
   }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
-    },
-    {
-      code: `
-type MyGenericType<IsAsync extends boolean = true> = IsAsync extends true
-  ? { setThing(): Promise<void> }
-  : { setThing(): void };
-
-interface MyAsyncInterface extends MyGenericType {
-  setThing(): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyTypeIntersection' },
+          line: 6,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2034,7 +2003,13 @@ interface MyAsyncInterface extends MyGenericType<false> {
   setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: false } }],
+      errors: [
+        {
+          data: { heritageTypeName: '{ setThing(): void; }' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2047,10 +2022,21 @@ interface MyOtherInterface {
 }
 
 interface MyThirdInterface extends MyInterface, MyOtherInterface {
-  setThing(): void;
+  setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyInterface' },
+          line: 11,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MyOtherInterface' },
+          line: 11,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2067,18 +2053,29 @@ class MyOtherClass {
 }
 
 interface MyInterface extends MyClass, MyOtherClass {
-  setThing(): void;
+  setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClass' },
+          line: 15,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MyOtherClass' },
+          line: 15,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
-interface MyInterface {
-  setThing(): void;
+interface MyAsyncInterface {
+  setThing(): Promise<void>;
 }
 
-interface MyOtherInterface {
+interface MySyncInterface {
   setThing(): void;
 }
 
@@ -2088,29 +2085,44 @@ class MyClass {
   }
 }
 
-class MySubclass extends MyClass implements MyInterface, MyOtherInterface {
-  setThing(): void {
-    return;
+class MySubclass extends MyClass implements MyAsyncInterface, MySyncInterface {
+  async setThing(): Promise<void> {
+    await Promise.resolve();
   }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClass' },
+          line: 17,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MySyncInterface' },
+          line: 17,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
-class MyClass {
-  setThing(): void {
-    return;
-  }
+interface MyInterface {
+  setThing(): void;
 }
 
-const MyClassExpressionExtendsMyClass = class extends MyClass {
-  setThing(): void {
-    return;
+const MyClassExpressionExtendsMyClass = class implements MyInterface {
+  setThing(): Promise<void> {
+    await Promise.resolve();
   }
 };
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyInterface' },
+          line: 7,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2121,12 +2133,18 @@ const MyClassExpression = class {
 };
 
 class MyClassExtendsMyClassExpression extends MyClassExpression {
-  setThing(): void {
-    return;
+  async setThing(): Promise<void> {
+    await Promise.resolve();
   }
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyClassExpression' },
+          line: 9,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2138,68 +2156,43 @@ const MyClassExpression = class {
 type MyClassExpressionType = typeof MyClassExpression;
 
 interface MyInterfaceExtendsMyClassExpression extends MyClassExpressionType {
-  setThing(): void;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-interface MySyncCallSignatures {
-  (): void;
-  (arg: string): void;
-}
-interface MyAsyncInterface extends MySyncCallSignatures {
-  (): Promise<void>;
-  (arg: string): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-interface MySyncConstructSignatures {
-  new (): void;
-  new (arg: string): void;
-}
-interface ThisIsADifferentIssue extends MySyncConstructSignatures {
-  new (): Promise<void>;
-  new (arg: string): Promise<void>;
-}
-      `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
-    },
-    {
-      code: `
-interface MySyncIndexSignatures {
-  [key: string]: void;
-  [key: number]: void;
-}
-interface ThisIsADifferentIssue extends MySyncIndexSignatures {
-  [key: string]: Promise<void>;
-  [key: number]: Promise<void>;
+  setThing(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'typeof MyClassExpression' },
+          line: 10,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
-interface MySyncInterfaceSignatures {
+interface MySyncInterface {
   (): void;
   (arg: string): void;
   new (): void;
   [key: string]: () => void;
   [key: number]: () => void;
+  myMethod(): void;
 }
-interface MyAsyncInterface extends MySyncInterfaceSignatures {
+interface MyAsyncInterface extends MySyncInterface {
   (): Promise<void>;
   (arg: string): Promise<void>;
   new (): Promise<void>;
   [key: string]: () => Promise<void>;
   [key: number]: () => Promise<void>;
+  myMethod(): Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MySyncInterface' },
+          line: 16,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
     {
       code: `
@@ -2225,22 +2218,28 @@ interface MyMethods {
 }
 interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
   (): void;
-  (arg: string): void;
+  (arg: string): Promise<void>;
   new (): void;
   new (arg: string): void;
-  [key: string]: () => void;
+  [key: string]: () => Promise<void>;
   [key: number]: () => void;
-  doSyncThing(): void;
+  doSyncThing(): Promise<void>;
   doAsyncThing(): Promise<void>;
-  syncMethodProperty: () => void;
+  syncMethodProperty: () => Promise<void>;
 }
       `,
-      options: [{ checksVoidReturn: { inheritedMethods: true } }],
+      errors: [
+        {
+          data: { heritageTypeName: 'MyMethods' },
+          line: 29,
+          messageId: 'voidReturnInheritedMethod',
+        },
+        {
+          data: { heritageTypeName: 'MyMethods' },
+          line: 31,
+          messageId: 'voidReturnInheritedMethod',
+        },
+      ],
     },
-    "const notAFn1: string = '';",
-    'const notAFn2: number = 1;',
-    'const notAFn3: boolean = true;',
-    'const notAFn4: { prop: 1 } = { prop: 1 };',
-    'const notAFn5: {} = {};',
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts b/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
index 047563ed471e..603afa4fc0d5 100644
--- a/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
@@ -14,6 +14,246 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-mixed-enums', rule, {
+  valid: [
+    `
+      enum Fruit {}
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = false,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = 0,
+        Banana,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana = 1,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple = 0,
+        Banana = 1,
+      }
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana = false,
+      }
+    `,
+    `
+      const getValue = () => 0;
+      enum Fruit {
+        Apple,
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => 0;
+      enum Fruit {
+        Apple = getValue(),
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = '',
+        Banana = getValue(),
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = getValue(),
+        Banana = '',
+      }
+    `,
+    `
+      const getValue = () => '';
+      enum Fruit {
+        Apple = getValue(),
+        Banana = getValue(),
+      }
+    `,
+    `
+      enum First {
+        A = 1,
+      }
+
+      enum Second {
+        A = First.A,
+        B = 2,
+      }
+    `,
+    `
+      enum First {
+        A = '',
+      }
+
+      enum Second {
+        A = First.A,
+        B = 'b',
+      }
+    `,
+    `
+      enum Foo {
+        A,
+      }
+      enum Foo {
+        B,
+      }
+    `,
+    `
+      enum Foo {
+        A = 0,
+      }
+      enum Foo {
+        B,
+      }
+    `,
+    `
+      enum Foo {
+        A,
+      }
+      enum Foo {
+        B = 1,
+      }
+    `,
+    `
+      enum Foo {
+        A = 0,
+      }
+      enum Foo {
+        B = 1,
+      }
+    `,
+    `
+      enum Foo {
+        A = 'a',
+      }
+      enum Foo {
+        B = 'b',
+      }
+    `,
+    `
+      declare const Foo: any;
+      enum Foo {
+        A,
+      }
+    `,
+    `
+enum Foo {
+  A = 1,
+}
+enum Foo {
+  B = 2,
+}
+    `,
+    `
+enum Foo {
+  A = \`A\`,
+}
+enum Foo {
+  B = \`B\`,
+}
+    `,
+    `
+enum Foo {
+  A = false, // (TS error)
+}
+enum Foo {
+  B = \`B\`,
+}
+    `,
+    `
+enum Foo {
+  A = 'A',
+}
+enum Foo {
+  B = false, // (TS error)
+}
+    `,
+    `
+import { Enum } from './mixed-enums-decl';
+
+declare module './mixed-enums-decl' {
+  enum Enum {
+    StringLike = 'StringLike',
+  }
+}
+    `,
+    `
+import { Enum } from "module-that-does't-exist";
+
+declare module "module-that-doesn't-exist" {
+  enum Enum {
+    StringLike = 'StringLike',
+  }
+}
+    `,
+    `
+namespace Test {
+  export enum Bar {
+    A = 1,
+  }
+}
+namespace Test {
+  export enum Bar {
+    B = 2,
+  }
+}
+    `,
+    `
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      A = 1,
+    }
+  }
+}
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      B = 'B',
+    }
+  }
+}
+    `,
+    `
+namespace Outer {
+  namespace Test {
+    export enum Bar {
+      A = 1,
+    }
+  }
+}
+namespace Different {
+  namespace Test {
+    export enum Bar {
+      B = 'B',
+    }
+  }
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -421,244 +661,4 @@ namespace Outer {
       ],
     },
   ],
-  valid: [
-    `
-      enum Fruit {}
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = false,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = 0,
-        Banana,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana = 1,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple = 0,
-        Banana = 1,
-      }
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana = false,
-      }
-    `,
-    `
-      const getValue = () => 0;
-      enum Fruit {
-        Apple,
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => 0;
-      enum Fruit {
-        Apple = getValue(),
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = '',
-        Banana = getValue(),
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = getValue(),
-        Banana = '',
-      }
-    `,
-    `
-      const getValue = () => '';
-      enum Fruit {
-        Apple = getValue(),
-        Banana = getValue(),
-      }
-    `,
-    `
-      enum First {
-        A = 1,
-      }
-
-      enum Second {
-        A = First.A,
-        B = 2,
-      }
-    `,
-    `
-      enum First {
-        A = '',
-      }
-
-      enum Second {
-        A = First.A,
-        B = 'b',
-      }
-    `,
-    `
-      enum Foo {
-        A,
-      }
-      enum Foo {
-        B,
-      }
-    `,
-    `
-      enum Foo {
-        A = 0,
-      }
-      enum Foo {
-        B,
-      }
-    `,
-    `
-      enum Foo {
-        A,
-      }
-      enum Foo {
-        B = 1,
-      }
-    `,
-    `
-      enum Foo {
-        A = 0,
-      }
-      enum Foo {
-        B = 1,
-      }
-    `,
-    `
-      enum Foo {
-        A = 'a',
-      }
-      enum Foo {
-        B = 'b',
-      }
-    `,
-    `
-      declare const Foo: any;
-      enum Foo {
-        A,
-      }
-    `,
-    `
-enum Foo {
-  A = 1,
-}
-enum Foo {
-  B = 2,
-}
-    `,
-    `
-enum Foo {
-  A = \`A\`,
-}
-enum Foo {
-  B = \`B\`,
-}
-    `,
-    `
-enum Foo {
-  A = false, // (TS error)
-}
-enum Foo {
-  B = \`B\`,
-}
-    `,
-    `
-enum Foo {
-  A = 'A',
-}
-enum Foo {
-  B = false, // (TS error)
-}
-    `,
-    `
-import { Enum } from './mixed-enums-decl';
-
-declare module './mixed-enums-decl' {
-  enum Enum {
-    StringLike = 'StringLike',
-  }
-}
-    `,
-    `
-import { Enum } from "module-that-does't-exist";
-
-declare module "module-that-doesn't-exist" {
-  enum Enum {
-    StringLike = 'StringLike',
-  }
-}
-    `,
-    `
-namespace Test {
-  export enum Bar {
-    A = 1,
-  }
-}
-namespace Test {
-  export enum Bar {
-    B = 2,
-  }
-}
-    `,
-    `
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      A = 1,
-    }
-  }
-}
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      B = 'B',
-    }
-  }
-}
-    `,
-    `
-namespace Outer {
-  namespace Test {
-    export enum Bar {
-      A = 1,
-    }
-  }
-}
-namespace Different {
-  namespace Test {
-    export enum Bar {
-      B = 'B',
-    }
-  }
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-namespace.test.ts b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
index 00b032640b7e..81e6d075d8b9 100644
--- a/packages/eslint-plugin/tests/rules/no-namespace.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
@@ -5,6 +5,74 @@ import rule from '../../src/rules/no-namespace';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-namespace', rule, {
+  valid: [
+    'declare global {}',
+    "declare module 'foo' {}",
+    {
+      code: 'declare module foo {}',
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: 'declare namespace foo {}',
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare global {
+  namespace foo {}
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare module foo {
+  namespace bar {}
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare global {
+  namespace foo {
+    namespace bar {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+declare namespace foo {
+  namespace bar {
+    namespace baz {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: `
+export declare namespace foo {
+  export namespace bar {
+    namespace baz {}
+  }
+}
+      `,
+      options: [{ allowDeclarations: true }],
+    },
+    {
+      code: 'namespace foo {}',
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: true }],
+    },
+    {
+      code: 'module foo {}',
+      filename: 'test.d.ts',
+      options: [{ allowDefinitionFiles: true }],
+    },
+  ],
   invalid: [
     {
       code: 'module foo {}',
@@ -495,72 +563,4 @@ export namespace A {
       options: [{ allowDeclarations: true }],
     },
   ],
-  valid: [
-    'declare global {}',
-    "declare module 'foo' {}",
-    {
-      code: 'declare module foo {}',
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: 'declare namespace foo {}',
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare global {
-  namespace foo {}
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare module foo {
-  namespace bar {}
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare global {
-  namespace foo {
-    namespace bar {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-declare namespace foo {
-  namespace bar {
-    namespace baz {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: `
-export declare namespace foo {
-  export namespace bar {
-    namespace baz {}
-  }
-}
-      `,
-      options: [{ allowDeclarations: true }],
-    },
-    {
-      code: 'namespace foo {}',
-      filename: 'test.d.ts',
-      options: [{ allowDefinitionFiles: true }],
-    },
-    {
-      code: 'module foo {}',
-      filename: 'test.d.ts',
-      options: [{ allowDefinitionFiles: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts b/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
index 248888f4db8c..861cae23de9f 100644
--- a/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-non-null-asserted-nullish-coalescing.test.ts
@@ -5,6 +5,61 @@ import rule from '../../src/rules/no-non-null-asserted-nullish-coalescing';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-nullish-coalescing', rule, {
+  valid: [
+    'foo ?? bar;',
+    'foo ?? bar!;',
+    'foo.bazz ?? bar;',
+    'foo.bazz ?? bar!;',
+    'foo!.bazz ?? bar;',
+    'foo!.bazz ?? bar!;',
+    'foo() ?? bar;',
+    'foo() ?? bar!;',
+    '(foo ?? bar)!;',
+    `
+      let x: string;
+      x! ?? '';
+    `,
+    `
+      let x: string;
+      x ?? '';
+    `,
+    `
+      let x!: string;
+      x ?? '';
+    `,
+    `
+      let x: string;
+      foo(x);
+      x! ?? '';
+    `,
+    `
+      let x: string;
+      x! ?? '';
+      x = foo();
+    `,
+    `
+      let x: string;
+      foo(x);
+      x! ?? '';
+      x = foo();
+    `,
+    `
+      let x = foo();
+      x ?? '';
+    `,
+    `
+      function foo() {
+        let x: string;
+        return x ?? '';
+      }
+    `,
+    `
+      let x: string;
+      function foo() {
+        return x ?? '';
+      }
+    `,
+  ],
   invalid: [
     {
       code: 'foo! ?? bar;',
@@ -273,59 +328,4 @@ x   ?? '';
       ],
     },
   ],
-  valid: [
-    'foo ?? bar;',
-    'foo ?? bar!;',
-    'foo.bazz ?? bar;',
-    'foo.bazz ?? bar!;',
-    'foo!.bazz ?? bar;',
-    'foo!.bazz ?? bar!;',
-    'foo() ?? bar;',
-    'foo() ?? bar!;',
-    '(foo ?? bar)!;',
-    `
-      let x: string;
-      x! ?? '';
-    `,
-    `
-      let x: string;
-      x ?? '';
-    `,
-    `
-      let x!: string;
-      x ?? '';
-    `,
-    `
-      let x: string;
-      foo(x);
-      x! ?? '';
-    `,
-    `
-      let x: string;
-      x! ?? '';
-      x = foo();
-    `,
-    `
-      let x: string;
-      foo(x);
-      x! ?? '';
-      x = foo();
-    `,
-    `
-      let x = foo();
-      x ?? '';
-    `,
-    `
-      function foo() {
-        let x: string;
-        return x ?? '';
-      }
-    `,
-    `
-      let x: string;
-      function foo() {
-        return x ?? '';
-      }
-    `,
-  ],
 });
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 865dadb2c33c..27b27ac07a8c 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
@@ -5,6 +5,21 @@ import rule from '../../src/rules/no-non-null-asserted-optional-chain';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-optional-chain', rule, {
+  valid: [
+    'foo.bar!;',
+    'foo.bar!.baz;',
+    'foo.bar!.baz();',
+    'foo.bar()!;',
+    'foo.bar()!();',
+    'foo.bar()!.baz;',
+    'foo?.bar;',
+    'foo?.bar();',
+    '(foo?.bar).baz!;',
+    '(foo?.bar()).baz!;',
+    'foo?.bar!.baz;',
+    'foo?.bar!();',
+    "foo?.['bar']!.baz;",
+  ],
   invalid: [
     {
       code: 'foo?.bar!;',
@@ -147,19 +162,4 @@ ruleTester.run('no-non-null-asserted-optional-chain', rule, {
       ],
     },
   ],
-  valid: [
-    'foo.bar!;',
-    'foo.bar!.baz;',
-    'foo.bar!.baz();',
-    'foo.bar()!;',
-    'foo.bar()!();',
-    'foo.bar()!.baz;',
-    'foo?.bar;',
-    'foo?.bar();',
-    '(foo?.bar).baz!;',
-    '(foo?.bar()).baz!;',
-    'foo?.bar!.baz;',
-    'foo?.bar!();',
-    "foo?.['bar']!.baz;",
-  ],
 });
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 2a8eeae99d1b..98dde42f9943 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
@@ -5,6 +5,15 @@ import rule from '../../src/rules/no-non-null-assertion';
 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;',
+  ],
   invalid: [
     {
       code: 'x!;',
@@ -379,13 +388,4 @@ x?.
       ],
     },
   ],
-  valid: [
-    //
-    'x;',
-    'x.y;',
-    'x.y.z;',
-    'x?.y.z;',
-    'x?.y?.z;',
-    '!x;',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
index 24237910a6c2..3d2f55e1d4e1 100644
--- a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
@@ -13,6 +13,136 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-redeclare', rule, {
+  valid: [
+    `
+var a = 3;
+var b = function () {
+  var a = 10;
+};
+    `,
+    `
+var a = 3;
+a = 10;
+    `,
+    {
+      code: `
+if (true) {
+  let b = 2;
+} else {
+  let b = 3;
+}
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaVersion: 6,
+        },
+      },
+    },
+    { code: 'var Object = 0;', options: [{ builtinGlobals: false }] },
+    {
+      code: 'var Object = 0;',
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var Object = 0;',
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var top = 0;',
+      options: [{ builtinGlobals: false }],
+    },
+    { code: 'var top = 0;', options: [{ builtinGlobals: true }] },
+    {
+      code: 'var top = 0;',
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var top = 0;',
+      languageOptions: { parserOptions: { sourceType: 'module' } },
+      options: [{ builtinGlobals: true }],
+    },
+    {
+      code: 'var self = 1;',
+      options: [{ builtinGlobals: true }],
+    },
+    // https://github.com/eslint/typescript-eslint-parser/issues/535
+    `
+function foo({ bar }: { bar: string }) {
+  console.log(bar);
+}
+    `,
+    `
+type AST<T extends ParserOptions> = TSESTree.Program &
+  (T['range'] extends true ? { range: [number, number] } : {}) &
+  (T['tokens'] extends true ? { tokens: TSESTree.Token[] } : {}) &
+  (T['comment'] extends true ? { comments: TSESTree.Comment[] } : {});
+interface ParseAndGenerateServicesResult<T extends ParserOptions> {
+  ast: AST<T>;
+  services: ParserServices;
+}
+    `,
+    `
+function A<T>() {}
+interface B<T> {}
+type C<T> = Array<T>;
+class D<T> {}
+    `,
+    `
+function a(): string;
+function a(): number;
+function a() {}
+    `,
+    {
+      code: `
+interface A {}
+interface A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+interface A {}
+class A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+class A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+interface A {}
+class A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+enum A {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+    {
+      code: `
+function A() {}
+namespace A {}
+      `,
+      options: [{ ignoreDeclarationMerge: true }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -548,134 +678,4 @@ const something = 2;
       ],
     },
   ],
-  valid: [
-    `
-var a = 3;
-var b = function () {
-  var a = 10;
-};
-    `,
-    `
-var a = 3;
-a = 10;
-    `,
-    {
-      code: `
-if (true) {
-  let b = 2;
-} else {
-  let b = 3;
-}
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaVersion: 6,
-        },
-      },
-    },
-    { code: 'var Object = 0;', options: [{ builtinGlobals: false }] },
-    {
-      code: 'var Object = 0;',
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-      options: [{ builtinGlobals: true }],
-    },
-    {
-      code: 'var Object = 0;',
-      languageOptions: {
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-      options: [{ builtinGlobals: true }],
-    },
-    {
-      code: 'var top = 0;',
-      options: [{ builtinGlobals: false }],
-    },
-    { code: 'var top = 0;', options: [{ builtinGlobals: true }] },
-    {
-      code: 'var top = 0;',
-      languageOptions: {
-        parserOptions: { ecmaFeatures: { globalReturn: true } },
-      },
-      options: [{ builtinGlobals: true }],
-    },
-    {
-      code: 'var top = 0;',
-      languageOptions: { parserOptions: { sourceType: 'module' } },
-      options: [{ builtinGlobals: true }],
-    },
-    {
-      code: 'var self = 1;',
-      options: [{ builtinGlobals: true }],
-    },
-    // https://github.com/eslint/typescript-eslint-parser/issues/535
-    `
-function foo({ bar }: { bar: string }) {
-  console.log(bar);
-}
-    `,
-    `
-type AST<T extends ParserOptions> = TSESTree.Program &
-  (T['range'] extends true ? { range: [number, number] } : {}) &
-  (T['tokens'] extends true ? { tokens: TSESTree.Token[] } : {}) &
-  (T['comment'] extends true ? { comments: TSESTree.Comment[] } : {});
-interface ParseAndGenerateServicesResult<T extends ParserOptions> {
-  ast: AST<T>;
-  services: ParserServices;
-}
-    `,
-    `
-function A<T>() {}
-interface B<T> {}
-type C<T> = Array<T>;
-class D<T> {}
-    `,
-    `
-function a(): string;
-function a(): number;
-function a() {}
-    `,
-    {
-      code: `
-interface A {}
-interface A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-interface A {}
-class A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-class A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-interface A {}
-class A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-enum A {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-    {
-      code: `
-function A() {}
-namespace A {}
-      `,
-      options: [{ ignoreDeclarationMerge: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
index 6e87f14f9235..3bd7fdb792cc 100644
--- a/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts
@@ -14,6 +14,158 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-redundant-type-constituents', rule, {
+  valid: [
+    `
+      type T = any;
+      type U = T;
+    `,
+    `
+      type T = never;
+      type U = T;
+    `,
+    `
+      type T = 1 | 2;
+      type U = T | 3;
+      type V = U;
+    `,
+    'type T = () => never;',
+    'type T = () => never | string;',
+    `
+      type B = never;
+      type T = () => B | string;
+    `,
+    `
+      type B = string;
+      type T = () => B | never;
+    `,
+    'type T = () => string | never;',
+    'type T = { (): string | never };',
+    `
+      function _(): string | never {
+        return '';
+      }
+    `,
+    `
+      const _ = (): string | never => {
+        return '';
+      };
+    `,
+    `
+      type B = string;
+      type T = { (): B | never };
+    `,
+    'type T = { new (): string | never };',
+    `
+      type B = never;
+      type T = { new (): string | B };
+    `,
+    `
+      type B = unknown;
+      type T = B;
+    `,
+    'type T = bigint;',
+    `
+      type B = bigint;
+      type T = B;
+    `,
+    'type T = 1n | 2n;',
+    `
+      type B = 1n;
+      type T = B | 2n;
+    `,
+    'type T = boolean;',
+    `
+      type B = boolean;
+      type T = B;
+    `,
+    'type T = false | true;',
+    `
+      type B = false;
+      type T = B | true;
+    `,
+    `
+      type B = true;
+      type T = B | false;
+    `,
+    'type T = number;',
+    `
+      type B = number;
+      type T = B;
+    `,
+    'type T = 1 | 2;',
+    `
+      type B = 1;
+      type T = B | 2;
+    `,
+    'type T = 1 | false;',
+    `
+      type B = 1;
+      type T = B | false;
+    `,
+    'type T = string;',
+    `
+      type B = string;
+      type T = B;
+    `,
+    "type T = 'a' | 'b';",
+    `
+      type B = 'b';
+      type T = 'a' | B;
+    `,
+    `
+      type B = 'a';
+      type T = B | 'b';
+    `,
+    'type T = bigint | null;',
+    `
+      type B = bigint;
+      type T = B | null;
+    `,
+    'type T = boolean | null;',
+    `
+      type B = boolean;
+      type T = B | null;
+    `,
+    'type T = number | null;',
+    `
+      type B = number;
+      type T = B | null;
+    `,
+    'type T = string | null;',
+    `
+      type B = string;
+      type T = B | null;
+    `,
+    'type T = bigint & null;',
+    `
+      type B = bigint;
+      type T = B & null;
+    `,
+    'type T = boolean & null;',
+    `
+      type B = boolean;
+      type T = B & null;
+    `,
+    'type T = number & null;',
+    `
+      type B = number;
+      type T = B & null;
+    `,
+    'type T = string & null;',
+    `
+      type B = string;
+      type T = B & null;
+    `,
+    'type T = `${string}` & null;',
+    `
+      type B = \`\${string}\`;
+      type T = B & null;
+    `,
+    `
+      type T = 'a' | 1 | 'b';
+      type U = T & string;
+    `,
+  ],
   invalid: [
     {
       code: 'type T = number | any;',
@@ -704,157 +856,4 @@ ruleTester.run('no-redundant-type-constituents', rule, {
       ],
     },
   ],
-
-  valid: [
-    `
-      type T = any;
-      type U = T;
-    `,
-    `
-      type T = never;
-      type U = T;
-    `,
-    `
-      type T = 1 | 2;
-      type U = T | 3;
-      type V = U;
-    `,
-    'type T = () => never;',
-    'type T = () => never | string;',
-    `
-      type B = never;
-      type T = () => B | string;
-    `,
-    `
-      type B = string;
-      type T = () => B | never;
-    `,
-    'type T = () => string | never;',
-    'type T = { (): string | never };',
-    `
-      function _(): string | never {
-        return '';
-      }
-    `,
-    `
-      const _ = (): string | never => {
-        return '';
-      };
-    `,
-    `
-      type B = string;
-      type T = { (): B | never };
-    `,
-    'type T = { new (): string | never };',
-    `
-      type B = never;
-      type T = { new (): string | B };
-    `,
-    `
-      type B = unknown;
-      type T = B;
-    `,
-    'type T = bigint;',
-    `
-      type B = bigint;
-      type T = B;
-    `,
-    'type T = 1n | 2n;',
-    `
-      type B = 1n;
-      type T = B | 2n;
-    `,
-    'type T = boolean;',
-    `
-      type B = boolean;
-      type T = B;
-    `,
-    'type T = false | true;',
-    `
-      type B = false;
-      type T = B | true;
-    `,
-    `
-      type B = true;
-      type T = B | false;
-    `,
-    'type T = number;',
-    `
-      type B = number;
-      type T = B;
-    `,
-    'type T = 1 | 2;',
-    `
-      type B = 1;
-      type T = B | 2;
-    `,
-    'type T = 1 | false;',
-    `
-      type B = 1;
-      type T = B | false;
-    `,
-    'type T = string;',
-    `
-      type B = string;
-      type T = B;
-    `,
-    "type T = 'a' | 'b';",
-    `
-      type B = 'b';
-      type T = 'a' | B;
-    `,
-    `
-      type B = 'a';
-      type T = B | 'b';
-    `,
-    'type T = bigint | null;',
-    `
-      type B = bigint;
-      type T = B | null;
-    `,
-    'type T = boolean | null;',
-    `
-      type B = boolean;
-      type T = B | null;
-    `,
-    'type T = number | null;',
-    `
-      type B = number;
-      type T = B | null;
-    `,
-    'type T = string | null;',
-    `
-      type B = string;
-      type T = B | null;
-    `,
-    'type T = bigint & null;',
-    `
-      type B = bigint;
-      type T = B & null;
-    `,
-    'type T = boolean & null;',
-    `
-      type B = boolean;
-      type T = B & null;
-    `,
-    'type T = number & null;',
-    `
-      type B = number;
-      type T = B & null;
-    `,
-    'type T = string & null;',
-    `
-      type B = string;
-      type T = B & null;
-    `,
-    'type T = `${string}` & null;',
-    `
-      type B = \`\${string}\`;
-      type T = B & null;
-    `,
-    `
-      type T = 'a' | 1 | 'b';
-      type U = T & string;
-    `,
-  ],
 });
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 672d7a0d68f5..5aad60bc6f9b 100644
--- a/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
@@ -5,6 +5,110 @@ import rule from '../../src/rules/no-require-imports';
 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 { createRequire } from 'module';
+const require = createRequire();
+require('remark-preset-prettier');
+    `,
+    {
+      code: "const pkg = require('./package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: 'const pkg = require(`./package.json`);',
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('data.json');",
+      options: [{ allow: ['\\.json$'] }],
+    },
+    {
+      code: "import pkg = require('some-package');",
+      options: [{ allow: ['^some-package$'] }],
+    },
+    {
+      code: "import foo = require('foo');",
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+trick(require('foo'));
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo = require('./foo.json') as Foo;
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo: Foo = require('./foo.json').default;
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const foo = <Foo>require('./foo.json');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+const configValidator = new Validator(require('./a.json'));
+configValidator.addSchema(require('./a.json'));
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+require('foo');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+let require = bazz;
+require?.('foo');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+    {
+      code: `
+import { createRequire } from 'module';
+const require = createRequire();
+require('remark-preset-prettier');
+      `,
+      options: [{ allowAsImport: true }],
+    },
+  ],
   invalid: [
     {
       code: "var lib = require('lib');",
@@ -264,108 +368,4 @@ configValidator.addSchema(require('./a.json'));
       options: [{ allowAsImport: true }],
     },
   ],
-  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 { createRequire } from 'module';
-const require = createRequire();
-require('remark-preset-prettier');
-    `,
-    {
-      code: "const pkg = require('./package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: 'const pkg = require(`./package.json`);',
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('data.json');",
-      options: [{ allow: ['\\.json$'] }],
-    },
-    {
-      code: "import pkg = require('some-package');",
-      options: [{ allow: ['^some-package$'] }],
-    },
-    {
-      code: "import foo = require('foo');",
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-trick(require('foo'));
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo = require('./foo.json') as Foo;
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo: Foo = require('./foo.json').default;
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const foo = <Foo>require('./foo.json');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-const configValidator = new Validator(require('./a.json'));
-configValidator.addSchema(require('./a.json'));
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-require('foo');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-let require = bazz;
-require?.('foo');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-    {
-      code: `
-import { createRequire } from 'module';
-const require = createRequire();
-require('remark-preset-prettier');
-      `,
-      options: [{ allowAsImport: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts b/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
index 854569b530e9..5640f285264f 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
@@ -6,64 +6,36 @@ import rule from '../../src/rules/no-restricted-imports';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-imports', rule, {
-  invalid: [
+  valid: [
+    "import foo from 'foo';",
+    "import foo = require('foo');",
+    "import 'foo';",
     {
-      code: "import foo from 'import1';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo from 'foo';",
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo = require('import1');",
-      errors: [
-        {
-          messageId: 'path',
-        },
-      ],
+      code: "import foo = require('foo');",
       options: ['import1', 'import2'],
     },
     {
-      code: "export { foo } from 'import1';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo from 'import1';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo from 'foo';",
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "export { foo } from 'import1';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "import foo from 'import1/private/foo';",
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import 'foo';",
+      options: ['import1', 'import2'],
+    },
+    {
+      code: "import foo from 'foo';",
       options: [
         {
           paths: ['import1', 'import2'],
@@ -72,13 +44,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'import1/private/foo';",
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: ['import1', 'import2'],
@@ -87,13 +53,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'import-foo';",
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo from 'foo';",
       options: [
         {
           paths: [
@@ -110,13 +70,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: [
@@ -133,13 +87,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import { Bar } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo from 'foo';",
       options: [
         {
           paths: [
@@ -153,13 +101,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { Bar } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: [
         {
           paths: [
@@ -173,13 +115,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'import1/private/foo';",
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo from 'foo';",
       options: [
         {
           patterns: [
@@ -197,13 +133,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'import1/private/foo';",
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export { foo } from 'foo';",
       options: [
         {
           patterns: [
@@ -221,36 +151,27 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import 'import-foo';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import foo = require('foo');",
       options: [
         {
           paths: [
             {
-              name: 'import-foo',
+              importNames: ['foo'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import 'import-foo';",
-      errors: [
-        {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import type foo from 'import-foo';",
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
+              message: 'Please use import-bar instead.',
               name: 'import-foo',
             },
           ],
@@ -258,13 +179,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'import-foo';",
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import type _ = require('import-foo');",
       options: [
         {
           paths: [
@@ -278,18 +193,14 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo = require('import-foo');",
-      errors: [
-        {
-          messageId: 'pathWithCustomMessage',
-        },
-      ],
+      code: "import type { Bar } from 'import-foo';",
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
-              message: 'Please use import-bar instead.',
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
               name: 'import-foo',
             },
           ],
@@ -297,13 +208,7 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import { Bar } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "export type { Bar } from 'import-foo';",
       options: [
         {
           paths: [
@@ -318,34 +223,21 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { Bar } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "import type foo from 'import1/private/bar';",
       options: [
         {
-          paths: [
+          patterns: [
             {
               allowTypeImports: true,
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
-              name: 'import-foo',
+              group: ['import1/private/*'],
+              message: 'usage of import1 private modules not allowed.',
             },
           ],
         },
       ],
     },
     {
-      code: "import foo from 'import1/private/bar';",
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "export type { foo } from 'import1/private/bar';",
       options: [
         {
           patterns: [
@@ -359,68 +251,69 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'import1/private/bar';",
-      errors: [
-        {
-          messageId: 'patternWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
-        },
-      ],
+      code: "export * from 'foo';",
+      options: ['import1'],
+    },
+    {
+      code: "import type { MyType } from './types';",
       options: [
         {
           patterns: [
             {
               allowTypeImports: true,
-              group: ['import1/private/*'],
-              message: 'usage of import1 private modules not allowed.',
+              group: ['fail'],
+              message: "Please do not load from 'fail'.",
             },
           ],
         },
       ],
     },
     {
-      code: "export * from 'import1';",
-      errors: [
+      code: `
+import type { foo } from 'import1/private/bar';
+import type { foo } from 'import2/private/bar';
+      `,
+      options: [
         {
-          messageId: 'path',
-          type: AST_NODE_TYPES.ExportAllDeclaration,
+          patterns: [
+            {
+              allowTypeImports: true,
+              group: ['import1/private/*'],
+              message: 'usage of import1 private modules not allowed.',
+            },
+            {
+              allowTypeImports: true,
+              group: ['import2/private/*'],
+              message: 'usage of import2 private modules not allowed.',
+            },
+          ],
         },
       ],
-      options: ['import1'],
     },
     {
-      code: "import type { InvalidTestCase } from '@typescript-eslint/utils/dist/ts-eslint';",
-      errors: [
-        {
-          messageId: 'patterns',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "import { type Bar } from 'import-foo';",
       options: [
         {
-          patterns: ['@typescript-eslint/utils/dist/*'],
+          paths: [
+            {
+              allowTypeImports: true,
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
+            },
+          ],
         },
       ],
     },
     {
-      code: "import { Bar, type Baz } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ImportDeclaration,
-        },
-      ],
+      code: "export { type Bar } from 'import-foo';",
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
-              importNames: ['Bar', 'Baz'],
-              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
               name: 'import-foo',
             },
           ],
@@ -428,61 +321,93 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { Bar, type Baz } from 'import-foo';",
-      errors: [
-        {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
+      code: "import foo from 'foo';",
+      options: [],
+    },
+    {
+      code: "import foo from 'foo';",
+      options: [
+        {
+          paths: [],
         },
+      ],
+    },
+    {
+      code: "import foo from 'foo';",
+      options: [
         {
-          messageId: 'importNameWithCustomMessage',
-          type: AST_NODE_TYPES.ExportNamedDeclaration,
+          patterns: [],
         },
       ],
+    },
+    {
+      code: "import foo from 'foo';",
       options: [
         {
-          paths: [
-            {
-              allowTypeImports: true,
-              importNames: ['Bar', 'Baz'],
-              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
-              name: 'import-foo',
-            },
-          ],
+          paths: [],
+          patterns: [],
         },
       ],
     },
   ],
-  valid: [
-    "import foo from 'foo';",
-    "import foo = require('foo');",
-    "import 'foo';",
+  invalid: [
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo = require('foo');",
+      code: "import foo = require('import1');",
+      errors: [
+        {
+          messageId: 'path',
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: ['import1', 'import2'],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [{ paths: ['import1', 'import2'] }],
     },
     {
-      code: "import 'foo';",
-      options: ['import1', 'import2'],
-    },
-    {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: ['import1', 'import2'],
@@ -491,7 +416,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: ['import1', 'import2'],
@@ -500,7 +431,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -517,7 +454,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -534,7 +477,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -548,7 +497,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -562,7 +517,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo from 'foo';",
+      code: "import foo from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
@@ -580,7 +541,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export { foo } from 'foo';",
+      code: "export { foo } from 'import1/private/foo';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
@@ -598,27 +565,36 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import foo = require('foo');",
+      code: "import 'import-foo';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
-              importNames: ['foo'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
-              name: 'foo',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "import type foo from 'import-foo';",
+      code: "import 'import-foo';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
-              message: 'Please use import-bar instead.',
               name: 'import-foo',
             },
           ],
@@ -626,7 +602,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import type _ = require('import-foo');",
+      code: "import foo from 'import-foo';",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -640,14 +622,18 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import type { Bar } from 'import-foo';",
+      code: "import foo = require('import-foo');",
+      errors: [
+        {
+          messageId: 'pathWithCustomMessage',
+        },
+      ],
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
+              message: 'Please use import-bar instead.',
               name: 'import-foo',
             },
           ],
@@ -655,7 +641,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export type { Bar } from 'import-foo';",
+      code: "import { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
@@ -670,21 +662,34 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "import type foo from 'import1/private/bar';",
+      code: "export { Bar } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
+        },
+      ],
       options: [
         {
-          patterns: [
+          paths: [
             {
               allowTypeImports: true,
-              group: ['import1/private/*'],
-              message: 'usage of import1 private modules not allowed.',
+              importNames: ['Bar'],
+              message: 'Please use Bar from /import-bar/baz/ instead.',
+              name: 'import-foo',
             },
           ],
         },
       ],
     },
     {
-      code: "export type { foo } from 'import1/private/bar';",
+      code: "import foo from 'import1/private/bar';",
+      errors: [
+        {
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           patterns: [
@@ -698,28 +703,13 @@ ruleTester.run('no-restricted-imports', rule, {
       ],
     },
     {
-      code: "export * from 'foo';",
-      options: ['import1'],
-    },
-    {
-      code: "import type { MyType } from './types';",
-      options: [
+      code: "export { foo } from 'import1/private/bar';",
+      errors: [
         {
-          patterns: [
-            {
-              allowTypeImports: true,
-              group: ['fail'],
-              message: "Please do not load from 'fail'.",
-            },
-          ],
+          messageId: 'patternWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
         },
       ],
-    },
-    {
-      code: `
-import type { foo } from 'import1/private/bar';
-import type { foo } from 'import2/private/bar';
-      `,
       options: [
         {
           patterns: [
@@ -728,39 +718,53 @@ import type { foo } from 'import2/private/bar';
               group: ['import1/private/*'],
               message: 'usage of import1 private modules not allowed.',
             },
-            {
-              allowTypeImports: true,
-              group: ['import2/private/*'],
-              message: 'usage of import2 private modules not allowed.',
-            },
           ],
         },
       ],
     },
     {
-      code: "import { type Bar } from 'import-foo';",
+      code: "export * from 'import1';",
+      errors: [
+        {
+          messageId: 'path',
+          type: AST_NODE_TYPES.ExportAllDeclaration,
+        },
+      ],
+      options: ['import1'],
+    },
+    {
+      code: "import type { InvalidTestCase } from '@typescript-eslint/utils/dist/ts-eslint';",
+      errors: [
+        {
+          messageId: 'patterns',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
-          paths: [
-            {
-              allowTypeImports: true,
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
-              name: 'import-foo',
-            },
-          ],
+          patterns: ['@typescript-eslint/utils/dist/*'],
         },
       ],
     },
     {
-      code: "export { type Bar } from 'import-foo';",
+      code: "import { Bar, type Baz } from 'import-foo';",
+      errors: [
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+        {
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ImportDeclaration,
+        },
+      ],
       options: [
         {
           paths: [
             {
               allowTypeImports: true,
-              importNames: ['Bar'],
-              message: 'Please use Bar from /import-bar/baz/ instead.',
+              importNames: ['Bar', 'Baz'],
+              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
               name: 'import-foo',
             },
           ],
@@ -768,31 +772,27 @@ import type { foo } from 'import2/private/bar';
       ],
     },
     {
-      code: "import foo from 'foo';",
-      options: [],
-    },
-    {
-      code: "import foo from 'foo';",
-      options: [
+      code: "export { Bar, type Baz } from 'import-foo';",
+      errors: [
         {
-          paths: [],
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
         },
-      ],
-    },
-    {
-      code: "import foo from 'foo';",
-      options: [
         {
-          patterns: [],
+          messageId: 'importNameWithCustomMessage',
+          type: AST_NODE_TYPES.ExportNamedDeclaration,
         },
       ],
-    },
-    {
-      code: "import foo from 'foo';",
       options: [
         {
-          paths: [],
-          patterns: [],
+          paths: [
+            {
+              allowTypeImports: true,
+              importNames: ['Bar', 'Baz'],
+              message: 'Please use Bar and Baz from /import-bar/baz/ instead.',
+              name: 'import-foo',
+            },
+          ],
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts b/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
index e98b54210e11..c0a2ddbfe5fa 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
@@ -5,6 +5,34 @@ import rule from '../../src/rules/no-restricted-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-types', rule, {
+  valid: [
+    'let f = Object();',
+    'let f: { x: number; y: number } = { x: 1, y: 1 };',
+    {
+      code: 'let f = Object();',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let f = Object(false);',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let g = Object.create(null);',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let e: namespace.Object;',
+      options: [{ types: { Object: true } }],
+    },
+    {
+      code: 'let value: _.NS.Banned;',
+      options: [{ types: { 'NS.Banned': true } }],
+    },
+    {
+      code: 'let value: NS.Banned._;',
+      options: [{ types: { 'NS.Banned': true } }],
+    },
+  ],
   invalid: [
     {
       code: 'let value: bigint;',
@@ -595,32 +623,4 @@ ruleTester.run('no-restricted-types', rule, {
       output: null,
     },
   ],
-  valid: [
-    'let f = Object();',
-    'let f: { x: number; y: number } = { x: 1, y: 1 };',
-    {
-      code: 'let f = Object();',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let f = Object(false);',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let g = Object.create(null);',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let e: namespace.Object;',
-      options: [{ types: { Object: true } }],
-    },
-    {
-      code: 'let value: _.NS.Banned;',
-      options: [{ types: { 'NS.Banned': true } }],
-    },
-    {
-      code: 'let value: NS.Banned._;',
-      options: [{ types: { 'NS.Banned': true } }],
-    },
-  ],
 });
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 4d0a3ef4951c..13a0e34f9f72 100644
--- a/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
@@ -19,6 +19,37 @@ const arrayDestructureError = {
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-this-alias', rule, {
+  valid: [
+    'const self = foo(this);',
+    {
+      code: `
+const { props, state } = this;
+const { length } = this;
+const { length, toString } = this;
+const [foo] = this;
+const [foo, bar] = this;
+      `,
+      options: [
+        {
+          allowDestructuring: true,
+        },
+      ],
+    },
+    {
+      code: 'const self = this;',
+      options: [
+        {
+          allowedNames: ['self'],
+        },
+      ],
+    },
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/281
+    `
+declare module 'foo' {
+  declare const aVar: string;
+}
+    `,
+  ],
   invalid: [
     {
       code: 'const self = this;',
@@ -99,36 +130,4 @@ class TestClass {
       ],
     },
   ],
-
-  valid: [
-    'const self = foo(this);',
-    {
-      code: `
-const { props, state } = this;
-const { length } = this;
-const { length, toString } = this;
-const [foo] = this;
-const [foo, bar] = this;
-      `,
-      options: [
-        {
-          allowDestructuring: true,
-        },
-      ],
-    },
-    {
-      code: 'const self = this;',
-      options: [
-        {
-          allowedNames: ['self'],
-        },
-      ],
-    },
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/281
-    `
-declare module 'foo' {
-  declare const aVar: string;
-}
-    `,
-  ],
 });
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 a7d7de86c692..60975e747c8d 100644
--- a/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
@@ -5,1185 +5,587 @@ import rule from '../../src/rules/no-type-alias';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-type-alias', rule, {
-  invalid: [
+  valid: [
     {
-      code: "type Foo = 'a';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: "type A = 'a' & ('b' | 'c');",
+      options: [{ allowAliases: 'always' }],
     },
     {
       code: "type Foo = 'a';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = typeof import('foo');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' | 'b';",
+      options: [{ allowAliases: 'always' }],
     },
     {
       code: "type Foo = 'a' | 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | typeof import('foo');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: "type Foo = 'a' | 'b';",
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' | 'b' | 'c';",
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
-        },
-      ],
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' & 'b';",
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = 'a' & 'b' & 'c';",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      code: "type Foo = 'a' & 'b' & 'c';",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: "type Foo = 'a' & 'b' & 'c';",
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
-        },
-      ],
+      code: "type Foo = 'a' | ('b' & 'c');",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: "type Foo = 'a' | ('b' & 'c');",
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = 1 | 2;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1 | 2;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: 'type Foo = 1 | 2;',
       options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1 | 2 | 3;',
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = 1 & 2;',
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 18,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 24,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1 & 2 & 3;',
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = 1 | (2 & 3);',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
+      code: 'type Foo = 1 | (2 & 3);',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: 'type Foo = `a-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
       options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 19,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 25,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-unions',
-          allowLiterals: 'in-intersections',
-        },
-      ],
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = true;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = true | false;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = true & false;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      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' }],
+    },
+    {
+      code: 'type Foo = string;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | readonly string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string | string[] | number;',
+      options: [{ allowAliases: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[];',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = string & string[] & number;',
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = () => void;',
+      options: [{ allowCallbacks: 'always' }],
+    },
+    {
+      code: 'type Foo = () => void | string;',
+      options: [{ allowCallbacks: 'always' }],
+    },
+    {
+      code: 'type Foo = {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = {} | {};',
+      options: [{ allowLiterals: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'always' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = {} & {};',
+      options: [{ allowLiterals: 'in-intersections' }],
+    },
+    {
+      code: `
+type Foo<T> = {
+  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];
+    };
+      `,
+      options: [{ allowMappedTypes: 'always' }],
+    },
+    {
+      code: `
+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];
+    };
+      `,
+      options: [{ allowMappedTypes: 'in-unions' }],
+    },
+    {
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+} & {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      options: [{ allowMappedTypes: 'always' }],
     },
     {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'in-intersections' }],
+      code: `
+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 = 'a' | ('b' & 'c');",
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: `
+type Foo<T> = {
+  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;
+      `,
       options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-intersections',
+          allowAliases: 'in-unions-and-intersections',
+          allowCallbacks: 'always',
+          allowLiterals: 'in-unions-and-intersections',
+          allowMappedTypes: 'in-unions-and-intersections',
         },
       ],
     },
     {
-      code: 'type Foo = string;',
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: 'type Foo = typeof bar;',
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = string;',
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: "type Foo = typeof import('foo');",
+      options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = string;',
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
+      code: `
+const WithAKey = { AKey: true };
+type KeyNames = keyof typeof SCALARS;
+      `,
+      options: [{ allowAliases: 'always' }],
+    },
+    {
+      code: 'type Foo = typeof bar | typeof baz;',
       options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = string;',
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowAliases: 'in-intersections' }],
+      code: "type Foo = typeof bar | typeof import('foo');",
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = string;',
-      errors: [
-        {
-          column: 12,
-          data: {
-            alias: 'aliases',
-          },
-          line: 1,
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = keyof [string];',
+      options: [{ allowTupleTypes: 'always' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
+      code: 'type Foo = [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowLiterals: 'in-unions' }],
+      code: 'type Foo = [string] | [number, number];',
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      errors: [
-        {
-          column: 12,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never' }],
+      code: 'type Foo = [string] & [number, number];',
+      options: [{ allowTupleTypes: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = ([string] & [number, number]) | [number, number, number];',
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = readonly [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = readonly [string] | readonly [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = readonly [string] | [number, number];',
+      options: [{ allowTupleTypes: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = [string] & readonly [number, number];',
+      options: [{ allowTupleTypes: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = ([string] & [number, number]) | readonly [number, number, number];',
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type Foo = keyof [string] | [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = keyof [string] | keyof [number, number];',
+      options: [{ allowTupleTypes: 'always' }],
+    },
+    {
+      code: 'type Foo = keyof [string] | [number, number];',
+      options: [{ allowTupleTypes: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = [string] & keyof [number, number];',
+      options: [{ allowTupleTypes: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = ([string] & [number, number]) | keyof [number, number, number];',
+      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
+    },
+    {
+      code: 'type MyType<T> = T extends number ? number : null;',
+      options: [{ allowConditionalTypes: 'always' }],
     },
     {
-      code: 'type Foo = string | string[];',
+      code: 'type Foo = new (bar: number) => string | null;',
+      options: [{ allowConstructors: 'always' }],
+    },
+    {
+      code: 'type Foo = Record<string, number>;',
+      options: [{ allowGenerics: 'always' }],
+    },
+  ],
+  invalid: [
+    {
+      code: "type Foo = 'a';",
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
+            alias: 'aliases',
           },
           line: 1,
-          messageId: 'noCompositionAlias',
+          messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[];',
+      code: "type Foo = 'a';",
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
+            alias: 'aliases',
           },
           line: 1,
-          messageId: 'noCompositionAlias',
+          messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowAliases: 'in-intersections' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | string[];',
+      code: "type Foo = typeof import('foo');",
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
+            alias: 'aliases',
           },
           line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          messageId: 'noTypeAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | 'b';",
       errors: [
         {
           column: 12,
@@ -1195,16 +597,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1215,7 +608,7 @@ ruleTester.run('no-type-alias', rule, {
       ],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | typeof import('foo');",
       errors: [
         {
           column: 12,
@@ -1227,16 +620,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1245,10 +629,9 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | 'b';",
       errors: [
         {
           column: 12,
@@ -1260,16 +643,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1278,10 +652,10 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | 'b';",
       errors: [
         {
           column: 12,
@@ -1293,16 +667,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1311,10 +676,10 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | 'b';",
       errors: [
         {
           column: 12,
@@ -1326,16 +691,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1344,10 +700,10 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-intersections' }],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
+      code: "type Foo = 'a' | 'b';",
       errors: [
         {
           column: 12,
@@ -1359,16 +715,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 21,
-          data: {
-            compositionType: 'union',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 32,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1385,7 +732,7 @@ ruleTester.run('no-type-alias', rule, {
       ],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
@@ -1397,30 +744,7 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 22,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 33,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-    },
-    {
-      code: 'type Foo = string | (string[] & number);',
-      errors: [
-        {
-          column: 12,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1429,28 +753,18 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 22,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 33,
+          column: 24,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
@@ -1462,28 +776,28 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 22,
+          column: 18,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 33,
+          column: 24,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
@@ -1495,76 +809,28 @@ ruleTester.run('no-type-alias', rule, {
           messageId: 'noCompositionAlias',
         },
         {
-          column: 22,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 33,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = string | (string[] & number);',
-      errors: [
-        {
-          column: 22,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 33,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Aliases',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-      ],
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = string | (string[] & number);',
-      errors: [
-        {
-          column: 22,
+          column: 18,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 33,
+          column: 24,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = string | (string[] & number);',
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
@@ -1575,14 +841,8 @@ ruleTester.run('no-type-alias', rule, {
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = string | (string[] & number);',
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -1590,219 +850,186 @@ ruleTester.run('no-type-alias', rule, {
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [
-        {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
-        },
-      ],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar;
-      `,
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 3,
-          messageId: 'noTypeAlias',
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar;
-      `,
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 3,
-          messageId: 'noTypeAlias',
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'never' }],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar;
-      `,
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 3,
-          messageId: 'noTypeAlias',
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar;
-      `,
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 3,
-          messageId: 'noTypeAlias',
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar;
-      `,
+      code: "type Foo = 'a' | 'b' | 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 3,
-          messageId: 'noTypeAlias',
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 18,
+          column: 24,
           data: {
             compositionType: 'union',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'union',
+            compositionType: 'intersection',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
           column: 18,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
         {
           column: 18,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-unions' }],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'union',
+            compositionType: 'intersection',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
           column: 18,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-intersections' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar | {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
         {
           column: 18,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
           column: 12,
@@ -1810,25 +1037,23 @@ type Foo = Bar & {};
             compositionType: 'intersection',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
           column: 18,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
+      code: "type Foo = 'a' & 'b';",
       errors: [
         {
           column: 12,
@@ -1836,26 +1061,28 @@ type Foo = Bar & {};
             compositionType: 'intersection',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
           column: 18,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
+      options: [
+        {
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
+        },
+      ],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
           column: 12,
@@ -1863,302 +1090,257 @@ type Foo = Bar & {};
             compositionType: 'intersection',
             typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
           column: 18,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
-      errors: [
         {
-          column: 18,
+          column: 24,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & {};
-      `,
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
-          column: 18,
+          column: 12,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = () => void;',
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
-            alias: 'callbacks',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = () => void;',
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'callbacks',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowCallbacks: 'never' }],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowLiterals: 'never' }],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowLiterals: 'in-unions' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = {};',
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowLiterals: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-intersections' }],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {};',
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowAliases: 'in-intersections', allowLiterals: 'never' }],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 18,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          column: 24,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = {};',
+      code: "type Foo = 'a' & 'b' & 'c';",
       errors: [
         {
           column: 12,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-intersections',
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = {};',
-      errors: [
         {
-          column: 12,
+          column: 24,
           data: {
-            alias: 'literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
       options: [
         {
-          allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions-and-intersections',
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
         },
       ],
     },
     {
-      code: 'type Foo = {} | {};',
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
           column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 17,
+          column: 19,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = {} | {};',
-      errors: [
         {
-          column: 12,
+          column: 25,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
+      ],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      errors: [
         {
-          column: 17,
+          column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowLiterals: 'never' }],
-    },
-    {
-      code: 'type Foo = {} | {};',
-      errors: [
         {
-          column: 12,
+          column: 19,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 17,
+          column: 25,
           data: {
-            compositionType: 'union',
-            typeName: 'Literals',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
@@ -2167,81 +1349,100 @@ type Foo = Bar & {};
       options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {} & {};',
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
           column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 19,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 17,
+          column: 25,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = {} & {};',
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
           column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 19,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 17,
+          column: 25,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowLiterals: 'never' }],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = {} & {};',
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          column: 12,
+          column: 19,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 17,
+          column: 25,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowLiterals: 'in-unions' }],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: "type Foo = (string & {}) | 'a' | 1;",
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          column: 13,
+          column: 19,
           data: {
             compositionType: 'intersection',
             typeName: 'Aliases',
@@ -2250,31 +1451,27 @@ type Foo = Bar & {};
           messageId: 'noCompositionAlias',
         },
         {
-          column: 22,
+          column: 25,
           data: {
             compositionType: 'intersection',
-            typeName: 'Literals',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
+      options: [
+        {
+          allowAliases: 'in-unions',
+          allowLiterals: 'in-intersections',
+        },
+      ],
     },
     {
-      code: "type Foo = (string & {}) | 'a' | 1;",
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
-          column: 22,
-          data: {
-            compositionType: 'intersection',
-            typeName: 'Literals',
-          },
-          line: 1,
-          messageId: 'noCompositionAlias',
-        },
-        {
-          column: 28,
+          column: 12,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -2282,8 +1479,14 @@ type Foo = Bar & {};
           line: 1,
           messageId: 'noCompositionAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: "type Foo = 'a' | ('b' & 'c');",
+      errors: [
         {
-          column: 34,
+          column: 12,
           data: {
             compositionType: 'union',
             typeName: 'Aliases',
@@ -2295,404 +1498,408 @@ type Foo = Bar & {};
       options: [
         {
           allowAliases: 'in-intersections',
-          allowLiterals: 'in-unions',
+          allowLiterals: 'in-intersections',
         },
       ],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            alias: 'mapped types',
+            alias: 'aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noTypeAlias',
         },
       ],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            alias: 'mapped types',
+            alias: 'aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'never' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            alias: 'mapped types',
+            alias: 'aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'in-unions' }],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            alias: 'mapped types',
+            alias: 'aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'in-intersections' }],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            alias: 'mapped types',
+            alias: 'aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noTypeAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
+      options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: `
-type Foo<T> =
-  | {
-      readonly [P in keyof T]: T[P];
-    }
-  | {
-      readonly [P in keyof T]: T[P];
-    };
-      `,
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          column: 5,
+          column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 6,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: `
-type Foo<T> =
-  | {
-      readonly [P in keyof T]: T[P];
-    }
-  | {
-      readonly [P in keyof T]: T[P];
-    };
-      `,
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          column: 5,
+          column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 6,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'never' }],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: `
-type Foo<T> =
-  | {
-      readonly [P in keyof T]: T[P];
-    }
-  | {
-      readonly [P in keyof T]: T[P];
-    };
-      `,
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          column: 5,
+          column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 3,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
             compositionType: 'union',
-            typeName: 'Mapped types',
+            typeName: 'Aliases',
           },
-          line: 6,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'in-intersections' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-} & {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 4,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-} & {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string | string[];',
       errors: [
         {
-          column: 15,
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 21,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string | string[];',
+      errors: [
+        {
+          column: 12,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 4,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowMappedTypes: 'never' }],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: `
-type Foo<T> = {
-  readonly [P in keyof T]: T[P];
-} & {
-  readonly [P in keyof T]: T[P];
-};
-      `,
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          column: 15,
+          column: 12,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 2,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 5,
+          column: 21,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Mapped types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
-          line: 4,
+          line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowMappedTypes: 'in-unions' }],
-    },
-    {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/270
-      code: "export type ButtonProps = JSX.IntrinsicElements['button'];",
-      errors: [
         {
-          column: 27,
+          column: 32,
           data: {
-            alias: 'aliases',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
     },
     {
-      code: 'type Foo = [number] | [number, number];',
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
           column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 23,
+          column: 21,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 32,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'never' }],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = [number] & [number, number];',
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 23,
+          column: 21,
           data: {
-            compositionType: 'intersection',
-            typeName: 'Tuple Types',
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 32,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'in-unions' }],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = [number] | [number, number];',
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
           column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 23,
+          column: 21,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = [number];',
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 32,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'in-intersections' }],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = [number];',
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowTupleTypes: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = [number];',
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 21,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 32,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = readonly [number] | keyof [number, number];',
+      code: 'type Foo = string | string[] | number;',
       errors: [
         {
           column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 21,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
@@ -2701,575 +1908,1004 @@ type Foo<T> = {
           column: 32,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'never' }],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: 'type Foo = keyof [number] & [number, number];',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
           column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 22,
           data: {
             compositionType: 'intersection',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 29,
+          column: 33,
           data: {
             compositionType: 'intersection',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = [number] | readonly [number, number];',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
           column: 12,
           data: {
             compositionType: 'union',
-            typeName: 'Tuple Types',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 23,
+          column: 22,
           data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = readonly [number];',
-      errors: [
-        {
-          messageId: 'noTypeAlias',
-        },
-      ],
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = keyof [number];',
-      errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 33,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowTupleTypes: 'in-unions' }],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = readonly [number];',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          messageId: 'noTypeAlias',
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = new (bar: number) => string | null;',
-      errors: [
         {
-          column: 12,
+          column: 22,
           data: {
-            alias: 'constructors',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowConstructors: 'never' }],
-    },
-    {
-      code: 'type MyType<T> = T extends number ? number : null;',
-      errors: [
         {
-          column: 18,
+          column: 33,
           data: {
-            alias: 'conditional types',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type MyType<T> = T extends number ? number : null;',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          column: 18,
+          column: 12,
           data: {
-            alias: 'conditional types',
+            compositionType: 'union',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-      options: [{ allowConditionalTypes: 'never' }],
-    },
-    {
-      // unique symbol is not allowed in this context
-      code: 'type Foo = keyof [string] | unique symbol;',
-      errors: [
         {
-          column: 12,
+          column: 22,
           data: {
-            compositionType: 'union',
-            typeName: 'Tuple Types',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 29,
+          column: 33,
           data: {
-            compositionType: 'union',
-            typeName: 'Unhandled',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = Record<string, number>;',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          column: 12,
+          column: 22,
           data: {
-            alias: 'generics',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
-      ],
-    },
-    {
-      code: 'type Foo = `foo-${number}`;',
-      errors: [
         {
-          column: 12,
+          column: 33,
           data: {
-            alias: 'aliases',
+            compositionType: 'intersection',
+            typeName: 'Aliases',
           },
           line: 1,
-          messageId: 'noTypeAlias',
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
-          column: 12,
+          column: 22,
           data: {
-            compositionType: 'union',
+            compositionType: 'intersection',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
         {
-          column: 28,
+          column: 33,
           data: {
-            compositionType: 'union',
+            compositionType: 'intersection',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
+      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
           column: 12,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
+    },
+    {
+      code: 'type Foo = string | (string[] & number);',
+      errors: [
         {
-          column: 28,
+          column: 12,
           data: {
-            compositionType: 'intersection',
+            compositionType: 'union',
             typeName: 'Aliases',
           },
           line: 1,
           messageId: 'noCompositionAlias',
         },
       ],
-      options: [{ allowAliases: 'never' }],
-    },
-  ],
-  valid: [
-    {
-      code: "type A = 'a' & ('b' | 'c');",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a';",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b';",
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' | 'b' | 'c';",
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b';",
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' & 'b' & 'c';",
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = 'a' | ('b' & 'c');",
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | 2;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | 2 | 3;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 & 2 & 3;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = 1 | (2 & 3);',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = 1 | (2 & 3);',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}`;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | `b-${number}` | `c-${number}`;',
-      options: [{ allowAliases: 'in-unions' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}`;',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 3,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
-      options: [{ allowAliases: 'always' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 3,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 3,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = `a-${number}` & `b-${number}` & `c-${number}`;',
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 3,
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = `a-${number}` | (`b-${number}` & `c-${number}`);',
+      code: `
+interface Bar {}
+type Foo = Bar;
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 3,
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = true;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: 'type Foo = true | false;',
-      options: [{ allowAliases: 'always' }],
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = true | false;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = true | false;',
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = true & false;',
-      options: [{ allowAliases: 'always' }],
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = true & false;',
+      code: `
+interface Bar {}
+type Foo = Bar | {};
+      `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
-    {
-      code: 'type Foo = true & false;',
-      options: [{ allowAliases: 'in-intersections' }],
-    },
     {
       code: `
 interface Bar {}
-type Foo = Bar | string;
+type Foo = Bar & {};
       `,
-      options: [{ allowAliases: 'always' }],
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
       code: `
 interface Bar {}
-type Foo = Bar | string;
+type Foo = Bar & {};
       `,
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
       code: `
 interface Bar {}
-type Foo = Bar | string;
+type Foo = Bar & {};
       `,
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-unions' }],
     },
     {
       code: `
 interface Bar {}
-type Foo = Bar & string;
+type Foo = Bar & {};
       `,
-      options: [{ allowAliases: 'always' }],
+      errors: [
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
       code: `
 interface Bar {}
-type Foo = Bar & string;
+type Foo = Bar & {};
       `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+      ],
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
-      code: `
-interface Bar {}
-type Foo = Bar & string;
-      `,
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = () => void;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'callbacks',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = string;',
-      options: [{ allowAliases: 'always' }],
+      code: 'type Foo = () => void;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'callbacks',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowCallbacks: 'never' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'always' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = string | readonly string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = string | string[];',
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'always' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = string | string[] | number;',
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-intersections', allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'always' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-intersections',
+        },
+      ],
     },
     {
-      code: 'type Foo = string & string[];',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'literals',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions-and-intersections',
+        },
+      ],
     },
     {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'always' }],
+      code: 'type Foo = {} | {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'in-unions-and-intersections' }],
+      code: 'type Foo = {} | {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = string & string[] & number;',
-      options: [{ allowAliases: 'in-intersections' }],
+      code: 'type Foo = {} | {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'union',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-intersections' }],
     },
     {
-      code: 'type Foo = () => void;',
-      options: [{ allowCallbacks: 'always' }],
+      code: 'type Foo = {} & {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = () => void | string;',
-      options: [{ allowCallbacks: 'always' }],
+      code: 'type Foo = {} & {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'never' }],
     },
     {
-      code: 'type Foo = {};',
-      options: [{ allowLiterals: 'always' }],
+      code: 'type Foo = {} & {};',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 17,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'always' }],
+      code: "type Foo = (string & {}) | 'a' | 1;",
+      errors: [
+        {
+          column: 13,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 22,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
     },
     {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+      code: "type Foo = (string & {}) | 'a' | 1;",
+      errors: [
+        {
+          column: 22,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Literals',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 28,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 34,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [
+        {
+          allowAliases: 'in-intersections',
+          allowLiterals: 'in-unions',
+        },
+      ],
     },
     {
-      code: 'type Foo = {} | {};',
-      options: [{ allowLiterals: 'in-unions' }],
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            alias: 'mapped types',
+          },
+          line: 2,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'always' }],
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            alias: 'mapped types',
+          },
+          line: 2,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'in-unions-and-intersections' }],
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            alias: 'mapped types',
+          },
+          line: 2,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = {} & {};',
-      options: [{ allowLiterals: 'in-intersections' }],
+      code: `
+type Foo<T> = {
+  readonly [P in keyof T]: T[P];
+};
+      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            alias: 'mapped types',
+          },
+          line: 2,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
       code: `
@@ -3277,7 +2913,17 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'always' }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            alias: 'mapped types',
+          },
+          line: 2,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
@@ -3289,7 +2935,26 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      options: [{ allowMappedTypes: 'always' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 6,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
       code: `
@@ -3301,7 +2966,27 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 6,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
       code: `
@@ -3313,7 +2998,27 @@ type Foo<T> =
       readonly [P in keyof T]: T[P];
     };
       `,
-      options: [{ allowMappedTypes: 'in-unions' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 3,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'union',
+            typeName: 'Mapped types',
+          },
+          line: 6,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
       code: `
@@ -3323,7 +3028,26 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'always' }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 2,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 4,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
       code: `
@@ -3333,7 +3057,27 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 2,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 4,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowMappedTypes: 'never' }],
     },
     {
       code: `
@@ -3343,122 +3087,378 @@ type Foo<T> = {
   readonly [P in keyof T]: T[P];
 };
       `,
-      options: [{ allowMappedTypes: 'in-intersections' }],
-    },
-    {
-      code: `
-export type ClassValue =
-  | string
-  | number
-  | ClassDictionary
-  | ClassArray
-  | undefined
-  | null
-  | false;
-      `,
-      options: [
+      errors: [
         {
-          allowAliases: 'in-unions-and-intersections',
-          allowCallbacks: 'always',
-          allowLiterals: 'in-unions-and-intersections',
-          allowMappedTypes: 'in-unions-and-intersections',
+          column: 15,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 2,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 5,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Mapped types',
+          },
+          line: 4,
+          messageId: 'noCompositionAlias',
         },
       ],
+      options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = typeof bar;',
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: "type Foo = typeof import('foo');",
-      options: [{ allowAliases: 'always' }],
-    },
-    {
-      code: `
-const WithAKey = { AKey: true };
-type KeyNames = keyof typeof SCALARS;
-      `,
-      options: [{ allowAliases: 'always' }],
+      // https://github.com/typescript-eslint/typescript-eslint/issues/270
+      code: "export type ButtonProps = JSX.IntrinsicElements['button'];",
+      errors: [
+        {
+          column: 27,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = typeof bar | typeof baz;',
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = [number] | [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'never' }],
     },
     {
-      code: "type Foo = typeof bar | typeof import('foo');",
-      options: [{ allowAliases: 'in-unions' }],
+      code: 'type Foo = [number] & [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = keyof [string];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type Foo = [number] | [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type Foo = [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = [string] | [number, number];',
+      code: 'type Foo = [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = [string] & [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
-    },
-    {
-      code: 'type Foo = ([string] & [number, number]) | [number, number, number];',
+      code: 'type Foo = [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = readonly [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type Foo = readonly [number] | keyof [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 32,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'never' }],
     },
     {
-      code: 'type Foo = readonly [string] | readonly [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type Foo = keyof [number] & [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 29,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-unions' }],
     },
     {
-      code: 'type Foo = readonly [string] | [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
+      code: 'type Foo = [number] | readonly [number, number];',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 23,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = [string] & readonly [number, number];',
+      code: 'type Foo = readonly [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowTupleTypes: 'in-intersections' }],
     },
     {
-      code: 'type Foo = ([string] & [number, number]) | readonly [number, number, number];',
+      code: 'type Foo = keyof [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowTupleTypes: 'in-unions' }],
+    },
+    {
+      code: 'type Foo = readonly [number];',
+      errors: [
+        {
+          messageId: 'noTypeAlias',
+        },
+      ],
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
-      code: 'type Foo = keyof [string] | [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type Foo = new (bar: number) => string | null;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'constructors',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowConstructors: 'never' }],
     },
     {
-      code: 'type Foo = keyof [string] | keyof [number, number];',
-      options: [{ allowTupleTypes: 'always' }],
+      code: 'type MyType<T> = T extends number ? number : null;',
+      errors: [
+        {
+          column: 18,
+          data: {
+            alias: 'conditional types',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = keyof [string] | [number, number];',
-      options: [{ allowTupleTypes: 'in-unions' }],
+      code: 'type MyType<T> = T extends number ? number : null;',
+      errors: [
+        {
+          column: 18,
+          data: {
+            alias: 'conditional types',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
+      options: [{ allowConditionalTypes: 'never' }],
     },
     {
-      code: 'type Foo = [string] & keyof [number, number];',
-      options: [{ allowTupleTypes: 'in-intersections' }],
+      // unique symbol is not allowed in this context
+      code: 'type Foo = keyof [string] | unique symbol;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Tuple Types',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 29,
+          data: {
+            compositionType: 'union',
+            typeName: 'Unhandled',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = ([string] & [number, number]) | keyof [number, number, number];',
-      options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
+      code: 'type Foo = Record<string, number>;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'generics',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type MyType<T> = T extends number ? number : null;',
-      options: [{ allowConditionalTypes: 'always' }],
+      code: 'type Foo = `foo-${number}`;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            alias: 'aliases',
+          },
+          line: 1,
+          messageId: 'noTypeAlias',
+        },
+      ],
     },
     {
-      code: 'type Foo = new (bar: number) => string | null;',
-      options: [{ allowConstructors: 'always' }],
+      code: 'type Foo = `a-${number}` | `b-${number}`;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 28,
+          data: {
+            compositionType: 'union',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
     {
-      code: 'type Foo = Record<string, number>;',
-      options: [{ allowGenerics: 'always' }],
+      code: 'type Foo = `a-${number}` & `b-${number}`;',
+      errors: [
+        {
+          column: 12,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+        {
+          column: 28,
+          data: {
+            compositionType: 'intersection',
+            typeName: 'Aliases',
+          },
+          line: 1,
+          messageId: 'noCompositionAlias',
+        },
+      ],
+      options: [{ allowAliases: 'never' }],
     },
   ],
 });
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 a2526457b44f..118c163569b9 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
@@ -14,6 +14,68 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
+  valid: [
+    `
+      declare const varAny: any;
+      varAny === true;
+    `,
+    `
+      declare const varAny: any;
+      varAny == false;
+    `,
+    `
+      declare const varString: string;
+      varString === false;
+    `,
+    `
+      declare const varString: string;
+      varString === true;
+    `,
+    `
+      declare const varObject: {};
+      varObject === true;
+    `,
+    `
+      declare const varObject: {};
+      varObject == false;
+    `,
+    `
+      declare const varNullOrUndefined: null | undefined;
+      varNullOrUndefined === false;
+    `,
+    `
+      declare const varBooleanOrString: boolean | string;
+      varBooleanOrString === false;
+    `,
+    `
+      declare const varBooleanOrString: boolean | string;
+      varBooleanOrString == true;
+    `,
+    `
+      declare const varTrueOrStringOrUndefined: true | string | undefined;
+      varTrueOrStringOrUndefined == true;
+    `,
+    `
+      declare const varBooleanOrUndefined: boolean | undefined;
+      varBooleanOrUndefined === true;
+    `,
+    {
+      code: `
+        declare const varBooleanOrUndefined: boolean | undefined;
+        varBooleanOrUndefined === true;
+      `,
+      options: [{ allowComparingNullableBooleansToFalse: false }],
+    },
+    {
+      code: `
+        declare const varBooleanOrUndefined: boolean | undefined;
+        varBooleanOrUndefined === false;
+      `,
+      options: [{ allowComparingNullableBooleansToTrue: false }],
+    },
+    "'false' === true;",
+    "'true' === false;",
+  ],
   invalid: [
     {
       code: 'true === true;',
@@ -419,67 +481,4 @@ ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
       `,
     },
   ],
-
-  valid: [
-    `
-      declare const varAny: any;
-      varAny === true;
-    `,
-    `
-      declare const varAny: any;
-      varAny == false;
-    `,
-    `
-      declare const varString: string;
-      varString === false;
-    `,
-    `
-      declare const varString: string;
-      varString === true;
-    `,
-    `
-      declare const varObject: {};
-      varObject === true;
-    `,
-    `
-      declare const varObject: {};
-      varObject == false;
-    `,
-    `
-      declare const varNullOrUndefined: null | undefined;
-      varNullOrUndefined === false;
-    `,
-    `
-      declare const varBooleanOrString: boolean | string;
-      varBooleanOrString === false;
-    `,
-    `
-      declare const varBooleanOrString: boolean | string;
-      varBooleanOrString == true;
-    `,
-    `
-      declare const varTrueOrStringOrUndefined: true | string | undefined;
-      varTrueOrStringOrUndefined == true;
-    `,
-    `
-      declare const varBooleanOrUndefined: boolean | undefined;
-      varBooleanOrUndefined === true;
-    `,
-    {
-      code: `
-        declare const varBooleanOrUndefined: boolean | undefined;
-        varBooleanOrUndefined === true;
-      `,
-      options: [{ allowComparingNullableBooleansToFalse: false }],
-    },
-    {
-      code: `
-        declare const varBooleanOrUndefined: boolean | undefined;
-        varBooleanOrUndefined === false;
-      `,
-      options: [{ allowComparingNullableBooleansToTrue: false }],
-    },
-    "'false' === true;",
-    "'true' === false;",
-  ],
 });
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 dcfc5865be4d..143255baf64b 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
@@ -55,203 +55,118 @@ const unnecessaryConditionTest = (
 });
 
 ruleTester.run('no-unnecessary-condition', rule, {
-  invalid: [
-    // Ensure that it's checking in all the right places
-    {
-      code: `
-const b1 = true;
+  valid: [
+    `
+declare const b1: boolean;
 declare const b2: boolean;
 const t1 = b1 && b2;
 const t2 = b1 || b2;
 if (b1 && b2) {
 }
-if (b2 && b1) {
-}
 while (b1 && b2) {}
-while (b2 && b1) {}
 for (let i = 0; b1 && b2; i++) {
   break;
 }
 const t1 = b1 && b2 ? 'yes' : 'no';
-const t1 = b2 && b1 ? 'yes' : 'no';
-      `,
-      errors: [
-        ruleError(4, 12, 'alwaysTruthy'),
-        ruleError(5, 12, 'alwaysTruthy'),
-        ruleError(6, 5, 'alwaysTruthy'),
-        ruleError(8, 11, 'alwaysTruthy'),
-        ruleError(10, 8, 'alwaysTruthy'),
-        ruleError(11, 14, 'alwaysTruthy'),
-        ruleError(12, 17, 'alwaysTruthy'),
-        ruleError(15, 12, 'alwaysTruthy'),
-        ruleError(16, 18, 'alwaysTruthy'),
-      ],
-      output: null,
-    },
-    // Ensure that it's complaining about the right things
-    unnecessaryConditionTest('object', 'alwaysTruthy'),
-    unnecessaryConditionTest('object | true', 'alwaysTruthy'),
-    unnecessaryConditionTest('"" | false', 'alwaysFalsy'), // Two falsy literals
-    unnecessaryConditionTest('"always truthy"', 'alwaysTruthy'),
-    unnecessaryConditionTest(`undefined`, 'alwaysFalsy'),
-    unnecessaryConditionTest('null', 'alwaysFalsy'),
-    unnecessaryConditionTest('void', 'alwaysFalsy'),
-    unnecessaryConditionTest('never', 'never'),
-    unnecessaryConditionTest('string & number', 'never'),
-
-    // More complex logical expressions
-    {
-      code: `
-declare const b1: boolean;
-declare const b2: boolean;
-if (true && b1 && b2) {
-}
-if (b1 && false && b2) {
+if (b1 && b2) {
 }
-if (b1 || b2 || true) {
+while (b1 && b2) {}
+for (let i = 0; b1 && b2; i++) {
+  break;
 }
-      `,
-      errors: [
-        ruleError(4, 5, 'alwaysTruthy'),
-        ruleError(6, 11, 'alwaysFalsy'),
-        ruleError(8, 17, 'alwaysTruthy'),
-      ],
-      output: null,
-    },
+const t1 = b1 && b2 ? 'yes' : 'no';
+for (;;) {}
+    `,
+    `
+declare function foo(): number | void;
+const result1 = foo() === undefined;
+const result2 = foo() == null;
+    `,
+    necessaryConditionTest('false | 5'), // Truthy literal and falsy literal
+    necessaryConditionTest('boolean | "foo"'), // boolean and truthy literal
+    necessaryConditionTest('0 | boolean'), // boolean and falsy literal
+    necessaryConditionTest('boolean | object'), // boolean and always-truthy type
+    necessaryConditionTest('false | object'), // always truthy type and falsy literal
+    // always falsy type and always truthy type
+    necessaryConditionTest('null | object'),
+    necessaryConditionTest('undefined | true'),
+    necessaryConditionTest('void | true'),
+    // "branded" type
+    necessaryConditionTest('string & {}'),
+    necessaryConditionTest('string & { __brand: string }'),
+    necessaryConditionTest('number & { __brand: string }'),
+    necessaryConditionTest('boolean & { __brand: string }'),
+    necessaryConditionTest('bigint & { __brand: string }'),
+    necessaryConditionTest('string & {} & { __brand: string }'),
+    necessaryConditionTest(
+      'string & { __brandA: string } & { __brandB: string }',
+    ),
+    necessaryConditionTest('string & { __brand: string } | number'),
+    necessaryConditionTest('(string | number) & { __brand: string }'),
+    necessaryConditionTest('string & ({ __brand: string } | number)'),
+    necessaryConditionTest('("" | "foo") & { __brand: string }'),
+    necessaryConditionTest(
+      '(string & { __brandA: string }) | (number & { __brandB: string })',
+    ),
+    necessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string }) & ("" | "foo"))',
+    ),
+    necessaryConditionTest(
+      '{ __brandA: string} & (({ __brandB: string } & string) | ({ __brandC: string } & number))',
+    ),
+    necessaryConditionTest(
+      '(string | number) & ("foo" | 123 | { __brandA: string })',
+    ),
+
+    necessaryConditionTest('string & string'),
+
+    necessaryConditionTest('any'), // any
+    necessaryConditionTest('unknown'), // unknown
 
     // Generic type params
-    {
-      code: `
-function test<T extends object>(t: T) {
+    `
+function test<T extends string>(t: T) {
   return t ? 'yes' : 'no';
 }
-      `,
-      errors: [ruleError(3, 10, 'alwaysTruthy')],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends false>(t: T) {
+    `,
+    `
+// Naked type param
+function test<T>(t: T) {
   return t ? 'yes' : 'no';
 }
-      `,
-      errors: [ruleError(3, 10, 'alwaysFalsy')],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends 'a' | 'b'>(t: T) {
+    `,
+    `
+// Naked type param in union
+function test<T>(t: T | []) {
   return t ? 'yes' : 'no';
 }
-      `,
-      errors: [ruleError(3, 10, 'alwaysTruthy')],
-      output: null,
-    },
+    `,
 
     // Boolean expressions
-    {
-      code: `
-function test(a: 'a') {
-  return a === 'a';
-}
-      `,
-      errors: [ruleError(3, 10, 'literalBooleanExpression')],
-      output: null,
-    },
-    {
-      code: `
-const y = 1;
-if (y === 0) {
-}
-      `,
-      errors: [ruleError(3, 5, 'literalBooleanExpression')],
-      output: null,
-    },
-    {
-      code: `
-enum Foo {
-  a = 1,
-  b = 2,
-}
-
-const x = Foo.a;
-if (x === Foo.a) {
-}
-      `,
-      errors: [ruleError(8, 5, 'literalBooleanExpression')],
-      output: null,
-    },
-    // Workaround https://github.com/microsoft/TypeScript/issues/37160
-    {
-      code: `
+    `
 function test(a: string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
+  const t1 = a === 'a';
+  const t2 = 'a' === a;
 }
-      `,
-      errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
-      ],
-      output: null,
-    },
-    {
-      code: `
+    `,
+    `
 function test(a?: string) {
   const t1 = a === undefined;
   const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
+  const t1 = a !== undefined;
+  const t2 = undefined !== a;
 }
-      `,
-      errors: [
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
-      ],
-      output: null,
-    },
-    {
-      code: `
+    `,
+    `
 function test(a: null | string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t3 = a !== undefined;
-  const t4 = undefined !== a;
-  const t5 = a === null;
-  const t6 = null === a;
-  const t7 = a !== null;
-  const t8 = null !== a;
+  const t1 = a === null;
+  const t2 = null === a;
+  const t1 = a !== null;
+  const t2 = null !== a;
 }
-      `,
-      errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
-      ],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends object>(a: T) {
+    `,
+    `
+function test(a?: null | string) {
   const t1 = a == null;
   const t2 = null == a;
   const t3 = a != null;
@@ -260,2055 +175,2140 @@ function test<T extends object>(a: T) {
   const t6 = undefined == a;
   const t7 = a != undefined;
   const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
+}
+    `,
+    `
+function test(a?: string) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+}
+    `,
+    `
+function test(a: null | string) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+}
+    `,
+    `
+function test(a: any) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
   const t16 = undefined !== a;
 }
-      `,
-      errors: [
-        ruleError(3, 14, 'noOverlapBooleanExpression'),
-        ruleError(4, 14, 'noOverlapBooleanExpression'),
-        ruleError(5, 14, 'noOverlapBooleanExpression'),
-        ruleError(6, 14, 'noOverlapBooleanExpression'),
-        ruleError(7, 14, 'noOverlapBooleanExpression'),
-        ruleError(8, 14, 'noOverlapBooleanExpression'),
-        ruleError(9, 14, 'noOverlapBooleanExpression'),
-        ruleError(10, 14, 'noOverlapBooleanExpression'),
-        ruleError(11, 14, 'noOverlapBooleanExpression'),
-        ruleError(12, 15, 'noOverlapBooleanExpression'),
-        ruleError(13, 15, 'noOverlapBooleanExpression'),
-        ruleError(14, 15, 'noOverlapBooleanExpression'),
-        ruleError(15, 15, 'noOverlapBooleanExpression'),
-        ruleError(16, 15, 'noOverlapBooleanExpression'),
-        ruleError(17, 15, 'noOverlapBooleanExpression'),
-        ruleError(18, 15, 'noOverlapBooleanExpression'),
-      ],
-      output: null,
-    },
+    `,
+    `
+function test(a: unknown) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
+}
+    `,
+    `
+function test<T>(a: T) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
+}
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] == null;
+}
+    `,
+
+    // Predicate functions
+    `
+// with literal arrow function
+[0, 1, 2].filter(x => x);
+
+// filter with named function
+function length(x: string) {
+  return x.length;
+}
+['a', 'b', ''].filter(length);
+
+// with non-literal array
+function nonEmptyStrings(x: string[]) {
+  return x.filter(length);
+}
+
+// filter-like predicate
+function count(
+  list: string[],
+  predicate: (value: string, index: number, array: string[]) => unknown,
+) {
+  return list.filter(predicate).length;
+}
+    `,
+    // Ignores non-array methods of the same name
+    `
+const notArray = {
+  filter: (func: () => boolean) => func(),
+  find: (func: () => boolean) => func(),
+};
+notArray.filter(() => true);
+notArray.find(() => true);
+    `,
+
     // Nullish coalescing operator
-    {
-      code: `
-function test(a: string) {
+    `
+function test(a: string | null) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'neverNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test(a: string | false) {
+    `,
+    `
+function test(a: string | undefined) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'neverNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends string>(a: T) {
+    `,
+    `
+function test(a: string | null | undefined) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'neverNullish')],
-      output: null,
-    },
-    // nullish + array index without optional chaining
-    {
-      code: `
-function test(a: { foo: string }[]) {
-  return a[0].foo ?? 'default';
-}
-      `,
-      errors: [ruleError(3, 10, 'neverNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test(a: null) {
+    `,
+    `
+function test(a: unknown) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test(a: null[]) {
-  return a[0] ?? 'default';
-}
-      `,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends null>(a: T) {
+    `,
+    `
+function test<T>(a: T) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'alwaysNullish')],
-      output: null,
-    },
-    {
-      code: `
-function test(a: never) {
+    `,
+    `
+function test<T extends string | null>(a: T) {
   return a ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 10, 'never')],
-      output: null,
-    },
-    {
-      code: `
-function test<T extends { foo: number }, K extends 'foo'>(num: T[K]) {
-  num ?? 'default';
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] ?? 'default';
 }
-      `,
-      errors: [ruleError(3, 3, 'neverNullish')],
-      output: null,
-    },
-    // Predicate functions
-    {
-      code: `
-[1, 3, 5].filter(() => true);
-[1, 2, 3].find(() => {
-  return false;
-});
+    `,
+    // Indexing cases
+    `
+declare const arr: object[];
+if (arr[42]) {
+} // looks unnecessary from the types, but isn't
 
-// with non-literal array
-function nothing(x: string[]) {
-  return x.filter(() => false);
+const tuple = [{}] as [object];
+declare const n: number;
+if (tuple[n]) {
 }
-// with readonly array
-function nothing2(x: readonly string[]) {
-  return x.filter(() => false);
-}
-// with tuple
-function nothing3(x: [string, string]) {
-  return x.filter(() => false);
-}
-      `,
-      errors: [
-        ruleError(2, 24, 'alwaysTruthy'),
-        ruleError(4, 10, 'alwaysFalsy'),
-        ruleError(9, 25, 'alwaysFalsy'),
-        ruleError(13, 25, 'alwaysFalsy'),
-        ruleError(17, 25, 'alwaysFalsy'),
-      ],
-      output: null,
-    },
-    // Indexing cases
-    {
-      // This is an error because 'dict' doesn't represent
-      //  the potential for undefined in its types
-      code: `
-declare const dict: Record<string, object>;
-if (dict['mightNotExist']) {
-}
-      `,
-      errors: [ruleError(3, 5, 'alwaysTruthy')],
-      output: null,
-    },
-    {
-      // 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) {
-}
-      `,
-      errors: [
-        ruleError(3, 5, 'alwaysTruthy'),
-        ruleError(5, 9, 'neverOptionalChain'),
-      ],
-      output: `
-const x = [{}] as [{ foo: string }];
-if (x[0]) {
+    `,
+    // Optional-chaining indexing
+    `
+declare const arr: Array<{ value: string } & (() => void)>;
+if (arr[42]?.value) {
 }
-if (x[0].foo) {
+arr[41]?.();
+
+// An array access can "infect" deeper into the chain
+declare const arr2: Array<{ x: { y: { z: object } } }>;
+arr2[42]?.x?.y?.z;
+
+const tuple = ['foo'] as const;
+declare const n: number;
+tuple[n]?.toUpperCase();
+    `,
+    `
+if (arr?.[42]) {
 }
-      `,
-    },
-    {
-      // Shouldn't mistake this for an array indexing case
-      code: `
-declare const arr: object[];
-if (arr.filter) {
+    `,
+    `
+type ItemA = { bar: string; baz: string };
+type ItemB = { bar: string; qux: string };
+declare const foo: ItemA[] | ItemB[];
+foo[0]?.bar;
+    `,
+    `
+type TupleA = [string, number];
+type TupleB = [string, number];
+
+declare const foo: TupleA | TupleB;
+declare const index: number;
+foo[index]?.toString();
+    `,
+    `
+declare const returnsArr: undefined | (() => string[]);
+if (returnsArr?.()[42]) {
 }
-      `,
-      errors: [ruleError(3, 5, 'alwaysTruthy')],
-      output: null,
-    },
+returnsArr?.()[42]?.toUpperCase();
+    `,
+    // nullish + array index
+    `
+declare const arr: string[][];
+arr[x] ?? [];
+    `,
+    // nullish + optional array index
+    `
+declare const arr: { foo: number }[];
+const bar = arr[42]?.foo ?? 0;
+    `,
+    // Doesn't check the right-hand side of a logical expression
+    //  in a non-conditional context
     {
       code: `
-function truthy() {
-  return [];
-}
-function falsy() {}
-[1, 3, 5].filter(truthy);
-[1, 2, 3].find(falsy);
+declare const b1: boolean;
+declare const b2: true;
+const x = b1 && b2;
       `,
-      errors: [
-        ruleError(6, 18, 'alwaysTruthyFunc'),
-        ruleError(7, 16, 'alwaysFalsyFunc'),
-      ],
-      output: null,
     },
-    // Supports generics
-    // TODO: fix this
-    //     {
-    //       code: `
-    // const isTruthy = <T>(t: T) => T;
-    // // Valid: numbers can be truthy or falsy (0).
-    // [0,1,2,3].filter(isTruthy);
-    // // Invalid: arrays are always falsy.
-    // [[1,2], [3,4]].filter(isTruthy);
-    // `,
-    //       errors: [ruleError(6, 23, 'alwaysTruthyFunc')],
-    //     },
     {
       code: `
 while (true) {}
 for (; true; ) {}
 do {} while (true);
       `,
-      errors: [
-        ruleError(2, 8, 'alwaysTruthy'),
-        ruleError(3, 8, 'alwaysTruthy'),
-        ruleError(4, 14, 'alwaysTruthy'),
-      ],
-      options: [{ allowConstantLoopConditions: false }],
-      output: null,
+      options: [{ allowConstantLoopConditions: true }],
     },
-    {
-      code: noFormat`
-let foo = { bar: true };
+    `
+let variable = 'abc' as string | void;
+variable?.[0];
+    `,
+    `
+let foo: undefined | { bar: true };
 foo?.bar;
-foo ?. bar;
-foo ?.
-  bar;
-foo
-  ?. bar;
-      `,
-      errors: [
-        {
-          column: 4,
-          endColumn: 6,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 5,
-          line: 5,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 3,
-          endColumn: 5,
-          endLine: 8,
-          line: 8,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-let foo = { bar: true };
-foo.bar;
-foo . bar;
-foo .
-  bar;
-foo
-  . bar;
-      `,
-    },
-    {
-      code: noFormat`
-let foo = () => {};
+    `,
+    `
+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?.();
-foo ?. ();
-foo ?.
-  ();
-foo
-  ?. ();
-      `,
-      errors: [
-        {
-          column: 4,
-          endColumn: 6,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 5,
-          line: 5,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 3,
-          endColumn: 5,
-          endLine: 8,
-          line: 8,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: noFormat`
-let foo = () => {};
-foo();
-foo  ();
-foo${' '}
-  ();
-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];',
+    `
+declare const foo: { bar?: { baz: { c: string } } } | null;
+foo?.bar?.baz;
+    `,
+    `
+foo?.bar?.baz?.qux;
+    `,
+    `
+declare const foo: { bar: { baz: string } };
+foo.bar.qux?.();
+    `,
+    `
+type Foo = { baz: number } | null;
+type Bar = { baz: null | string | { qux: string } };
+declare const foo: { fooOrBar: Foo | Bar } | null;
+foo?.fooOrBar?.baz?.qux;
+    `,
+    `
+type Foo = { [key: string]: string } | null;
+declare const foo: Foo;
+
+const key = '1';
+foo?.[key]?.trim();
+    `,
+    `
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = 'bar' | 'foo';
+declare const foo: Foo;
+declare const key: Key;
+
+foo?.[key].trim();
+    `,
+    `
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+  };
+}
+
+function Foo(outer: Outer, key: string): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
+    `,
+    `
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Foo = 'foo';
+
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
+    `,
+    `
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = 'bar' | 'foo' | 'baz';
+declare const foo: Foo;
+declare const key: Key;
+
+foo?.[key]?.trim();
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/7700
+    `
+type BrandedKey = string & { __brand: string };
+type Foo = { [key: BrandedKey]: string } | null;
+declare const foo: Foo;
+const key = '1' as BrandedKey;
+foo?.[key]?.trim();
+    `,
+    `
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key].trim();
+    `,
+    `
+type BrandedKey = string & { __brand: string };
+interface Outer {
+  inner?: {
+    [key: BrandedKey]: string | undefined;
+  };
+}
+function Foo(outer: Outer, key: BrandedKey): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
+    `,
+    `
+interface Outer {
+  inner?: {
+    [key: string & { __brand: string }]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Foo = 'foo' & { __brand: string };
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
+    `,
+    `
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key]?.trim();
+    `,
     {
-      code: noFormat`
-let foo = () => {};
-foo?.(bar);
-foo ?. (bar);
-foo ?.
-  (bar);
-foo
-  ?. (bar);
-      `,
-      errors: [
-        {
-          column: 4,
-          endColumn: 6,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 5,
-          endColumn: 7,
-          endLine: 5,
-          line: 5,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 3,
-          endColumn: 5,
-          endLine: 8,
-          line: 8,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: noFormat`
-let foo = () => {};
-foo(bar);
-foo  (bar);
-foo${' '}
-  (bar);
-foo
-   (bar);
+      code: `
+type BrandedKey = string & { __brand: string };
+type Foo = { [key: BrandedKey]: string } | null;
+declare const foo: Foo;
+const key = '1' as BrandedKey;
+foo?.[key]?.trim();
       `,
-    },
-    {
-      code: 'const foo = [1, 2, 3]?.[0];',
-      errors: [
-        {
-          column: 22,
-          endColumn: 24,
-          endLine: 1,
-          line: 1,
-          messageId: 'neverOptionalChain',
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
-      output: 'const foo = [1, 2, 3][0];',
+      },
     },
     {
       code: `
-declare const x: { a?: { b: string } };
-x?.a?.b;
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key].trim();
       `,
-      errors: [
-        {
-          column: 2,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
-      output: `
-declare const x: { a?: { b: string } };
-x.a?.b;
-      `,
+      },
     },
     {
       code: `
-declare const x: { a: { b?: { c: string } } };
-x.a?.b?.c;
-      `,
-      errors: [
-        {
-          column: 4,
-          endColumn: 6,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-declare const x: { a: { b?: { c: string } } };
-x.a.b?.c;
+type BrandedKey = string & { __brand: string };
+interface Outer {
+  inner?: {
+    [key: BrandedKey]: string | undefined;
+  };
+}
+function Foo(outer: Outer, key: BrandedKey): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
       `,
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
+      },
     },
     {
       code: `
-let x: { a?: string };
-x?.a;
+interface Outer {
+  inner?: {
+    [key: string & { __brand: string }]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Foo = 'foo' & { __brand: string };
+function Foo(outer: Outer, key: Foo): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
       `,
-      errors: [
-        {
-          column: 2,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
-      output: `
-let x: { a?: string };
-x.a;
-      `,
+      },
     },
     {
       code: `
-declare const foo: { bar: { baz: { c: string } } } | null;
-foo?.bar?.baz;
+type BrandedKey<S extends string> = S & { __brand: string };
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
+type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
+declare const foo: Foo;
+declare const key: Key;
+foo?.[key]?.trim();
       `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
-      output: `
-declare const foo: { bar: { baz: { c: string } } } | null;
-foo?.bar.baz;
-      `,
+      },
     },
+    `
+let latencies: number[][] = [];
+
+function recordData(): void {
+  if (!latencies[0]) latencies[0] = [];
+  latencies[0].push(4);
+}
+
+recordData();
+    `,
+    `
+let latencies: number[][] = [];
+
+function recordData(): void {
+  if (latencies[0]) latencies[0] = [];
+  latencies[0].push(4);
+}
+
+recordData();
+    `,
+    `
+function test(testVal?: boolean) {
+  if (testVal ?? true) {
+    console.log('test');
+  }
+}
+    `,
+    `
+declare const x: string[];
+if (!x[0]) {
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2421
+    `
+const isEven = (val: number) => val % 2 === 0;
+if (!isEven(1)) {
+}
+    `,
+    `
+declare const booleanTyped: boolean;
+declare const unknownTyped: unknown;
+
+if (!(booleanTyped || unknownTyped)) {
+}
+    `,
     {
       code: `
-declare const foo: { bar?: { baz: { qux: string } } } | null;
-foo?.bar?.baz?.qux;
+declare const x: string[] | null;
+// eslint-disable-next-line
+if (x) {
+}
       `,
-      errors: [
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      options: [
         {
-          column: 14,
-          endColumn: 16,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
         },
       ],
-      output: `
-declare const foo: { bar?: { baz: { qux: string } } } | null;
-foo?.bar?.baz.qux;
-      `,
     },
+    `
+interface Foo {
+  [key: string]: [string] | undefined;
+}
+
+type OptionalFoo = Foo | undefined;
+declare const foo: OptionalFoo;
+foo?.test?.length;
+    `,
+    `
+interface Foo {
+  [key: number]: [string] | undefined;
+}
+
+type OptionalFoo = Foo | undefined;
+declare const foo: OptionalFoo;
+foo?.[1]?.length;
+    `,
+    `
+declare let foo: number | null;
+foo ??= 1;
+    `,
+    `
+declare let foo: number;
+foo ||= 1;
+    `,
+    `
+declare const foo: { bar: { baz?: number; qux: number } };
+type Key = 'baz' | 'qux';
+declare const key: Key;
+foo.bar[key] ??= 1;
+    `,
+    `
+enum Keys {
+  A = 'A',
+  B = 'B',
+}
+type Foo = {
+  [Keys.A]: number | null;
+  [Keys.B]: number;
+};
+declare const foo: Foo;
+declare const key: Keys;
+foo[key] ??= 1;
+    `,
     {
       code: `
-declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
-foo?.bar?.baz?.qux?.();
-      `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
-foo?.bar.baz.qux?.();
+declare const foo: { bar?: number };
+foo.bar ??= 1;
       `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare const foo: { bar: { baz: { qux: () => {} } } } | null;
-foo?.bar?.baz?.qux?.();
-      `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 19,
-          endColumn: 21,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-declare const foo: { bar: { baz: { qux: () => {} } } } | null;
-foo?.bar.baz.qux();
+declare const foo: { bar: { baz?: number } };
+foo['bar'].baz ??= 1;
       `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-type baz = () => { qux: () => {} };
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.().qux?.();
-      `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 22,
-          endColumn: 24,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-type baz = () => { qux: () => {} };
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz().qux();
+declare const foo: { bar: { baz?: number; qux: number } };
+type Key = 'baz' | 'qux';
+declare const key: Key;
+foo.bar[key] ??= 1;
       `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
+    `
+declare let foo: number;
+foo &&= 1;
+    `,
+    `
+function foo<T extends object>(arg: T, key: keyof T): void {
+  arg[key] ??= 'default';
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6264
+    `
+function get<Obj, Key extends keyof Obj>(obj: Obj, key: Key) {
+  const value = obj[key];
+  if (value) {
+    return value;
+  }
+  throw new Error('BOOM!');
+}
+
+get({ foo: null }, 'foo');
+    `,
     {
       code: `
-type baz = null | (() => { qux: () => {} });
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.().qux?.();
+function getElem(dict: Record<string, { foo: string }>, key: string) {
+  if (dict[key]) {
+    return dict[key].foo;
+  } else {
+    return '';
+  }
+}
       `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 22,
-          endColumn: 24,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
         },
-      ],
-      output: `
-type baz = null | (() => { qux: () => {} });
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz?.().qux();
+      },
+    },
+    `
+type Foo = { bar: () => number | undefined } | null;
+declare const foo: Foo;
+foo?.bar()?.toExponential();
+    `,
+    `
+type Foo = (() => number | undefined) | null;
+declare const foo: Foo;
+foo?.()?.toExponential();
+    `,
+    `
+type FooUndef = () => undefined;
+type FooNum = () => number;
+type Foo = FooUndef | FooNum | null;
+declare const foo: Foo;
+foo?.()?.toExponential();
+    `,
+    `
+type Foo = { [key: string]: () => number | undefined } | null;
+declare const foo: Foo;
+foo?.['bar']()?.toExponential();
+    `,
+    {
+      code: `
+class ConsistentRand {
+  #rand?: number;
+
+  getCachedRand() {
+    this.#rand ??= Math.random();
+    return this.#rand;
+  }
+}
       `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
+  ],
+  invalid: [
+    // Ensure that it's checking in all the right places
     {
       code: `
-type baz = null | (() => { qux: () => {} } | null);
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar?.baz?.()?.qux?.();
+const b1 = true;
+declare const b2: boolean;
+const t1 = b1 && b2;
+const t2 = b1 || b2;
+if (b1 && b2) {
+}
+if (b2 && b1) {
+}
+while (b1 && b2) {}
+while (b2 && b1) {}
+for (let i = 0; b1 && b2; i++) {
+  break;
+}
+const t1 = b1 && b2 ? 'yes' : 'no';
+const t1 = b2 && b1 ? 'yes' : 'no';
       `,
       errors: [
-        {
-          column: 9,
-          endColumn: 11,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
-        {
-          column: 23,
-          endColumn: 25,
-          endLine: 4,
-          line: 4,
-          messageId: 'neverOptionalChain',
-        },
+        ruleError(4, 12, 'alwaysTruthy'),
+        ruleError(5, 12, 'alwaysTruthy'),
+        ruleError(6, 5, 'alwaysTruthy'),
+        ruleError(8, 11, 'alwaysTruthy'),
+        ruleError(10, 8, 'alwaysTruthy'),
+        ruleError(11, 14, 'alwaysTruthy'),
+        ruleError(12, 17, 'alwaysTruthy'),
+        ruleError(15, 12, 'alwaysTruthy'),
+        ruleError(16, 18, 'alwaysTruthy'),
       ],
-      output: `
-type baz = null | (() => { qux: () => {} } | null);
-declare const foo: { bar: { baz: baz } } | null;
-foo?.bar.baz?.()?.qux();
-      `,
+      output: null,
     },
+    // Ensure that it's complaining about the right things
+    unnecessaryConditionTest('object', 'alwaysTruthy'),
+    unnecessaryConditionTest('object | true', 'alwaysTruthy'),
+    unnecessaryConditionTest('"" | false', 'alwaysFalsy'), // Two falsy literals
+    unnecessaryConditionTest('"always truthy"', 'alwaysTruthy'),
+    unnecessaryConditionTest(`undefined`, 'alwaysFalsy'),
+    unnecessaryConditionTest('null', 'alwaysFalsy'),
+    unnecessaryConditionTest('void', 'alwaysFalsy'),
+    unnecessaryConditionTest('never', 'never'),
+    unnecessaryConditionTest('string & number', 'never'),
+
+    // More complex logical expressions
     {
       code: `
-type Foo = { baz: number };
-type Bar = { baz: null | string | { qux: string } };
-declare const foo: { fooOrBar: Foo | Bar } | null;
-foo?.fooOrBar?.baz?.qux;
+declare const b1: boolean;
+declare const b2: boolean;
+if (true && b1 && b2) {
+}
+if (b1 && false && b2) {
+}
+if (b1 || b2 || true) {
+}
       `,
       errors: [
-        {
-          column: 14,
-          endColumn: 16,
-          endLine: 5,
-          line: 5,
-          messageId: 'neverOptionalChain',
-        },
+        ruleError(4, 5, 'alwaysTruthy'),
+        ruleError(6, 11, 'alwaysFalsy'),
+        ruleError(8, 17, 'alwaysTruthy'),
       ],
-      output: `
-type Foo = { baz: number };
-type Bar = { baz: null | string | { qux: string } };
-declare const foo: { fooOrBar: Foo | Bar } | null;
-foo?.fooOrBar.baz?.qux;
-      `,
+      output: null,
     },
+
+    // Generic type params
     {
       code: `
-declare const x: { a: { b: number } }[];
-x[0].a?.b;
-      `,
-      errors: [ruleError(3, 7, 'neverOptionalChain')],
-      output: `
-declare const x: { a: { b: number } }[];
-x[0].a.b;
+function test<T extends object>(t: T) {
+  return t ? 'yes' : 'no';
+}
       `,
+      errors: [ruleError(3, 10, 'alwaysTruthy')],
+      output: null,
     },
     {
       code: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo';
-declare const foo: Foo;
-declare const key: Key;
-
-foo?.[key]?.trim();
-      `,
-      errors: [
-        {
-          column: 11,
-          endColumn: 13,
-          endLine: 7,
-          line: 7,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo';
-declare const foo: Foo;
-declare const key: Key;
-
-foo?.[key].trim();
+function test<T extends false>(t: T) {
+  return t ? 'yes' : 'no';
+}
       `,
+      errors: [ruleError(3, 10, 'alwaysFalsy')],
+      output: null,
     },
     {
       code: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-declare const foo: Foo;
-const key = 'bar';
-foo?.[key]?.trim();
-      `,
-      errors: [
-        {
-          column: 11,
-          endColumn: 13,
-          endLine: 5,
-          line: 5,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-declare const foo: Foo;
-const key = 'bar';
-foo?.[key].trim();
+function test<T extends 'a' | 'b'>(t: T) {
+  return t ? 'yes' : 'no';
+}
       `,
+      errors: [ruleError(3, 10, 'alwaysTruthy')],
+      output: null,
     },
+
+    // Boolean expressions
     {
       code: `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
+function test(a: 'a') {
+  return a === 'a';
 }
-
-export function test(outer: Outer): number | undefined {
-  const key = 'bar';
-  return outer.inner?.[key]?.charCodeAt(0);
+      `,
+      errors: [ruleError(3, 10, 'literalBooleanExpression')],
+      output: null,
+    },
+    {
+      code: `
+const y = 1;
+if (y === 0) {
 }
       `,
-      errors: [
-        {
-          column: 28,
-          endColumn: 30,
-          endLine: 11,
-          line: 11,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
+      errors: [ruleError(3, 5, 'literalBooleanExpression')],
+      output: null,
+    },
+    {
+      code: `
+enum Foo {
+  a = 1,
+  b = 2,
 }
 
-export function test(outer: Outer): number | undefined {
-  const key = 'bar';
-  return outer.inner?.[key].charCodeAt(0);
+const x = Foo.a;
+if (x === Foo.a) {
 }
       `,
+      errors: [ruleError(8, 5, 'literalBooleanExpression')],
+      output: null,
     },
+    // Workaround https://github.com/microsoft/TypeScript/issues/37160
     {
       code: `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Bar = 'bar';
-
-function Foo(outer: Outer, key: Bar): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
+function test(a: string) {
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
       `,
       errors: [
-        {
-          column: 28,
-          endColumn: 30,
-          endLine: 11,
-          line: 11,
-          messageId: 'neverOptionalChain',
-        },
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
       ],
-      output: `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Bar = 'bar';
-
-function Foo(outer: Outer, key: Bar): number | undefined {
-  return outer.inner?.[key].charCodeAt(0);
+      output: null,
+    },
+    {
+      code: `
+function test(a?: string) {
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
       `,
+      errors: [
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
+      ],
+      output: null,
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2384
     {
       code: `
-function test(testVal?: true) {
-  if (testVal ?? true) {
-    console.log('test');
-  }
+function test(a: null | string) {
+  const t1 = a === undefined;
+  const t2 = undefined === a;
+  const t3 = a !== undefined;
+  const t4 = undefined !== a;
+  const t5 = a === null;
+  const t6 = null === a;
+  const t7 = a !== null;
+  const t8 = null !== a;
 }
       `,
       errors: [
-        {
-          column: 7,
-          endColumn: 22,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysTruthy',
-        },
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
       ],
       output: null,
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2255
     {
       code: `
-const a = null;
-if (!a) {
+function test<T extends object>(a: T) {
+  const t1 = a == null;
+  const t2 = null == a;
+  const t3 = a != null;
+  const t4 = null != a;
+  const t5 = a == undefined;
+  const t6 = undefined == a;
+  const t7 = a != undefined;
+  const t8 = undefined != a;
+  const t9 = a === null;
+  const t10 = null === a;
+  const t11 = a !== null;
+  const t12 = null !== a;
+  const t13 = a === undefined;
+  const t14 = undefined === a;
+  const t15 = a !== undefined;
+  const t16 = undefined !== a;
 }
       `,
-      errors: [ruleError(3, 6, 'alwaysTruthy')],
+      errors: [
+        ruleError(3, 14, 'noOverlapBooleanExpression'),
+        ruleError(4, 14, 'noOverlapBooleanExpression'),
+        ruleError(5, 14, 'noOverlapBooleanExpression'),
+        ruleError(6, 14, 'noOverlapBooleanExpression'),
+        ruleError(7, 14, 'noOverlapBooleanExpression'),
+        ruleError(8, 14, 'noOverlapBooleanExpression'),
+        ruleError(9, 14, 'noOverlapBooleanExpression'),
+        ruleError(10, 14, 'noOverlapBooleanExpression'),
+        ruleError(11, 14, 'noOverlapBooleanExpression'),
+        ruleError(12, 15, 'noOverlapBooleanExpression'),
+        ruleError(13, 15, 'noOverlapBooleanExpression'),
+        ruleError(14, 15, 'noOverlapBooleanExpression'),
+        ruleError(15, 15, 'noOverlapBooleanExpression'),
+        ruleError(16, 15, 'noOverlapBooleanExpression'),
+        ruleError(17, 15, 'noOverlapBooleanExpression'),
+        ruleError(18, 15, 'noOverlapBooleanExpression'),
+      ],
       output: null,
     },
+    // Nullish coalescing operator
     {
       code: `
-const a = true;
-if (!a) {
+function test(a: string) {
+  return a ?? 'default';
 }
       `,
-      errors: [ruleError(3, 6, 'alwaysFalsy')],
+      errors: [ruleError(3, 10, 'neverNullish')],
       output: null,
     },
     {
       code: `
-function sayHi(): void {
-  console.log('Hi!');
-}
-
-let speech: never = sayHi();
-if (!speech) {
+function test(a: string | false) {
+  return a ?? 'default';
 }
       `,
-      errors: [ruleError(7, 6, 'never')],
+      errors: [ruleError(3, 10, 'neverNullish')],
       output: null,
     },
     {
       code: `
-declare const x: string[] | null;
-if (x) {
+function test<T extends string>(a: T) {
+  return a ?? 'default';
 }
       `,
-      errors: [
-        {
-          column: 1,
-          line: 0,
-          messageId: 'noStrictNullCheck',
-        },
-        {
-          column: 5,
-          line: 3,
-          messageId: 'alwaysTruthy',
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
+      errors: [ruleError(3, 10, 'neverNullish')],
       output: null,
     },
+    // nullish + array index without optional chaining
     {
       code: `
-interface Foo {
-  test: string;
-  [key: string]: [string] | undefined;
+function test(a: { foo: string }[]) {
+  return a[0].foo ?? 'default';
 }
-
-type OptionalFoo = Foo | undefined;
-declare const foo: OptionalFoo;
-foo?.test?.length;
       `,
-      errors: [
-        {
-          column: 10,
-          endColumn: 12,
-          endLine: 9,
-          line: 9,
-          messageId: 'neverOptionalChain',
-        },
-      ],
-      output: `
-interface Foo {
-  test: string;
-  [key: string]: [string] | undefined;
+      errors: [ruleError(3, 10, 'neverNullish')],
+      output: null,
+    },
+    {
+      code: `
+function test(a: null) {
+  return a ?? 'default';
 }
-
-type OptionalFoo = Foo | undefined;
-declare const foo: OptionalFoo;
-foo?.test.length;
       `,
+      errors: [ruleError(3, 10, 'alwaysNullish')],
+      output: null,
     },
     {
       code: `
-function pick<Obj extends Record<string, 1 | 2 | 3>, Key extends keyof Obj>(
-  obj: Obj,
-  key: Key,
-): Obj[Key] {
-  const k = obj[key];
-  if (obj[key]) {
-    return obj[key];
-  }
-  throw new Error('Boom!');
+function test(a: null[]) {
+  return a[0] ?? 'default';
 }
-
-pick({ foo: 1, bar: 2 }, 'bar');
       `,
-      errors: [
-        {
-          column: 7,
-          endColumn: 15,
-          endLine: 7,
-          line: 7,
-          messageId: 'alwaysTruthy',
-        },
-      ],
+      errors: [ruleError(3, 10, 'alwaysNullish')],
       output: null,
     },
     {
       code: `
-function getElem(dict: Record<string, { foo: string }>, key: string) {
-  if (dict[key]) {
-    return dict[key].foo;
-  } else {
-    return '';
-  }
+function test<T extends null>(a: T) {
+  return a ?? 'default';
 }
       `,
-      errors: [
-        {
-          column: 7,
-          endColumn: 16,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysTruthy',
-        },
-      ],
+      errors: [ruleError(3, 10, 'alwaysNullish')],
       output: null,
     },
     {
       code: `
-declare let foo: {};
-foo ??= 1;
+function test(a: never) {
+  return a ?? 'default';
+}
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverNullish',
-        },
-      ],
+      errors: [ruleError(3, 10, 'never')],
       output: null,
     },
     {
       code: `
-declare let foo: number;
-foo ??= 1;
+function test<T extends { foo: number }, K extends 'foo'>(num: T[K]) {
+  num ?? 'default';
+}
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverNullish',
-        },
-      ],
+      errors: [ruleError(3, 3, 'neverNullish')],
       output: null,
     },
+    // Predicate functions
     {
       code: `
-declare let foo: null;
-foo ??= null;
+[1, 3, 5].filter(() => true);
+[1, 2, 3].find(() => {
+  return false;
+});
+
+// with non-literal array
+function nothing(x: string[]) {
+  return x.filter(() => false);
+}
+// with readonly array
+function nothing2(x: readonly string[]) {
+  return x.filter(() => false);
+}
+// with tuple
+function nothing3(x: [string, string]) {
+  return x.filter(() => false);
+}
       `,
       errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysNullish',
-        },
+        ruleError(2, 24, 'alwaysTruthy'),
+        ruleError(4, 10, 'alwaysFalsy'),
+        ruleError(9, 25, 'alwaysFalsy'),
+        ruleError(13, 25, 'alwaysFalsy'),
+        ruleError(17, 25, 'alwaysFalsy'),
       ],
       output: null,
     },
+    // Indexing cases
     {
+      // This is an error because 'dict' doesn't represent
+      //  the potential for undefined in its types
       code: `
-declare let foo: {};
-foo ||= 1;
+declare const dict: Record<string, object>;
+if (dict['mightNotExist']) {
+}
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysTruthy',
-        },
-      ],
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
       output: null,
     },
     {
+      // Should still check tuples when accessed with literal numbers, since they don't have
+      //   unsound index signatures
       code: `
-declare let foo: null;
-foo ||= null;
+const x = [{}] as [{ foo: string }];
+if (x[0]) {
+}
+if (x[0]?.foo) {
+}
       `,
       errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysFalsy',
-        },
+        ruleError(3, 5, 'alwaysTruthy'),
+        ruleError(5, 9, 'neverOptionalChain'),
       ],
-      output: null,
+      output: `
+const x = [{}] as [{ foo: string }];
+if (x[0]) {
+}
+if (x[0].foo) {
+}
+      `,
     },
     {
+      // Shouldn't mistake this for an array indexing case
       code: `
-declare let foo: {};
-foo &&= 1;
+declare const arr: object[];
+if (arr.filter) {
+}
       `,
-      errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysTruthy',
-        },
-      ],
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
       output: null,
     },
     {
       code: `
-declare let foo: null;
-foo &&= null;
+function truthy() {
+  return [];
+}
+function falsy() {}
+[1, 3, 5].filter(truthy);
+[1, 2, 3].find(falsy);
       `,
       errors: [
-        {
-          column: 1,
-          endColumn: 4,
-          endLine: 3,
-          line: 3,
-          messageId: 'alwaysFalsy',
-        },
+        ruleError(6, 18, 'alwaysTruthyFunc'),
+        ruleError(7, 16, 'alwaysFalsyFunc'),
       ],
       output: null,
     },
+    // Supports generics
+    // TODO: fix this
+    //     {
+    //       code: `
+    // const isTruthy = <T>(t: T) => T;
+    // // Valid: numbers can be truthy or falsy (0).
+    // [0,1,2,3].filter(isTruthy);
+    // // Invalid: arrays are always falsy.
+    // [[1,2], [3,4]].filter(isTruthy);
+    // `,
+    //       errors: [ruleError(6, 23, 'alwaysTruthyFunc')],
+    //     },
     {
       code: `
-declare const foo: { bar: number };
-foo.bar ??= 1;
+while (true) {}
+for (; true; ) {}
+do {} while (true);
       `,
       errors: [
-        {
-          column: 1,
-          endColumn: 8,
-          endLine: 3,
-          line: 3,
-          messageId: 'neverNullish',
-        },
+        ruleError(2, 8, 'alwaysTruthy'),
+        ruleError(3, 8, 'alwaysTruthy'),
+        ruleError(4, 14, 'alwaysTruthy'),
       ],
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      options: [{ allowConstantLoopConditions: false }],
       output: null,
     },
     {
       code: noFormat`
-type Foo = { bar: () => number } | null;
-declare const foo: Foo;
-foo?.bar()?.toExponential();
+let foo = { bar: true };
+foo?.bar;
+foo ?. bar;
+foo ?.
+  bar;
+foo
+  ?. bar;
       `,
       errors: [
         {
-          column: 11,
-          endColumn: 13,
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
           endLine: 4,
           line: 4,
           messageId: 'neverOptionalChain',
         },
-      ],
-      output: noFormat`
-type Foo = { bar: () => number } | null;
-declare const foo: Foo;
-foo?.bar().toExponential();
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+let foo = { bar: true };
+foo.bar;
+foo . bar;
+foo .
+  bar;
+foo
+  . bar;
       `,
     },
     {
       code: noFormat`
-type Foo = { bar: null | { baz: () => { qux: number } } } | null;
-declare const foo: Foo;
-foo?.bar?.baz()?.qux?.toExponential();
+let foo = () => {};
+foo?.();
+foo ?. ();
+foo ?.
+  ();
+foo
+  ?. ();
       `,
       errors: [
         {
-          column: 16,
-          endColumn: 18,
-          endLine: 4,
-          line: 4,
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
           messageId: 'neverOptionalChain',
         },
         {
-          column: 21,
-          endColumn: 23,
+          column: 5,
+          endColumn: 7,
           endLine: 4,
           line: 4,
           messageId: 'neverOptionalChain',
         },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
       ],
       output: noFormat`
-type Foo = { bar: null | { baz: () => { qux: number } } } | null;
-declare const foo: Foo;
-foo?.bar?.baz().qux.toExponential();
+let foo = () => {};
+foo();
+foo  ();
+foo${' '}
+  ();
+foo
+   ();
       `,
     },
     {
       code: noFormat`
-type Foo = (() => number) | null;
-declare const foo: Foo;
-foo?.()?.toExponential();
+let foo = () => {};
+foo?.(bar);
+foo ?. (bar);
+foo ?.
+  (bar);
+foo
+  ?. (bar);
       `,
       errors: [
         {
-          column: 8,
-          endColumn: 10,
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 5,
+          endColumn: 7,
           endLine: 4,
           line: 4,
           messageId: 'neverOptionalChain',
         },
+        {
+          column: 5,
+          endColumn: 7,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 3,
+          endColumn: 5,
+          endLine: 8,
+          line: 8,
+          messageId: 'neverOptionalChain',
+        },
       ],
       output: noFormat`
-type Foo = (() => number) | null;
-declare const foo: Foo;
-foo?.().toExponential();
+let foo = () => {};
+foo(bar);
+foo  (bar);
+foo${' '}
+  (bar);
+foo
+   (bar);
       `,
     },
     {
-      code: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']()?.toExponential();
+      code: 'const foo = [1, 2, 3]?.[0];',
+      errors: [
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 1,
+          line: 1,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: 'const foo = [1, 2, 3][0];',
+    },
+    {
+      code: `
+declare const x: { a?: { b: string } };
+x?.a?.b;
       `,
       errors: [
         {
-          column: 15,
-          endColumn: 17,
-          endLine: 4,
-          line: 4,
+          column: 2,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
           messageId: 'neverOptionalChain',
         },
       ],
-      output: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']().toExponential();
+      output: `
+declare const x: { a?: { b: string } };
+x.a?.b;
       `,
     },
     {
-      code: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']?.()?.toExponential();
+      code: `
+declare const x: { a: { b?: { c: string } } };
+x.a?.b?.c;
       `,
       errors: [
         {
-          column: 17,
-          endColumn: 19,
-          endLine: 4,
-          line: 4,
+          column: 4,
+          endColumn: 6,
+          endLine: 3,
+          line: 3,
           messageId: 'neverOptionalChain',
         },
       ],
-      output: noFormat`
-type Foo = { [key: string]: () => number } | null;
-declare const foo: Foo;
-foo?.['bar']?.().toExponential();
+      output: `
+declare const x: { a: { b?: { c: string } } };
+x.a.b?.c;
+      `,
+    },
+    {
+      code: `
+let x: { a?: string };
+x?.a;
+      `,
+      errors: [
+        {
+          column: 2,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+let x: { a?: string };
+x.a;
       `,
     },
-
-    // "branded" types
-    unnecessaryConditionTest('"" & {}', 'alwaysFalsy'),
-    unnecessaryConditionTest('"" & { __brand: string }', 'alwaysFalsy'),
-    unnecessaryConditionTest(
-      '("" | false) & { __brand: string }',
-      'alwaysFalsy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & ""',
-      'alwaysFalsy',
-    ),
-    unnecessaryConditionTest(
-      '("foo" | "bar") & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '(123 | true) & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '(string | number) & ("foo" | 123) & { __brand: string }',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & "foo"',
-      'alwaysTruthy',
-    ),
-    unnecessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string })) & ("foo" | 123)',
-      'alwaysTruthy',
-    ),
-  ],
-  valid: [
-    `
-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';
-for (;;) {}
-    `,
-    `
-declare function foo(): number | void;
-const result1 = foo() === undefined;
-const result2 = foo() == null;
-    `,
-    necessaryConditionTest('false | 5'), // Truthy literal and falsy literal
-    necessaryConditionTest('boolean | "foo"'), // boolean and truthy literal
-    necessaryConditionTest('0 | boolean'), // boolean and falsy literal
-    necessaryConditionTest('boolean | object'), // boolean and always-truthy type
-    necessaryConditionTest('false | object'), // always truthy type and falsy literal
-    // always falsy type and always truthy type
-    necessaryConditionTest('null | object'),
-    necessaryConditionTest('undefined | true'),
-    necessaryConditionTest('void | true'),
-    // "branded" type
-    necessaryConditionTest('string & {}'),
-    necessaryConditionTest('string & { __brand: string }'),
-    necessaryConditionTest('number & { __brand: string }'),
-    necessaryConditionTest('boolean & { __brand: string }'),
-    necessaryConditionTest('bigint & { __brand: string }'),
-    necessaryConditionTest('string & {} & { __brand: string }'),
-    necessaryConditionTest(
-      'string & { __brandA: string } & { __brandB: string }',
-    ),
-    necessaryConditionTest('string & { __brand: string } | number'),
-    necessaryConditionTest('(string | number) & { __brand: string }'),
-    necessaryConditionTest('string & ({ __brand: string } | number)'),
-    necessaryConditionTest('("" | "foo") & { __brand: string }'),
-    necessaryConditionTest(
-      '(string & { __brandA: string }) | (number & { __brandB: string })',
-    ),
-    necessaryConditionTest(
-      '((string & { __brandA: string }) | (number & { __brandB: string }) & ("" | "foo"))',
-    ),
-    necessaryConditionTest(
-      '{ __brandA: string} & (({ __brandB: string } & string) | ({ __brandC: string } & number))',
-    ),
-    necessaryConditionTest(
-      '(string | number) & ("foo" | 123 | { __brandA: string })',
-    ),
-
-    necessaryConditionTest('string & string'),
-
-    necessaryConditionTest('any'), // any
-    necessaryConditionTest('unknown'), // unknown
-
-    // Generic type params
-    `
-function test<T extends string>(t: T) {
-  return t ? 'yes' : 'no';
-}
-    `,
-    `
-// Naked type param
-function test<T>(t: T) {
-  return t ? 'yes' : 'no';
-}
-    `,
-    `
-// Naked type param in union
-function test<T>(t: T | []) {
-  return t ? 'yes' : 'no';
-}
-    `,
-
-    // Boolean expressions
-    `
-function test(a: string) {
-  const t1 = a === 'a';
-  const t2 = 'a' === a;
-}
-    `,
-    `
-function test(a?: string) {
-  const t1 = a === undefined;
-  const t2 = undefined === a;
-  const t1 = a !== undefined;
-  const t2 = undefined !== a;
-}
-    `,
-    `
-function test(a: null | string) {
-  const t1 = a === null;
-  const t2 = null === a;
-  const t1 = a !== null;
-  const t2 = null !== a;
-}
-    `,
-    `
-function test(a?: null | string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a?: string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a: null | string) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-}
-    `,
-    `
-function test(a: any) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
-}
-    `,
-    `
-function test(a: unknown) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
-}
-    `,
-    `
-function test<T>(a: T) {
-  const t1 = a == null;
-  const t2 = null == a;
-  const t3 = a != null;
-  const t4 = null != a;
-  const t5 = a == undefined;
-  const t6 = undefined == a;
-  const t7 = a != undefined;
-  const t8 = undefined != a;
-  const t9 = a === null;
-  const t10 = null === a;
-  const t11 = a !== null;
-  const t12 = null !== a;
-  const t13 = a === undefined;
-  const t14 = undefined === a;
-  const t15 = a !== undefined;
-  const t16 = undefined !== a;
-}
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] == null;
-}
-    `,
-
-    // Predicate functions
-    `
-// with literal arrow function
-[0, 1, 2].filter(x => x);
-
-// filter with named function
-function length(x: string) {
-  return x.length;
-}
-['a', 'b', ''].filter(length);
-
-// with non-literal array
-function nonEmptyStrings(x: string[]) {
-  return x.filter(length);
-}
-
-// filter-like predicate
-function count(
-  list: string[],
-  predicate: (value: string, index: number, array: string[]) => unknown,
-) {
-  return list.filter(predicate).length;
-}
-    `,
-    // Ignores non-array methods of the same name
-    `
-const notArray = {
-  filter: (func: () => boolean) => func(),
-  find: (func: () => boolean) => func(),
-};
-notArray.filter(() => true);
-notArray.find(() => true);
-    `,
-
-    // Nullish coalescing operator
-    `
-function test(a: string | null) {
-  return a ?? 'default';
-}
-    `,
-    `
-function test(a: string | undefined) {
-  return a ?? 'default';
-}
-    `,
-    `
-function test(a: string | null | undefined) {
-  return a ?? 'default';
-}
-    `,
-    `
-function test(a: unknown) {
-  return a ?? 'default';
-}
-    `,
-    `
-function test<T>(a: T) {
-  return a ?? 'default';
-}
-    `,
-    `
-function test<T extends string | null>(a: T) {
-  return a ?? 'default';
-}
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] ?? 'default';
-}
-    `,
-    // Indexing cases
-    `
-declare const arr: object[];
-if (arr[42]) {
-} // looks unnecessary from the types, but isn't
-
-const tuple = [{}] as [object];
-declare const n: number;
-if (tuple[n]) {
-}
-    `,
-    // Optional-chaining indexing
-    `
-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 } } }>;
-arr2[42]?.x?.y?.z;
-
-const tuple = ['foo'] as const;
-declare const n: number;
-tuple[n]?.toUpperCase();
-    `,
-    `
-if (arr?.[42]) {
-}
-    `,
-    `
-type ItemA = { bar: string; baz: string };
-type ItemB = { bar: string; qux: string };
-declare const foo: ItemA[] | ItemB[];
-foo[0]?.bar;
-    `,
-    `
-type TupleA = [string, number];
-type TupleB = [string, number];
-
-declare const foo: TupleA | TupleB;
-declare const index: number;
-foo[index]?.toString();
-    `,
-    `
-declare const returnsArr: undefined | (() => string[]);
-if (returnsArr?.()[42]) {
-}
-returnsArr?.()[42]?.toUpperCase();
-    `,
-    // nullish + array index
-    `
-declare const arr: string[][];
-arr[x] ?? [];
-    `,
-    // nullish + optional array index
-    `
-declare const arr: { foo: number }[];
-const bar = arr[42]?.foo ?? 0;
-    `,
-    // Doesn't check the right-hand side of a logical expression
-    //  in a non-conditional context
     {
       code: `
-declare const b1: boolean;
-declare const b2: true;
-const x = b1 && b2;
+declare const foo: { bar: { baz: { c: string } } } | null;
+foo?.bar?.baz;
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { c: string } } } | null;
+foo?.bar.baz;
       `,
     },
     {
       code: `
-while (true) {}
-for (; true; ) {}
-do {} while (true);
+declare const foo: { bar?: { baz: { qux: string } } } | null;
+foo?.bar?.baz?.qux;
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar?: { baz: { qux: string } } } | null;
+foo?.bar?.baz.qux;
       `,
-      options: [{ allowConstantLoopConditions: true }],
     },
-    `
-let variable = 'abc' as string | void;
-variable?.[0];
-    `,
-    `
-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];',
-    `
-declare const foo: { bar?: { baz: { c: string } } } | null;
-foo?.bar?.baz;
-    `,
-    `
-foo?.bar?.baz?.qux;
-    `,
-    `
-declare const foo: { bar: { baz: string } };
-foo.bar.qux?.();
-    `,
-    `
-type Foo = { baz: number } | null;
+    {
+      code: `
+declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
+foo?.bar?.baz?.qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { qux?: () => {} } } } | null;
+foo?.bar.baz.qux?.();
+      `,
+    },
+    {
+      code: `
+declare const foo: { bar: { baz: { qux: () => {} } } } | null;
+foo?.bar?.baz?.qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 19,
+          endColumn: 21,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+declare const foo: { bar: { baz: { qux: () => {} } } } | null;
+foo?.bar.baz.qux();
+      `,
+    },
+    {
+      code: `
+type baz = () => { qux: () => {} };
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.().qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type baz = () => { qux: () => {} };
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz().qux();
+      `,
+    },
+    {
+      code: `
+type baz = null | (() => { qux: () => {} });
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.().qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 22,
+          endColumn: 24,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type baz = null | (() => { qux: () => {} });
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz?.().qux();
+      `,
+    },
+    {
+      code: `
+type baz = null | (() => { qux: () => {} } | null);
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar?.baz?.()?.qux?.();
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 11,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 23,
+          endColumn: 25,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type baz = null | (() => { qux: () => {} } | null);
+declare const foo: { bar: { baz: baz } } | null;
+foo?.bar.baz?.()?.qux();
+      `,
+    },
+    {
+      code: `
+type Foo = { baz: number };
 type Bar = { baz: null | string | { qux: string } };
 declare const foo: { fooOrBar: Foo | Bar } | null;
 foo?.fooOrBar?.baz?.qux;
-    `,
-    `
-type Foo = { [key: string]: string } | null;
-declare const foo: Foo;
-
-const key = '1';
-foo?.[key]?.trim();
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 16,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
+type Foo = { baz: number };
+type Bar = { baz: null | string | { qux: string } };
+declare const foo: { fooOrBar: Foo | Bar } | null;
+foo?.fooOrBar.baz?.qux;
+      `,
+    },
+    {
+      code: `
+declare const x: { a: { b: number } }[];
+x[0].a?.b;
+      `,
+      errors: [ruleError(3, 7, 'neverOptionalChain')],
+      output: `
+declare const x: { a: { b: number } }[];
+x[0].a.b;
+      `,
+    },
+    {
+      code: `
 type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
 type Key = 'bar' | 'foo';
 declare const foo: Foo;
 declare const key: Key;
 
-foo?.[key].trim();
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-  };
-}
-
-function Foo(outer: Outer, key: string): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Foo = 'foo';
-
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = 'bar' | 'foo' | 'baz';
-declare const foo: Foo;
-declare const key: Key;
-
-foo?.[key]?.trim();
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/7700
-    `
-type BrandedKey = string & { __brand: string };
-type Foo = { [key: BrandedKey]: string } | null;
-declare const foo: Foo;
-const key = '1' as BrandedKey;
 foo?.[key]?.trim();
-    `,
-    `
-type BrandedKey<S extends string> = S & { __brand: string };
+      `,
+      errors: [
+        {
+          column: 11,
+          endColumn: 13,
+          endLine: 7,
+          line: 7,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
 type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
+type Key = 'bar' | 'foo';
 declare const foo: Foo;
 declare const key: Key;
+
 foo?.[key].trim();
-    `,
-    `
-type BrandedKey = string & { __brand: string };
-interface Outer {
-  inner?: {
-    [key: BrandedKey]: string | undefined;
-  };
-}
-function Foo(outer: Outer, key: BrandedKey): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-interface Outer {
-  inner?: {
-    [key: string & { __brand: string }]: string | undefined;
-    bar: 'bar';
-  };
-}
-type Foo = 'foo' & { __brand: string };
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
-}
-    `,
-    `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key]?.trim();
-    `,
+      `,
+    },
     {
       code: `
-type BrandedKey = string & { __brand: string };
-type Foo = { [key: BrandedKey]: string } | null;
+type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
 declare const foo: Foo;
-const key = '1' as BrandedKey;
+const key = 'bar';
 foo?.[key]?.trim();
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 11,
+          endColumn: 13,
+          endLine: 5,
+          line: 5,
+          messageId: 'neverOptionalChain',
         },
-      },
-    },
-    {
-      code: `
-type BrandedKey<S extends string> = S & { __brand: string };
+      ],
+      output: `
 type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'>;
 declare const foo: Foo;
-declare const key: Key;
+const key = 'bar';
 foo?.[key].trim();
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
-        },
-      },
     },
     {
       code: `
-type BrandedKey = string & { __brand: string };
 interface Outer {
   inner?: {
-    [key: BrandedKey]: string | undefined;
+    [key: string]: string | undefined;
+    bar: 'bar';
   };
 }
-function Foo(outer: Outer, key: BrandedKey): number | undefined {
+
+export function test(outer: Outer): number | undefined {
+  const key = 'bar';
   return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 28,
+          endColumn: 30,
+          endLine: 11,
+          line: 11,
+          messageId: 'neverOptionalChain',
         },
-      },
-    },
-    {
-      code: `
+      ],
+      output: `
 interface Outer {
   inner?: {
-    [key: string & { __brand: string }]: string | undefined;
+    [key: string]: string | undefined;
     bar: 'bar';
   };
 }
-type Foo = 'foo' & { __brand: string };
-function Foo(outer: Outer, key: Foo): number | undefined {
-  return outer.inner?.[key]?.charCodeAt(0);
+
+export function test(outer: Outer): number | undefined {
+  const key = 'bar';
+  return outer.inner?.[key].charCodeAt(0);
 }
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
-        },
-      },
     },
     {
       code: `
-type BrandedKey<S extends string> = S & { __brand: string };
-type Foo = { [key: string]: string; foo: 'foo'; bar: 'bar' } | null;
-type Key = BrandedKey<'bar'> | BrandedKey<'foo'> | BrandedKey<'baz'>;
-declare const foo: Foo;
-declare const key: Key;
-foo?.[key]?.trim();
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
+}
+type Bar = 'bar';
+
+function Foo(outer: Outer, key: Bar): number | undefined {
+  return outer.inner?.[key]?.charCodeAt(0);
+}
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 28,
+          endColumn: 30,
+          endLine: 11,
+          line: 11,
+          messageId: 'neverOptionalChain',
         },
-      },
-    },
-    `
-let latencies: number[][] = [];
-
-function recordData(): void {
-  if (!latencies[0]) latencies[0] = [];
-  latencies[0].push(4);
+      ],
+      output: `
+interface Outer {
+  inner?: {
+    [key: string]: string | undefined;
+    bar: 'bar';
+  };
 }
+type Bar = 'bar';
 
-recordData();
-    `,
-    `
-let latencies: number[][] = [];
-
-function recordData(): void {
-  if (latencies[0]) latencies[0] = [];
-  latencies[0].push(4);
+function Foo(outer: Outer, key: Bar): number | undefined {
+  return outer.inner?.[key].charCodeAt(0);
 }
-
-recordData();
-    `,
-    `
-function test(testVal?: boolean) {
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2384
+    {
+      code: `
+function test(testVal?: true) {
   if (testVal ?? true) {
     console.log('test');
   }
 }
-    `,
-    `
-declare const x: string[];
-if (!x[0]) {
+      `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 22,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      output: null,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2255
+    {
+      code: `
+const a = null;
+if (!a) {
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2421
-    `
-const isEven = (val: number) => val % 2 === 0;
-if (!isEven(1)) {
+      `,
+      errors: [ruleError(3, 6, 'alwaysTruthy')],
+      output: null,
+    },
+    {
+      code: `
+const a = true;
+if (!a) {
+}
+      `,
+      errors: [ruleError(3, 6, 'alwaysFalsy')],
+      output: null,
+    },
+    {
+      code: `
+function sayHi(): void {
+  console.log('Hi!');
 }
-    `,
-    `
-declare const booleanTyped: boolean;
-declare const unknownTyped: unknown;
 
-if (!(booleanTyped || unknownTyped)) {
+let speech: never = sayHi();
+if (!speech) {
 }
-    `,
+      `,
+      errors: [ruleError(7, 6, 'never')],
+      output: null,
+    },
     {
       code: `
 declare const x: string[] | null;
-// eslint-disable-next-line
 if (x) {
 }
       `,
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
+        },
+        {
+          column: 5,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
       languageOptions: {
         parserOptions: {
           tsconfigRootDir: path.join(rootPath, 'unstrict'),
         },
       },
-      options: [
-        {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
-        },
-      ],
+      output: null,
     },
-    `
+    {
+      code: `
 interface Foo {
+  test: string;
   [key: string]: [string] | undefined;
 }
 
 type OptionalFoo = Foo | undefined;
 declare const foo: OptionalFoo;
 foo?.test?.length;
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 10,
+          endColumn: 12,
+          endLine: 9,
+          line: 9,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: `
 interface Foo {
-  [key: number]: [string] | undefined;
+  test: string;
+  [key: string]: [string] | undefined;
 }
 
 type OptionalFoo = Foo | undefined;
 declare const foo: OptionalFoo;
-foo?.[1]?.length;
-    `,
-    `
-declare let foo: number | null;
+foo?.test.length;
+      `,
+    },
+    {
+      code: `
+function pick<Obj extends Record<string, 1 | 2 | 3>, Key extends keyof Obj>(
+  obj: Obj,
+  key: Key,
+): Obj[Key] {
+  const k = obj[key];
+  if (obj[key]) {
+    return obj[key];
+  }
+  throw new Error('Boom!');
+}
+
+pick({ foo: 1, bar: 2 }, 'bar');
+      `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 15,
+          endLine: 7,
+          line: 7,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+function getElem(dict: Record<string, { foo: string }>, key: string) {
+  if (dict[key]) {
+    return dict[key].foo;
+  } else {
+    return '';
+  }
+}
+      `,
+      errors: [
+        {
+          column: 7,
+          endColumn: 16,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare let foo: {};
 foo ??= 1;
-    `,
-    `
+      `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
 declare let foo: number;
+foo ??= 1;
+      `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare let foo: null;
+foo ??= null;
+      `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysNullish',
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+declare let foo: {};
 foo ||= 1;
-    `,
-    `
-declare const foo: { bar: { baz?: number; qux: number } };
-type Key = 'baz' | 'qux';
-declare const key: Key;
-foo.bar[key] ??= 1;
-    `,
-    `
-enum Keys {
-  A = 'A',
-  B = 'B',
-}
-type Foo = {
-  [Keys.A]: number | null;
-  [Keys.B]: number;
-};
-declare const foo: Foo;
-declare const key: Keys;
-foo[key] ??= 1;
-    `,
+      `,
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      output: null,
+    },
     {
       code: `
-declare const foo: { bar?: number };
-foo.bar ??= 1;
+declare let foo: null;
+foo ||= null;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysFalsy',
+        },
+      ],
+      output: null,
     },
     {
       code: `
-declare const foo: { bar: { baz?: number } };
-foo['bar'].baz ??= 1;
+declare let foo: {};
+foo &&= 1;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysTruthy',
+        },
+      ],
+      output: null,
     },
     {
       code: `
-declare const foo: { bar: { baz?: number; qux: number } };
-type Key = 'baz' | 'qux';
-declare const key: Key;
-foo.bar[key] ??= 1;
+declare let foo: null;
+foo &&= null;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      errors: [
+        {
+          column: 1,
+          endColumn: 4,
+          endLine: 3,
+          line: 3,
+          messageId: 'alwaysFalsy',
+        },
+      ],
+      output: null,
     },
-    `
-declare let foo: number;
-foo &&= 1;
-    `,
-    `
-function foo<T extends object>(arg: T, key: keyof T): void {
-  arg[key] ??= 'default';
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6264
-    `
-function get<Obj, Key extends keyof Obj>(obj: Obj, key: Key) {
-  const value = obj[key];
-  if (value) {
-    return value;
-  }
-  throw new Error('BOOM!');
-}
-
-get({ foo: null }, 'foo');
-    `,
     {
       code: `
-function getElem(dict: Record<string, { foo: string }>, key: string) {
-  if (dict[key]) {
-    return dict[key].foo;
-  } else {
-    return '';
-  }
-}
+declare const foo: { bar: number };
+foo.bar ??= 1;
       `,
-      languageOptions: {
-        parserOptions: {
-          project: './tsconfig.noUncheckedIndexedAccess.json',
-          projectService: false,
-          tsconfigRootDir: getFixturesRootDir(),
+      errors: [
+        {
+          column: 1,
+          endColumn: 8,
+          endLine: 3,
+          line: 3,
+          messageId: 'neverNullish',
         },
-      },
+      ],
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      output: null,
     },
-    `
-type Foo = { bar: () => number | undefined } | null;
+    {
+      code: noFormat`
+type Foo = { bar: () => number } | null;
 declare const foo: Foo;
 foo?.bar()?.toExponential();
-    `,
-    `
-type Foo = (() => number | undefined) | null;
+      `,
+      errors: [
+        {
+          column: 11,
+          endColumn: 13,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+type Foo = { bar: () => number } | null;
 declare const foo: Foo;
-foo?.()?.toExponential();
-    `,
-    `
-type FooUndef = () => undefined;
-type FooNum = () => number;
-type Foo = FooUndef | FooNum | null;
+foo?.bar().toExponential();
+      `,
+    },
+    {
+      code: noFormat`
+type Foo = { bar: null | { baz: () => { qux: number } } } | null;
+declare const foo: Foo;
+foo?.bar?.baz()?.qux?.toExponential();
+      `,
+      errors: [
+        {
+          column: 16,
+          endColumn: 18,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+        {
+          column: 21,
+          endColumn: 23,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+type Foo = { bar: null | { baz: () => { qux: number } } } | null;
+declare const foo: Foo;
+foo?.bar?.baz().qux.toExponential();
+      `,
+    },
+    {
+      code: noFormat`
+type Foo = (() => number) | null;
 declare const foo: Foo;
 foo?.()?.toExponential();
-    `,
-    `
-type Foo = { [key: string]: () => number | undefined } | null;
+      `,
+      errors: [
+        {
+          column: 8,
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+type Foo = (() => number) | null;
+declare const foo: Foo;
+foo?.().toExponential();
+      `,
+    },
+    {
+      code: noFormat`
+type Foo = { [key: string]: () => number } | null;
 declare const foo: Foo;
 foo?.['bar']()?.toExponential();
-    `,
+      `,
+      errors: [
+        {
+          column: 15,
+          endColumn: 17,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']().toExponential();
+      `,
+    },
     {
-      code: `
-class ConsistentRand {
-  #rand?: number;
-
-  getCachedRand() {
-    this.#rand ??= Math.random();
-    return this.#rand;
-  }
-}
+      code: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']?.()?.toExponential();
+      `,
+      errors: [
+        {
+          column: 17,
+          endColumn: 19,
+          endLine: 4,
+          line: 4,
+          messageId: 'neverOptionalChain',
+        },
+      ],
+      output: noFormat`
+type Foo = { [key: string]: () => number } | null;
+declare const foo: Foo;
+foo?.['bar']?.().toExponential();
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
+
+    // "branded" types
+    unnecessaryConditionTest('"" & {}', 'alwaysFalsy'),
+    unnecessaryConditionTest('"" & { __brand: string }', 'alwaysFalsy'),
+    unnecessaryConditionTest(
+      '("" | false) & { __brand: string }',
+      'alwaysFalsy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & ""',
+      'alwaysFalsy',
+    ),
+    unnecessaryConditionTest(
+      '("foo" | "bar") & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '(123 | true) & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '(string | number) & ("foo" | 123) & { __brand: string }',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & "foo"',
+      'alwaysTruthy',
+    ),
+    unnecessaryConditionTest(
+      '((string & { __brandA: string }) | (number & { __brandB: string })) & ("foo" | 123)',
+      'alwaysTruthy',
+    ),
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
index 419118e88a74..93997c98ab6f 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-parameter-property-assignment.test.ts
@@ -5,6 +5,168 @@ import rule from '../../src/rules/no-unnecessary-parameter-property-assignment';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-parameter-property-assignment', rule, {
+  valid: [
+    `
+class Foo {
+  constructor(foo: string) {}
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {}
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.foo = bar;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: any) {
+    this.foo = foo.bar;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.foo = this.bar;
+  }
+}
+    `,
+    `
+class Foo {
+  foo: string;
+  constructor(foo: string) {
+    this.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  bar: string;
+  constructor(private foo: string) {
+    this.bar = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this.bar = () => {
+      this.foo = foo;
+    };
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(private foo: string) {
+    this[\`\${foo}\`] = foo;
+  }
+}
+    `,
+    `
+function Foo(foo) {
+  this.foo = foo;
+}
+    `,
+    `
+const foo = 'foo';
+this.foo = foo;
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo += foo;
+    this.foo -= foo;
+    this.foo *= foo;
+    this.foo /= foo;
+    this.foo %= foo;
+    this.foo **= foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo += 1;
+    this.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(
+    public foo: number,
+    bar: boolean,
+  ) {
+    if (bar) {
+      this.foo += 1;
+    } else {
+      this.foo = foo;
+    }
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo = foo;
+  }
+  init = (this.foo += 1);
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    {
+      const foo = 1;
+      this.foo = foo;
+    }
+  }
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    this[name] = foo;
+  }
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    Foo.foo = foo;
+  }
+}
+    `,
+    `
+class Foo {
+  constructor(public foo: number) {
+    this.foo = foo;
+  }
+  init = (() => {
+    this.foo += 1;
+  })();
+}
+    `,
+    `
+declare const name: string;
+class Foo {
+  constructor(public foo: number) {
+    this[name] = foo;
+  }
+  init = (this[name] = 1);
+  init2 = (Foo.foo = 1);
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -316,166 +478,4 @@ class Foo {
       ],
     },
   ],
-  valid: [
-    `
-class Foo {
-  constructor(foo: string) {}
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {}
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.foo = bar;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: any) {
-    this.foo = foo.bar;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.foo = this.bar;
-  }
-}
-    `,
-    `
-class Foo {
-  foo: string;
-  constructor(foo: string) {
-    this.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  bar: string;
-  constructor(private foo: string) {
-    this.bar = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this.bar = () => {
-      this.foo = foo;
-    };
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(private foo: string) {
-    this[\`\${foo}\`] = foo;
-  }
-}
-    `,
-    `
-function Foo(foo) {
-  this.foo = foo;
-}
-    `,
-    `
-const foo = 'foo';
-this.foo = foo;
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo += foo;
-    this.foo -= foo;
-    this.foo *= foo;
-    this.foo /= foo;
-    this.foo %= foo;
-    this.foo **= foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo += 1;
-    this.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(
-    public foo: number,
-    bar: boolean,
-  ) {
-    if (bar) {
-      this.foo += 1;
-    } else {
-      this.foo = foo;
-    }
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo = foo;
-  }
-  init = (this.foo += 1);
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    {
-      const foo = 1;
-      this.foo = foo;
-    }
-  }
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    this[name] = foo;
-  }
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    Foo.foo = foo;
-  }
-}
-    `,
-    `
-class Foo {
-  constructor(public foo: number) {
-    this.foo = foo;
-  }
-  init = (() => {
-    this.foo += 1;
-  })();
-}
-    `,
-    `
-declare const name: string;
-class Foo {
-  constructor(public foo: number) {
-    this[name] = foo;
-  }
-  init = (this[name] = 1);
-  init2 = (Foo.foo = 1);
-}
-    `,
-  ],
 });
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 fa38be088fd4..135fd3cd0674 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
@@ -18,6 +18,72 @@ const ruleTester = new RuleTester({
 const messageId = 'unnecessaryQualifier';
 
 ruleTester.run('no-unnecessary-qualifier', rule, {
+  valid: [
+    `
+namespace X {
+  export type T = number;
+}
+
+namespace Y {
+  export const x: X.T = 3;
+}
+    `,
+    `
+namespace A {}
+namespace A.B {
+  export type Z = 1;
+}
+    `,
+    `
+enum A {
+  X,
+  Y,
+}
+
+enum B {
+  Z = A.X,
+}
+    `,
+    `
+namespace X {
+  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;
+}
+    `,
+    `
+enum Foo {
+  One,
+}
+
+namespace Foo {
+  export function bar() {
+    return Foo.One;
+  }
+}
+    `,
+    `
+namespace Foo {
+  export enum Foo {
+    One,
+  }
+}
+
+namespace Foo {
+  export function bar() {
+    return Foo.One;
+  }
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -220,71 +286,4 @@ declare module './foo' {
       `,
     },
   ],
-
-  valid: [
-    `
-namespace X {
-  export type T = number;
-}
-
-namespace Y {
-  export const x: X.T = 3;
-}
-    `,
-    `
-namespace A {}
-namespace A.B {
-  export type Z = 1;
-}
-    `,
-    `
-enum A {
-  X,
-  Y,
-}
-
-enum B {
-  Z = A.X,
-}
-    `,
-    `
-namespace X {
-  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;
-}
-    `,
-    `
-enum Foo {
-  One,
-}
-
-namespace Foo {
-  export function bar() {
-    return Foo.One;
-  }
-}
-    `,
-    `
-namespace Foo {
-  export enum Foo {
-    One,
-  }
-}
-
-namespace Foo {
-  export function bar() {
-    return Foo.One;
-  }
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
index 44d077f485cf..62c73dcfc2ec 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-template-expression.test.ts
@@ -899,123 +899,6 @@ describe('fixer should not change runtime value', () => {
 });
 
 ruleTester.run('no-unnecessary-template-expression', rule, {
-  invalid: [
-    ...invalidCases,
-    {
-      code: `
-        function func<T extends string>(arg: T) {
-          \`\${arg}\`;
-        }
-      `,
-      errors: [
-        {
-          column: 14,
-          endColumn: 17,
-          line: 3,
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-        function func<T extends string>(arg: T) {
-          arg;
-        }
-      `,
-    },
-    {
-      code: `
-        declare const b: 'b';
-        \`a\${b}\${'c'}\`;
-      `,
-      errors: [
-        {
-          column: 17,
-          endColumn: 20,
-          line: 3,
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-        declare const b: 'b';
-        \`a\${b}c\`;
-      `,
-    },
-    {
-      code: `
-declare const nested: string, interpolation: string;
-\`use\${\`less\${nested}\${interpolation}\`}\`;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-declare const nested: string, interpolation: string;
-\`useless\${nested}\${interpolation}\`;
-      `,
-    },
-    {
-      code: noFormat`
-        declare const string: 'a';
-        \`\${   string   }\`;
-      `,
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-        declare const string: 'a';
-        string;
-      `,
-    },
-    {
-      code: `
-        declare const string: 'a';
-        \`\${string}\`;
-      `,
-      errors: [
-        {
-          column: 12,
-          endColumn: 18,
-          line: 3,
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-        declare const string: 'a';
-        string;
-      `,
-    },
-    {
-      code: `
-        declare const intersection: string & { _brand: 'test-brand' };
-        \`\${intersection}\`;
-      `,
-      errors: [
-        {
-          column: 12,
-          endColumn: 24,
-          line: 3,
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: `
-        declare const intersection: string & { _brand: 'test-brand' };
-        intersection;
-      `,
-    },
-    {
-      code: "true ? `${'test' || ''}`.trim() : undefined;",
-      errors: [
-        {
-          messageId: 'noUnnecessaryTemplateExpression',
-        },
-      ],
-      output: "true ? ('test' || '').trim() : undefined;",
-    },
-  ],
-
   valid: [
     "const string = 'a';",
     'const string = `a`;',
@@ -1138,4 +1021,121 @@ declare const nested: string, interpolation: string;
 \`not a useless \${String.raw\`nested interpolation \${a}\`}\`;
     `,
   ],
+
+  invalid: [
+    ...invalidCases,
+    {
+      code: `
+        function func<T extends string>(arg: T) {
+          \`\${arg}\`;
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 17,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        function func<T extends string>(arg: T) {
+          arg;
+        }
+      `,
+    },
+    {
+      code: `
+        declare const b: 'b';
+        \`a\${b}\${'c'}\`;
+      `,
+      errors: [
+        {
+          column: 17,
+          endColumn: 20,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const b: 'b';
+        \`a\${b}c\`;
+      `,
+    },
+    {
+      code: `
+declare const nested: string, interpolation: string;
+\`use\${\`less\${nested}\${interpolation}\`}\`;
+      `,
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+declare const nested: string, interpolation: string;
+\`useless\${nested}\${interpolation}\`;
+      `,
+    },
+    {
+      code: noFormat`
+        declare const string: 'a';
+        \`\${   string   }\`;
+      `,
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const string: 'a';
+        string;
+      `,
+    },
+    {
+      code: `
+        declare const string: 'a';
+        \`\${string}\`;
+      `,
+      errors: [
+        {
+          column: 12,
+          endColumn: 18,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const string: 'a';
+        string;
+      `,
+    },
+    {
+      code: `
+        declare const intersection: string & { _brand: 'test-brand' };
+        \`\${intersection}\`;
+      `,
+      errors: [
+        {
+          column: 12,
+          endColumn: 24,
+          line: 3,
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: `
+        declare const intersection: string & { _brand: 'test-brand' };
+        intersection;
+      `,
+    },
+    {
+      code: "true ? `${'test' || ''}`.trim() : undefined;",
+      errors: [
+        {
+          messageId: 'noUnnecessaryTemplateExpression',
+        },
+      ],
+      output: "true ? ('test' || '').trim() : undefined;",
+    },
+  ],
 });
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 c41c65182492..28ba6e955dd3 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
@@ -15,6 +15,147 @@ 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>();
+    `,
+    `
+declare const f: unknown;
+f<string>\`\`;
+    `,
+    `
+function f<T = number>(template: TemplateStringsArray) {}
+f<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>>();
+    `,
+    `
+type A<T = Element> = T;
+type B = A<HTMLInputElement>;
+    `,
+    `
+type A<T = Map<string, string>> = T;
+type B = A<Map<string, number>>;
+    `,
+    `
+type A = Map<string, string>;
+type B<T = A> = T;
+type C2 = B<Map<string, number>>;
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -312,145 +453,4 @@ type F = E;
       `,
     },
   ],
-  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>();
-    `,
-    `
-declare const f: unknown;
-f<string>\`\`;
-    `,
-    `
-function f<T = number>(template: TemplateStringsArray) {}
-f<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>>();
-    `,
-    `
-type A<T = Element> = T;
-type B = A<HTMLInputElement>;
-    `,
-    `
-type A<T = Map<string, string>> = T;
-type B = A<Map<string, number>>;
-    `,
-    `
-type A = Map<string, string>;
-type B<T = A> = T;
-type C2 = B<Map<string, number>>;
-    `,
-  ],
 });
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 59961451e4f5..2803ccae360a 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
@@ -25,6 +25,341 @@ const optionsWithExactOptionalPropertyTypes = {
 };
 
 ruleTester.run('no-unnecessary-type-assertion', rule, {
+  valid: [
+    `
+import { TSESTree } from '@typescript-eslint/utils';
+declare const member: TSESTree.TSEnumMember;
+if (
+  member.id.type === AST_NODE_TYPES.Literal &&
+  typeof member.id.value === 'string'
+) {
+  const name = member.id as TSESTree.StringLiteral;
+}
+    `,
+    `
+      const c = 1;
+      let z = c as number;
+    `,
+    `
+      const c = 1;
+      let z = c as const;
+    `,
+    `
+      const c = 1;
+      let z = c as 1;
+    `,
+    `
+      type Bar = 'bar';
+      const data = {
+        x: 'foo' as 'foo',
+        y: 'bar' as Bar,
+      };
+    `,
+    "[1, 2, 3, 4, 5].map(x => [x, 'A' + x] as [number, string]);",
+    `
+      let x: Array<[number, string]> = [1, 2, 3, 4, 5].map(
+        x => [x, 'A' + x] as [number, string],
+      );
+    `,
+    'let y = 1 as 1;',
+    'const foo = 3 as number;',
+    'const foo = <number>3;',
+    `
+type Tuple = [3, 'hi', 'bye'];
+const foo = [3, 'hi', 'bye'] as Tuple;
+    `,
+    `
+type PossibleTuple = {};
+const foo = {} 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;
+    `,
+    `
+let bar: number | undefined = x;
+let foo: number = bar!;
+    `,
+    `
+declare const a: { data?: unknown };
+
+const x = a.data!;
+    `,
+    `
+declare function foo(arg?: number): number | void;
+const bar: number = foo()!;
+    `,
+    {
+      code: `
+type Foo = number;
+const foo = (3 + 5) as Foo;
+      `,
+      options: [{ typesToIgnore: ['Foo'] }],
+    },
+    {
+      code: 'const foo = (3 + 5) as any;',
+      options: [{ typesToIgnore: ['any'] }],
+    },
+    {
+      code: "(Syntax as any).ArrayExpression = 'foo';",
+      options: [{ typesToIgnore: ['any'] }],
+    },
+    {
+      code: 'const foo = (3 + 5) as string;',
+      options: [{ typesToIgnore: ['string'] }],
+    },
+    {
+      code: `
+type Foo = number;
+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: undefined | number;
+bar! + 1;
+    `,
+    `
+let bar: number, baz: number;
+bar! + 1;
+    `,
+    `
+function foo<T extends string | undefined>(bar: T) {
+  return bar!;
+}
+    `,
+    `
+declare function nonNull(s: string);
+let s: string | null = null;
+nonNull(s!);
+    `,
+    `
+const x: number | null = null;
+const y: number = x!;
+    `,
+    `
+const x: number | null = null;
+class Foo {
+  prop: number = x!;
+}
+    `,
+    `
+      declare const y: number | null;
+      console.log(y!);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/529
+    `
+declare function foo(str?: string): void;
+declare const str: string | null;
+
+foo(str!);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/532
+    `
+declare function a(a: string): any;
+declare const b: string | null;
+class Mx {
+  @a(b!)
+  private prop = 1;
+}
+    `,
+    // 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 | 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 };
+  }
+}
+
+function Test(props: { id?: null | string | number }) {
+  return <div key={props.id!} />;
+}
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+const a = [1, 2];
+const b = [3, 4];
+const c = [...a, ...b] as const;
+      `,
+    },
+    {
+      code: 'const a = [1, 2] as const;',
+    },
+    {
+      code: "const a = { foo: 'foo' } as const;",
+    },
+    {
+      code: `
+const a = [1, 2];
+const b = [3, 4];
+const c = <const>[...a, ...b];
+      `,
+    },
+    {
+      code: 'const a = <const>[1, 2];',
+    },
+    {
+      code: "const a = <const>{ foo: 'foo' };",
+    },
+    {
+      code: `
+let a: number | undefined;
+let b: number | undefined;
+let c: number;
+a = b;
+c = b!;
+a! -= 1;
+      `,
+    },
+    {
+      code: `
+let a: { b?: string } | undefined;
+a!.b = '';
+      `,
+    },
+    `
+let value: number | undefined;
+let values: number[] = [];
+
+value = values.pop()!;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = foo()!;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = foo() as number;
+    `,
+    `
+declare function foo(): number | undefined;
+const a = <number>foo();
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = arr[0]!;
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = arr[0] as object;
+    `,
+    `
+declare const arr: (object | undefined)[];
+const item = <object>arr[0];
+    `,
+    {
+      code: `
+function foo(item: string) {}
+function bar(items: string[]) {
+  for (let i = 0; i < items.length; i++) {
+    foo(items[i]!);
+  }
+}
+      `,
+      languageOptions: { parserOptions: optionsWithOnUncheckedIndexedAccess },
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
+    `
+let myString = 'foo';
+const templateLiteral = \`\${myString}-somethingElse\` as const;
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
+    `
+let myString = 'foo';
+const templateLiteral = <const>\`\${myString}-somethingElse\`;
+    `,
+    'let a = `a` as const;',
+    {
+      code: `
+declare const foo: {
+  a?: string;
+};
+const bar = foo.a as string;
+      `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
+declare const foo: {
+  a?: string | undefined;
+};
+const bar = foo.a as string;
+      `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
+declare const foo: {
+  a: string;
+};
+const bar = foo.a as string | undefined;
+      `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
+declare const foo: {
+  a?: string | null | number;
+};
+const bar = foo.a as string | undefined;
+      `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
+declare const foo: {
+  a?: string | number;
+};
+const bar = foo.a as string | undefined | bigint;
+      `,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+    },
+    {
+      code: `
+if (Math.random()) {
+  {
+    var x = 1;
+  }
+}
+x!;
+      `,
+    },
+  ],
+
   invalid: [
     // https://github.com/typescript-eslint/typescript-eslint/issues/8737
     {
@@ -474,591 +809,213 @@ const a = foo() as number;
       ],
       output: `
 declare function foo(): number;
-const a = foo();
-      `,
-    },
-    {
-      code: `
-declare function foo(): number;
-const a = <number>foo();
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-declare function foo(): number;
-const a = foo();
-      `,
-    },
-    {
-      code: `
-type RT = { log: () => void };
-declare function foo(): RT;
-(foo() as RT).log;
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-type RT = { log: () => void };
-declare function foo(): RT;
-(foo()).log;
-      `,
-    },
-    {
-      code: `
-declare const arr: object[];
-const item = arr[0]!;
-      `,
-      errors: [
-        {
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-declare const arr: object[];
-const item = arr[0];
-      `,
-    },
-    {
-      code: noFormat`
-const foo = (  3 + 5  ) as number;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (  3 + 5  );
-      `,
-    },
-    {
-      code: noFormat`
-const foo = (  3 + 5  ) /*as*/ as number;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (  3 + 5  ) /*as*/;
-      `,
-    },
-    {
-      code: noFormat`
-const foo = (  3 + 5
-  ) /*as*/ as //as
-  (
-    number
-  );
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (  3 + 5
-  ) /*as*/;
-      `,
-    },
-    {
-      code: noFormat`
-const foo = (3 + (5 as number) ) as number;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (3 + (5 as number) );
-      `,
-    },
-    {
-      code: noFormat`
-const foo = 3 + 5/*as*/ as number;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = 3 + 5/*as*/;
-      `,
-    },
-    {
-      code: noFormat`
-const foo = 3 + 5/*a*/ /*b*/ as number;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = 3 + 5/*a*/ /*b*/;
-      `,
-    },
-    {
-      code: noFormat`
-const foo = <(number)>(3 + 5);
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (3 + 5);
-      `,
-    },
-    {
-      code: noFormat`
-const foo = < ( number ) >( 3 + 5 );
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = ( 3 + 5 );
-      `,
-    },
-    {
-      code: noFormat`
-const foo = <number> /* a */ (3 + 5);
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo =  /* a */ (3 + 5);
-      `,
-    },
-    {
-      code: noFormat`
-const foo = <number /* a */>(3 + 5);
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 2,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-const foo = (3 + 5);
-      `,
-    },
-    // onUncheckedIndexedAccess = false
-    {
-      code: `
-function foo(item: string) {}
-function bar(items: string[]) {
-  for (let i = 0; i < items.length; i++) {
-    foo(items[i]!);
-  }
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 5,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      output: `
-function foo(item: string) {}
-function bar(items: string[]) {
-  for (let i = 0; i < items.length; i++) {
-    foo(items[i]);
-  }
-}
-      `,
-    },
-    // exactOptionalPropertyTypes = true
-    {
-      code: `
-declare const foo: {
-  a?: string;
-};
-const bar = foo.a as string | undefined;
-      `,
-      errors: [
-        {
-          column: 13,
-          line: 5,
-          messageId: 'unnecessaryAssertion',
-        },
-      ],
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-      output: `
-declare const foo: {
-  a?: string;
-};
-const bar = foo.a;
+const a = foo();
       `,
     },
     {
       code: `
-declare const foo: {
-  a?: string | undefined;
-};
-const bar = foo.a as string | undefined;
+declare function foo(): number;
+const a = <number>foo();
       `,
       errors: [
         {
-          column: 13,
-          line: 5,
+          line: 3,
           messageId: 'unnecessaryAssertion',
         },
       ],
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
       output: `
-declare const foo: {
-  a?: string | undefined;
-};
-const bar = foo.a;
+declare function foo(): number;
+const a = foo();
       `,
     },
     {
       code: `
-varDeclarationFromFixture!;
+type RT = { log: () => void };
+declare function foo(): RT;
+(foo() as RT).log;
       `,
       errors: [
         {
-          line: 2,
           messageId: 'unnecessaryAssertion',
         },
       ],
       output: `
-varDeclarationFromFixture;
+type RT = { log: () => void };
+declare function foo(): RT;
+(foo()).log;
       `,
     },
     {
       code: `
-var x = 1;
-x!;
+declare const arr: object[];
+const item = arr[0]!;
       `,
       errors: [
         {
-          line: 3,
           messageId: 'unnecessaryAssertion',
         },
       ],
       output: `
-var x = 1;
-x;
+declare const arr: object[];
+const item = arr[0];
       `,
     },
     {
-      code: `
-var x = 1;
-{
-  x!;
-}
+      code: noFormat`
+const foo = (  3 + 5  ) as number;
       `,
       errors: [
         {
-          line: 4,
+          column: 13,
+          line: 2,
           messageId: 'unnecessaryAssertion',
         },
       ],
       output: `
-var x = 1;
-{
-  x;
-}
+const foo = (  3 + 5  );
       `,
     },
-  ],
-
-  valid: [
-    `
-import { TSESTree } from '@typescript-eslint/utils';
-declare const member: TSESTree.TSEnumMember;
-if (
-  member.id.type === AST_NODE_TYPES.Literal &&
-  typeof member.id.value === 'string'
-) {
-  const name = member.id as TSESTree.StringLiteral;
-}
-    `,
-    `
-      const c = 1;
-      let z = c as number;
-    `,
-    `
-      const c = 1;
-      let z = c as const;
-    `,
-    `
-      const c = 1;
-      let z = c as 1;
-    `,
-    `
-      type Bar = 'bar';
-      const data = {
-        x: 'foo' as 'foo',
-        y: 'bar' as Bar,
-      };
-    `,
-    "[1, 2, 3, 4, 5].map(x => [x, 'A' + x] as [number, string]);",
-    `
-      let x: Array<[number, string]> = [1, 2, 3, 4, 5].map(
-        x => [x, 'A' + x] as [number, string],
-      );
-    `,
-    'let y = 1 as 1;',
-    'const foo = 3 as number;',
-    'const foo = <number>3;',
-    `
-type Tuple = [3, 'hi', 'bye'];
-const foo = [3, 'hi', 'bye'] as Tuple;
-    `,
-    `
-type PossibleTuple = {};
-const foo = {} 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;
-    `,
-    `
-let bar: number | undefined = x;
-let foo: number = bar!;
-    `,
-    `
-declare const a: { data?: unknown };
-
-const x = a.data!;
-    `,
-    `
-declare function foo(arg?: number): number | void;
-const bar: number = foo()!;
-    `,
     {
-      code: `
-type Foo = number;
-const foo = (3 + 5) as Foo;
+      code: noFormat`
+const foo = (  3 + 5  ) /*as*/ as number;
       `,
-      options: [{ typesToIgnore: ['Foo'] }],
-    },
-    {
-      code: 'const foo = (3 + 5) as any;',
-      options: [{ typesToIgnore: ['any'] }],
-    },
-    {
-      code: "(Syntax as any).ArrayExpression = 'foo';",
-      options: [{ typesToIgnore: ['any'] }],
-    },
-    {
-      code: 'const foo = (3 + 5) as string;',
-      options: [{ typesToIgnore: ['string'] }],
-    },
-    {
-      code: `
-type Foo = number;
-const foo = <Foo>(3 + 5);
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (  3 + 5  ) /*as*/;
       `,
-      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: undefined | number;
-bar! + 1;
-    `,
-    `
-let bar: number, baz: number;
-bar! + 1;
-    `,
-    `
-function foo<T extends string | undefined>(bar: T) {
-  return bar!;
-}
-    `,
-    `
-declare function nonNull(s: string);
-let s: string | null = null;
-nonNull(s!);
-    `,
-    `
-const x: number | null = null;
-const y: number = x!;
-    `,
-    `
-const x: number | null = null;
-class Foo {
-  prop: number = x!;
-}
-    `,
-    `
-      declare const y: number | null;
-      console.log(y!);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/529
-    `
-declare function foo(str?: string): void;
-declare const str: string | null;
-
-foo(str!);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/532
-    `
-declare function a(a: string): any;
-declare const b: string | null;
-class Mx {
-  @a(b!)
-  private prop = 1;
-}
-    `,
-    // 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 | 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 };
-  }
-}
-
-function Test(props: { id?: null | string | number }) {
-  return <div key={props.id!} />;
-}
+      code: noFormat`
+const foo = (  3 + 5
+  ) /*as*/ as //as
+  (
+    number
+  );
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    {
-      code: `
-const a = [1, 2];
-const b = [3, 4];
-const c = [...a, ...b] as const;
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (  3 + 5
+  ) /*as*/;
       `,
     },
     {
-      code: 'const a = [1, 2] as const;',
+      code: noFormat`
+const foo = (3 + (5 as number) ) as number;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + (5 as number) );
+      `,
     },
     {
-      code: "const a = { foo: 'foo' } as const;",
+      code: noFormat`
+const foo = 3 + 5/*as*/ as number;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = 3 + 5/*as*/;
+      `,
     },
     {
-      code: `
-const a = [1, 2];
-const b = [3, 4];
-const c = <const>[...a, ...b];
+      code: noFormat`
+const foo = 3 + 5/*a*/ /*b*/ as number;
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = 3 + 5/*a*/ /*b*/;
       `,
     },
     {
-      code: 'const a = <const>[1, 2];',
+      code: noFormat`
+const foo = <(number)>(3 + 5);
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + 5);
+      `,
     },
     {
-      code: "const a = <const>{ foo: 'foo' };",
+      code: noFormat`
+const foo = < ( number ) >( 3 + 5 );
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = ( 3 + 5 );
+      `,
     },
     {
-      code: `
-let a: number | undefined;
-let b: number | undefined;
-let c: number;
-a = b;
-c = b!;
-a! -= 1;
+      code: noFormat`
+const foo = <number> /* a */ (3 + 5);
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo =  /* a */ (3 + 5);
       `,
     },
     {
-      code: `
-let a: { b?: string } | undefined;
-a!.b = '';
+      code: noFormat`
+const foo = <number /* a */>(3 + 5);
+      `,
+      errors: [
+        {
+          column: 13,
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+const foo = (3 + 5);
       `,
     },
-    `
-let value: number | undefined;
-let values: number[] = [];
-
-value = values.pop()!;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = foo()!;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = foo() as number;
-    `,
-    `
-declare function foo(): number | undefined;
-const a = <number>foo();
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = arr[0]!;
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = arr[0] as object;
-    `,
-    `
-declare const arr: (object | undefined)[];
-const item = <object>arr[0];
-    `,
+    // onUncheckedIndexedAccess = false
     {
       code: `
 function foo(item: string) {}
@@ -1068,72 +1025,115 @@ function bar(items: string[]) {
   }
 }
       `,
-      languageOptions: { parserOptions: optionsWithOnUncheckedIndexedAccess },
+      errors: [
+        {
+          column: 9,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+function foo(item: string) {}
+function bar(items: string[]) {
+  for (let i = 0; i < items.length; i++) {
+    foo(items[i]);
+  }
+}
+      `,
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
-    `
-let myString = 'foo';
-const templateLiteral = \`\${myString}-somethingElse\` as const;
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8737
-    `
-let myString = 'foo';
-const templateLiteral = <const>\`\${myString}-somethingElse\`;
-    `,
-    'let a = `a` as const;',
+    // exactOptionalPropertyTypes = true
     {
       code: `
 declare const foo: {
   a?: string;
 };
-const bar = foo.a as string;
+const bar = foo.a as string | undefined;
       `,
+      errors: [
+        {
+          column: 13,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
       languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
-    },
-    {
-      code: `
+      output: `
 declare const foo: {
-  a?: string | undefined;
+  a?: string;
 };
-const bar = foo.a as string;
+const bar = foo.a;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
 declare const foo: {
-  a: string;
+  a?: string | undefined;
 };
 const bar = foo.a as string | undefined;
       `,
+      errors: [
+        {
+          column: 13,
+          line: 5,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
       languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
+      output: `
+declare const foo: {
+  a?: string | undefined;
+};
+const bar = foo.a;
+      `,
     },
     {
       code: `
-declare const foo: {
-  a?: string | null | number;
-};
-const bar = foo.a as string | undefined;
+varDeclarationFromFixture!;
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+varDeclarationFromFixture;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-declare const foo: {
-  a?: string | number;
-};
-const bar = foo.a as string | undefined | bigint;
+var x = 1;
+x!;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+var x = 1;
+x;
       `,
-      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
-if (Math.random()) {
-  {
-    var x = 1;
-  }
+var x = 1;
+{
+  x!;
+}
+      `,
+      errors: [
+        {
+          line: 4,
+          messageId: 'unnecessaryAssertion',
+        },
+      ],
+      output: `
+var x = 1;
+{
+  x;
 }
-x!;
       `,
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
index 1c9fedf5c08a..c03cf27a3cdb 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-constraint.test.ts
@@ -5,6 +5,23 @@ import rule from '../../src/rules/no-unnecessary-type-constraint';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-type-constraint', rule, {
+  valid: [
+    'function data() {}',
+    'function data<T>() {}',
+    'function data<T, U>() {}',
+    'function data<T extends number>() {}',
+    'function data<T extends number | string>() {}',
+    'function data<T extends any | number>() {}',
+    `
+type TODO = any;
+function data<T extends TODO>() {}
+    `,
+    'const data = () => {};',
+    'const data = <T,>() => {};',
+    'const data = <T, U>() => {};',
+    'const data = <T extends number>() => {};',
+    'const data = <T extends number | string>() => {};',
+  ],
   invalid: [
     {
       code: 'function data<T extends any>() {}',
@@ -506,21 +523,4 @@ const Data = class {
       ],
     },
   ],
-  valid: [
-    'function data() {}',
-    'function data<T>() {}',
-    'function data<T, U>() {}',
-    'function data<T extends number>() {}',
-    'function data<T extends number | string>() {}',
-    'function data<T extends any | number>() {}',
-    `
-type TODO = any;
-function data<T extends TODO>() {}
-    `,
-    'const data = () => {};',
-    'const data = <T,>() => {};',
-    'const data = <T, U>() => {};',
-    'const data = <T extends number>() => {};',
-    'const data = <T extends number | string>() => {};',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
index 5811ae0f57f8..69e1d534a098 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-parameters.test.ts
@@ -15,600 +15,59 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unnecessary-type-parameters', rule, {
-  invalid: [
-    {
-      code: 'const func = <T,>(param: T) => null;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'const f1 = <T,>(): T => {};',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        interface I {
-          <T>(value: T): void;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        interface I {
-          m<T>(x: T): void;
-        }
-      `,
-      errors: [{ messageId: 'sole' }],
-    },
-    {
-      code: `
-        class Joiner<T extends string | number> {
-          join(el: T, other: string) {
-            return [el, other].join(',');
-          }
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C<V> {}
-      `,
-      errors: [
-        {
-          data: { descriptor: 'class', name: 'V', uses: 'never used' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C<T, U> {
-          method(param: T): U;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'class', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C {
-          method<T, U>(param: T): U;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare class C {
-          prop: <P>() => P;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'P', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare class Foo {
-          foo<T>(this: T): void;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function third<A, B, C>(a: A, b: B, c: C): C {
-          return c;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'A', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'B', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function foo<T>(_: T) {
-          const x: T = null!;
-          const y: T = null!;
+  valid: [
+    `
+      class ClassyArray<T> {
+        arr: T[];
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        value1: T;
+        value2: T;
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        arr: T[];
+        constructor(arr: T[]) {
+          this.arr = arr;
         }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function foo<T>(_: T): void {
-          const x: T = null!;
-          const y: T = null!;
+      }
+    `,
+    `
+      class ClassyArray<T> {
+        arr: T[];
+        workWith(value: T) {
+          this.arr.indexOf(value);
         }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function foo<T>(_: T): <T>(input: T) => T {
-          const x: T = null!;
-          const y: T = null!;
+      }
+    `,
+    `
+      abstract class ClassyArray<T> {
+        arr: T[];
+        abstract workWith(value: T): void;
+      }
+    `,
+    `
+      class Box<T> {
+        val: T | null = null;
+        get() {
+          return this.val;
         }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function foo<T>(_: T) {
-          function withX(): T {
-            return null!;
-          }
-          function withY(): T {
-            return null!;
-          }
+      }
+    `,
+    `
+      class Joiner<T extends string | number> {
+        join(els: T[]) {
+          return els.map(el => '' + el).join(',');
         }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function parseYAML<T>(input: string): T {
-          return input as any as T;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function printProperty<T, K extends keyof T>(obj: T, key: K) {
-          console.log(obj[key]);
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'K', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function fn<T>(param: string) {
-          let v: T = null!;
-          return v;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function both<
-          Args extends unknown[],
-          CB1 extends (...args: Args) => void,
-          CB2 extends (...args: Args) => void,
-        >(fn1: CB1, fn2: CB2): (...args: Args) => void {
-          return function (...args: Args) {
-            fn1(...args);
-            fn2(...args);
-          };
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'CB1', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'CB2', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        function getLength<T extends { length: number }>(x: T) {
-          return x.length;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        interface Lengthy {
-          length: number;
-        }
-        function getLength<T extends Lengthy>(x: T) {
-          return x.length;
-        }
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T>(): unknown;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'never used' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T>(): T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T extends object>(): T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function take<T>(param: T): void;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function take<T extends object>(param: T): void;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function take<T, U = T>(param1: T, param2: U): void;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function take<T, U extends T>(param: T): U;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function take<T, U extends T>(param: U): U;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T, U = T>(param: U): U;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T, U extends T = T>(param: T): U;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function compare<T, U extends T>(param1: T, param2: U): boolean;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T>(param: <U, V>(param: U) => V): T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'V', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'declare function get<T>(param: <T, U>(param: T) => U): T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <T>() => T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <T>() => [];',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'never used' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        type Other = 0;
-        type Fn = <T>() => Other;
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'never used' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        type Other = 0 | 1;
-        type Fn = <T>() => Other;
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'never used' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <U>(param: U) => void;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Ctr = new <T>() => T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <T>() => { [K in keyof T]: K };',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: "type Fn = <T>() => { [K in 'a']: T };",
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <T>(value: unknown) => value is T;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: 'type Fn = <T extends string>() => `a${T}b`;',
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-    {
-      code: `
-        declare function mapObj<K extends string, V>(
-          obj: { [key in K]?: V },
-          fn: (key: K) => number,
-        ): number[];
-      `,
-      errors: [
-        {
-          data: { descriptor: 'function', name: 'V', uses: 'used only once' },
-          messageId: 'sole',
-        },
-      ],
-    },
-  ],
-
-  valid: [
-    `
-      class ClassyArray<T> {
-        arr: T[];
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        value1: T;
-        value2: T;
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        arr: T[];
-        constructor(arr: T[]) {
-          this.arr = arr;
-        }
-      }
-    `,
-    `
-      class ClassyArray<T> {
-        arr: T[];
-        workWith(value: T) {
-          this.arr.indexOf(value);
-        }
-      }
-    `,
-    `
-      abstract class ClassyArray<T> {
-        arr: T[];
-        abstract workWith(value: T): void;
-      }
-    `,
-    `
-      class Box<T> {
-        val: T | null = null;
-        get() {
-          return this.val;
-        }
-      }
-    `,
-    `
-      class Joiner<T extends string | number> {
-        join(els: T[]) {
-          return els.map(el => '' + el).join(',');
-        }
-      }
-    `,
-    `
-      class Joiner {
-        join<T extends string | number>(els: T[]) {
-          return els.map(el => '' + el).join(',');
+      }
+    `,
+    `
+      class Joiner {
+        join<T extends string | number>(els: T[]) {
+          return els.map(el => '' + el).join(',');
         }
       }
     `,
@@ -935,4 +394,544 @@ ruleTester.run('no-unnecessary-type-parameters', rule, {
       }
     `,
   ],
+  invalid: [
+    {
+      code: 'const func = <T,>(param: T) => null;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'const f1 = <T,>(): T => {};',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        interface I {
+          <T>(value: T): void;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        interface I {
+          m<T>(x: T): void;
+        }
+      `,
+      errors: [{ messageId: 'sole' }],
+    },
+    {
+      code: `
+        class Joiner<T extends string | number> {
+          join(el: T, other: string) {
+            return [el, other].join(',');
+          }
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C<V> {}
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'V', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C<T, U> {
+          method(param: T): U;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'class', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'class', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C {
+          method<T, U>(param: T): U;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class C {
+          prop: <P>() => P;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'P', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare class Foo {
+          foo<T>(this: T): void;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function third<A, B, C>(a: A, b: B, c: C): C {
+          return c;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'A', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'B', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function foo<T>(_: T) {
+          const x: T = null!;
+          const y: T = null!;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function foo<T>(_: T): void {
+          const x: T = null!;
+          const y: T = null!;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function foo<T>(_: T): <T>(input: T) => T {
+          const x: T = null!;
+          const y: T = null!;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function foo<T>(_: T) {
+          function withX(): T {
+            return null!;
+          }
+          function withY(): T {
+            return null!;
+          }
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function parseYAML<T>(input: string): T {
+          return input as any as T;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function printProperty<T, K extends keyof T>(obj: T, key: K) {
+          console.log(obj[key]);
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'K', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function fn<T>(param: string) {
+          let v: T = null!;
+          return v;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function both<
+          Args extends unknown[],
+          CB1 extends (...args: Args) => void,
+          CB2 extends (...args: Args) => void,
+        >(fn1: CB1, fn2: CB2): (...args: Args) => void {
+          return function (...args: Args) {
+            fn1(...args);
+            fn2(...args);
+          };
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'CB1', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'CB2', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        function getLength<T extends { length: number }>(x: T) {
+          return x.length;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        interface Lengthy {
+          length: number;
+        }
+        function getLength<T extends Lengthy>(x: T) {
+          return x.length;
+        }
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T>(): unknown;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T>(): T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T extends object>(): T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function take<T>(param: T): void;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function take<T extends object>(param: T): void;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function take<T, U = T>(param1: T, param2: U): void;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function take<T, U extends T>(param: T): U;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function take<T, U extends T>(param: U): U;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T, U = T>(param: U): U;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T, U extends T = T>(param: T): U;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function compare<T, U extends T>(param1: T, param2: U): boolean;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T>(param: <U, V>(param: U) => V): T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'V', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'declare function get<T>(param: <T, U>(param: T) => U): T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <T>() => T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <T>() => [];',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        type Other = 0;
+        type Fn = <T>() => Other;
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        type Other = 0 | 1;
+        type Fn = <T>() => Other;
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'never used' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <U>(param: U) => void;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'U', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Ctr = new <T>() => T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <T>() => { [K in keyof T]: K };',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: "type Fn = <T>() => { [K in 'a']: T };",
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <T>(value: unknown) => value is T;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: 'type Fn = <T extends string>() => `a${T}b`;',
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'T', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+    {
+      code: `
+        declare function mapObj<K extends string, V>(
+          obj: { [key in K]?: V },
+          fn: (key: K) => number,
+        ): number[];
+      `,
+      errors: [
+        {
+          data: { descriptor: 'function', name: 'V', uses: 'used only once' },
+          messageId: 'sole',
+        },
+      ],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
index 38781b5ac32c..491fd6e0dfd8 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
@@ -13,6 +13,112 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unsafe-argument', rule, {
+  valid: [
+    // unknown function should be ignored
+    `
+doesNotExist(1 as any);
+    `,
+    // non-function call should be ignored
+    `
+const foo = 1;
+foo(1 as any);
+    `,
+    // too many arguments should be ignored as this is a TS error
+    `
+declare function foo(arg: number): void;
+foo(1, 1 as any, 2 as any);
+    `,
+    `
+declare function foo(arg: number, arg2: string): void;
+foo(1, 'a');
+    `,
+    `
+declare function foo(arg: any): void;
+foo(1 as any);
+    `,
+    `
+declare function foo(arg: unknown): void;
+foo(1 as any);
+    `,
+    `
+declare function foo(...arg: number[]): void;
+foo(1, 2, 3);
+    `,
+    `
+declare function foo(...arg: any[]): void;
+foo(1, 2, 3, 4 as any);
+    `,
+    `
+declare function foo(arg: number, arg2: number): void;
+const x = [1, 2] as const;
+foo(...x);
+    `,
+    `
+declare function foo(arg: any, arg2: number): void;
+const x = [1 as any, 2] as const;
+foo(...x);
+    `,
+    `
+declare function foo(arg1: string, arg2: string): void;
+const x: string[] = [];
+foo(...x);
+    `,
+    `
+function foo(arg1: number, arg2: number) {}
+foo(...([1, 1, 1] as [number, number, number]));
+    `,
+    `
+declare function foo(arg1: Set<string>, arg2: Map<string, string>): void;
+
+const x = [new Map<string, string>()] as const;
+foo(new Set<string>(), ...x);
+    `,
+    `
+declare function foo(arg1: unknown, arg2: Set<unkown>, arg3: unknown[]): void;
+foo(1 as any, new Set<any>(), [] as any[]);
+    `,
+    `
+declare function foo(...params: [number, string, any]): void;
+foo(1, 'a', 1 as any);
+    `,
+    // Unfortunately - we cannot handle this case because TS infers `params` to be a tuple type
+    // that tuple type is the same as the type of
+    `
+declare function foo<E extends string[]>(...params: E): void;
+
+foo('a', 'b', 1 as any);
+    `,
+    `
+declare function toHaveBeenCalledWith<E extends any[]>(...params: E): void;
+toHaveBeenCalledWith(1 as any);
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    `
+declare function acceptsMap(arg: Map<string, string>): void;
+acceptsMap(new Map());
+    `,
+    `
+type T = [number, T[]];
+declare function foo(t: T): void;
+declare const t: T;
+
+foo(t);
+    `,
+    `
+type T = Array<T>;
+declare function foo<T>(t: T): T;
+const t: T = [];
+foo(t);
+    `,
+    `
+function foo(templates: TemplateStringsArray) {}
+foo\`\`;
+    `,
+    `
+function foo(templates: TemplateStringsArray, arg: any) {}
+foo\`\${1 as any}\`;
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -380,110 +486,4 @@ foo\`\${arg}\`;
       ],
     },
   ],
-  valid: [
-    // unknown function should be ignored
-    `
-doesNotExist(1 as any);
-    `,
-    // non-function call should be ignored
-    `
-const foo = 1;
-foo(1 as any);
-    `,
-    // too many arguments should be ignored as this is a TS error
-    `
-declare function foo(arg: number): void;
-foo(1, 1 as any, 2 as any);
-    `,
-    `
-declare function foo(arg: number, arg2: string): void;
-foo(1, 'a');
-    `,
-    `
-declare function foo(arg: any): void;
-foo(1 as any);
-    `,
-    `
-declare function foo(arg: unknown): void;
-foo(1 as any);
-    `,
-    `
-declare function foo(...arg: number[]): void;
-foo(1, 2, 3);
-    `,
-    `
-declare function foo(...arg: any[]): void;
-foo(1, 2, 3, 4 as any);
-    `,
-    `
-declare function foo(arg: number, arg2: number): void;
-const x = [1, 2] as const;
-foo(...x);
-    `,
-    `
-declare function foo(arg: any, arg2: number): void;
-const x = [1 as any, 2] as const;
-foo(...x);
-    `,
-    `
-declare function foo(arg1: string, arg2: string): void;
-const x: string[] = [];
-foo(...x);
-    `,
-    `
-function foo(arg1: number, arg2: number) {}
-foo(...([1, 1, 1] as [number, number, number]));
-    `,
-    `
-declare function foo(arg1: Set<string>, arg2: Map<string, string>): void;
-
-const x = [new Map<string, string>()] as const;
-foo(new Set<string>(), ...x);
-    `,
-    `
-declare function foo(arg1: unknown, arg2: Set<unkown>, arg3: unknown[]): void;
-foo(1 as any, new Set<any>(), [] as any[]);
-    `,
-    `
-declare function foo(...params: [number, string, any]): void;
-foo(1, 'a', 1 as any);
-    `,
-    // Unfortunately - we cannot handle this case because TS infers `params` to be a tuple type
-    // that tuple type is the same as the type of
-    `
-declare function foo<E extends string[]>(...params: E): void;
-
-foo('a', 'b', 1 as any);
-    `,
-    `
-declare function toHaveBeenCalledWith<E extends any[]>(...params: E): void;
-toHaveBeenCalledWith(1 as any);
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    `
-declare function acceptsMap(arg: Map<string, string>): void;
-acceptsMap(new Map());
-    `,
-    `
-type T = [number, T[]];
-declare function foo(t: T): void;
-declare const t: T;
-
-foo(t);
-    `,
-    `
-type T = Array<T>;
-declare function foo<T>(t: T): T;
-const t: T = [];
-foo(t);
-    `,
-    `
-function foo(templates: TemplateStringsArray) {}
-foo\`\`;
-    `,
-    `
-function foo(templates: TemplateStringsArray, arg: any) {}
-foo\`\${1 as any}\`;
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
index f089a29654ce..88fe34ed89ce 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
@@ -75,6 +75,104 @@ const ruleTester = new RuleTester({
 });
 
 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] as number[];',
+    'const [x, ...y] = [1, 2, 3, 4, 5];',
+    'const [x, ...y] = [1];',
+    'const [{ ...x }] = [{ x: 1 }] as [{ x: any }];',
+    '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 = 1 };',
+    noFormat`const x = { y(){} };`,
+    'const x: { y: number } = { y: 1 };',
+    'const x = [...[1, 2, 3]];',
+    'const [{ [`x${1}`]: x }] = [{ [`x`]: 1 }] as [{ [`x`]: any }];',
+    `
+type T = [string, T[]];
+const test: T = ['string', []] as T;
+    `,
+    {
+      code: `
+type Props = { a: string };
+declare function Foo(props: Props): never;
+<Foo a={'foo'} />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+
+    {
+      code: `
+declare function Foo(props: { a: string }): never;
+<Foo a="foo" />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    {
+      code: `
+declare function Foo(props: { a: string }): never;
+<Foo a={} />;
+      `,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+        },
+      },
+    },
+    'const x: unknown = y as any;',
+    'const x: unknown[] = y as any[];',
+    'const x: Set<unknown> = y as Set<any>;',
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    'const x: Map<string, string> = new Map();',
+    `
+type Foo = { bar: unknown };
+const bar: any = 1;
+const foo: Foo = { bar };
+    `,
+  ],
   invalid: [
     {
       code: 'const x = 1 as any;',
@@ -377,102 +475,4 @@ const foo: Foo = { bar };
       ],
     },
   ],
-  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] as number[];',
-    'const [x, ...y] = [1, 2, 3, 4, 5];',
-    'const [x, ...y] = [1];',
-    'const [{ ...x }] = [{ x: 1 }] as [{ x: any }];',
-    '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 = 1 };',
-    noFormat`const x = { y(){} };`,
-    'const x: { y: number } = { y: 1 };',
-    'const x = [...[1, 2, 3]];',
-    'const [{ [`x${1}`]: x }] = [{ [`x`]: 1 }] as [{ [`x`]: any }];',
-    `
-type T = [string, T[]];
-const test: T = ['string', []] as T;
-    `,
-    {
-      code: `
-type Props = { a: string };
-declare function Foo(props: Props): never;
-<Foo a={'foo'} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-
-    {
-      code: `
-declare function Foo(props: { a: string }): never;
-<Foo a="foo" />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    {
-      code: `
-declare function Foo(props: { a: string }): never;
-<Foo a={} />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-        },
-      },
-    },
-    'const x: unknown = y as any;',
-    'const x: unknown[] = y as any[];',
-    'const x: Set<unknown> = y as Set<any>;',
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    'const x: Map<string, string> = new Map();',
-    `
-type Foo = { bar: unknown };
-const bar: any = 1;
-const foo: Foo = { bar };
-    `,
-  ],
 });
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 c32493858839..0792fb67c71d 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -14,6 +14,37 @@ 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');",
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1825
+    `
+      let foo: any = 23;
+      String(foo); // ERROR: Unsafe call of an any typed value
+    `,
+    // TS 3.9 changed this to be safe
+    `
+      function foo<T extends any>(x: T) {
+        x();
+      }
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -221,35 +252,4 @@ value();
       ],
     },
   ],
-  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');",
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1825
-    `
-      let foo: any = 23;
-      String(foo); // ERROR: Unsafe call of an any typed value
-    `,
-    // TS 3.9 changed this to be safe
-    `
-      function foo<T extends any>(x: T) {
-        x();
-      }
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
index cbd58771b0d2..fbaadb553e66 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-declaration-merging.test.ts
@@ -15,6 +15,52 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unsafe-declaration-merging', rule, {
+  valid: [
+    `
+interface Foo {}
+class Bar implements Foo {}
+    `,
+    `
+namespace Foo {}
+namespace Foo {}
+    `,
+    `
+enum Foo {}
+namespace Foo {}
+    `,
+    `
+namespace Fooo {}
+function Foo() {}
+    `,
+    `
+const Foo = class {};
+    `,
+    `
+interface Foo {
+  props: string;
+}
+
+function bar() {
+  return class Foo {};
+}
+    `,
+    `
+interface Foo {
+  props: string;
+}
+
+(function bar() {
+  class Foo {}
+})();
+    `,
+    `
+declare global {
+  interface Foo {}
+}
+
+class Foo {}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -73,50 +119,4 @@ declare global {
       ],
     },
   ],
-  valid: [
-    `
-interface Foo {}
-class Bar implements Foo {}
-    `,
-    `
-namespace Foo {}
-namespace Foo {}
-    `,
-    `
-enum Foo {}
-namespace Foo {}
-    `,
-    `
-namespace Fooo {}
-function Foo() {}
-    `,
-    `
-const Foo = class {};
-    `,
-    `
-interface Foo {
-  props: string;
-}
-
-function bar() {
-  return class Foo {};
-}
-    `,
-    `
-interface Foo {
-  props: string;
-}
-
-(function bar() {
-  class Foo {}
-})();
-    `,
-    `
-declare global {
-  interface Foo {}
-}
-
-class Foo {}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
index ffa4fbf1fa9f..b592b7fe513d 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts
@@ -15,917 +15,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unsafe-enum-comparison', rule, {
-  invalid: [
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple < 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple > 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple == 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple === 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple != 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        Fruit.Apple !== 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple = 0,
-          Banana = 'banana',
-        }
-        Fruit.Apple === 0;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Fruit {
-          Apple = 0,
-          Banana = 'banana',
-        }
-        Fruit.Apple === Fruit.Apple;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple = 0,
-          Banana = 'banana',
-        }
-        Fruit.Banana === '';
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        Vegetable.Asparagus === 'beet';
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-          Banana,
-          Cherry,
-        }
-        1 === Fruit.Apple;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        'beet' === Vegetable.Asparagus;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-          Banana,
-          Cherry,
-        }
-        const fruit = Fruit.Apple;
-        fruit === 1;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        const vegetable = Vegetable.Asparagus;
-        vegetable === 'beet';
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-          Banana,
-          Cherry,
-        }
-        const fruit = Fruit.Apple;
-        1 === fruit;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        const vegetable = Vegetable.Asparagus;
-        'beet' === vegetable;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code:
-        'enum Fruit { Apple, Banana, Cherry }' +
-        `enum Fruit2 {
-  Apple2,
-  Banana2,
-  Cherry2,
-}
-      Fruit.Apple === Fruit2.Apple2;
-        `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        enum Vegetable2 {
-          Asparagus2 = 'asparagus2',
-          Beet2 = 'beet2',
-          Celery2 = 'celery2',
-        }
-        Vegetable.Asparagus === Vegetable2.Asparagus2;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code:
-        'enum Fruit { Apple, Banana, Cherry }' +
-        `enum Fruit2 {
-  Apple2,
-  Banana2,
-  Cherry2,
-}
-      const fruit = Fruit.Apple;
-      fruit === Fruit2.Apple2;
-        `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-          Celery = 'celery',
-        }
-        enum Vegetable2 {
-          Asparagus2 = 'asparagus2',
-          Beet2 = 'beet2',
-          Celery2 = 'celery2',
-        }
-        const vegetable = Vegetable.Asparagus;
-        vegetable === Vegetable2.Asparagus2;
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Str {
-          A = 'a',
-        }
-        enum Num {
-          B = 1,
-        }
-        enum Mixed {
-          A = 'a',
-          B = 1,
-        }
-
-        declare const str: Str;
-        declare const num: Num;
-        declare const mixed: Mixed;
-
-        // following are all errors because the value might be an enum value
-        str === 'a';
-        num === 1;
-        mixed === 'a';
-        mixed === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-        }
-        enum Num {
-          B = 1,
-        }
-        enum Mixed {
-          A = 'a',
-          B = 1,
-        }
-
-        declare const str: Str;
-        declare const num: Num;
-        declare const mixed: Mixed;
-
-        // following are all errors because the value might be an enum value
-        str === Str.A;
-        num === 1;
-        mixed === 'a';
-        mixed === 1;
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-        }
-        enum Num {
-          B = 1,
-        }
-        enum Mixed {
-          A = 'a',
-          B = 1,
-        }
-
-        declare const str: Str;
-        declare const num: Num;
-        declare const mixed: Mixed;
-
-        // following are all errors because the value might be an enum value
-        str === 'a';
-        num === Num.B;
-        mixed === 'a';
-        mixed === 1;
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-        }
-        enum Num {
-          B = 1,
-        }
-        enum Mixed {
-          A = 'a',
-          B = 1,
-        }
-
-        declare const str: Str;
-        declare const num: Num;
-        declare const mixed: Mixed;
-
-        // following are all errors because the value might be an enum value
-        str === 'a';
-        num === 1;
-        mixed === Mixed.A;
-        mixed === 1;
-      `,
-            },
-          ],
-        },
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-        }
-        enum Num {
-          B = 1,
-        }
-        enum Mixed {
-          A = 'a',
-          B = 1,
-        }
-
-        declare const str: Str;
-        declare const num: Num;
-        declare const mixed: Mixed;
-
-        // following are all errors because the value might be an enum value
-        str === 'a';
-        num === 1;
-        mixed === 'a';
-        mixed === Mixed.B;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple = 'apple',
-        }
-        type __String =
-          | (string & { __escapedIdentifier: void })
-          | (void & { __escapedIdentifier: void })
-          | Fruit;
-        declare const weirdString: __String;
-        weirdString === 'someArbitraryValue';
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-
-        declare const fruit: Fruit;
-
-        switch (fruit) {
-          case 0: {
-            break;
-          }
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCase' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-          Banana,
-        }
-
-        declare const fruit: Fruit;
-
-        switch (fruit) {
-          case Fruit.Apple: {
-            break;
-          }
-          case 1: {
-            break;
-          }
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCase' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-        }
-
-        declare const vegetable: Vegetable;
-
-        switch (vegetable) {
-          case 'asparagus': {
-            break;
-          }
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCase' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-        }
-
-        declare const vegetable: Vegetable;
-
-        switch (vegetable) {
-          case Vegetable.Asparagus: {
-            break;
-          }
-          case 'beet': {
-            break;
-          }
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCase' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-          Beet = 'beet',
-        }
-
-        declare const vegetable: Vegetable;
-
-        switch (vegetable) {
-          case Vegetable.Asparagus: {
-            break;
-          }
-          case 'beet': {
-            break;
-          }
-          default: {
-            break;
-          }
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCase' }],
-    },
-    {
-      code: `
-        enum Str {
-          A = 'a',
-          B = 'b',
-        }
-        declare const str: Str;
-        str === 'b';
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-          B = 'b',
-        }
-        declare const str: Str;
-        str === Str.B;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Str {
-          A = 'a',
-          AB = 'ab',
-        }
-        declare const str: Str;
-        str === 'a' + 'b';
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Str {
-          A = 'a',
-          AB = 'ab',
-        }
-        declare const str: Str;
-        str === Str.AB;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        1 === num;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        Num.A === num;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        1 /* with */ === /* comment */ num;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        Num.A /* with */ === /* comment */ num;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        1 + 1 === num;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Num {
-          A = 1,
-          B = 2,
-        }
-        declare const num: Num;
-        Num.B === num;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Mixed {
-          A = 1,
-          B = 'b',
-        }
-        declare const mixed: Mixed;
-        mixed === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Mixed {
-          A = 1,
-          B = 'b',
-        }
-        declare const mixed: Mixed;
-        mixed === Mixed.A;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Mixed {
-          A = 1,
-          B = 'b',
-        }
-        declare const mixed: Mixed;
-        mixed === 'b';
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum Mixed {
-          A = 1,
-          B = 'b',
-        }
-        declare const mixed: Mixed;
-        mixed === Mixed.B;
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum StringKey {
-          'test-key' /* with comment */ = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum StringKey {
-          'test-key' /* with comment */ = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === StringKey['test-key'];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum StringKey {
-          "key-'with-single'-quotes" = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum StringKey {
-          "key-'with-single'-quotes" = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === StringKey['key-\\'with-single\\'-quotes'];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum StringKey {
-          'key-"with-double"-quotes' = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum StringKey {
-          'key-"with-double"-quotes' = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === StringKey['key-"with-double"-quotes'];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum StringKey {
-          'key-\`with-backticks\`-quotes' = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum StringKey {
-          'key-\`with-backticks\`-quotes' = 1,
-        }
-        declare const stringKey: StringKey;
-        stringKey === StringKey['key-\`with-backticks\`-quotes'];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum ComputedKey {
-          ['test-key' /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum ComputedKey {
-          ['test-key' /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === ComputedKey['test-key'];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum ComputedKey {
-          [\`test-key\` /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum ComputedKey {
-          [\`test-key\` /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === ComputedKey[\`test-key\`];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum ComputedKey {
-          [\`test-
-          key\` /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === 1;
-      `,
-      errors: [
-        {
-          messageId: 'mismatchedCondition',
-          suggestions: [
-            {
-              messageId: 'replaceValueWithEnum',
-              output: `
-        enum ComputedKey {
-          [\`test-
-          key\` /* with comment */] = 1,
-        }
-        declare const computedKey: ComputedKey;
-        computedKey === ComputedKey[\`test-
-          key\`];
-      `,
-            },
-          ],
-        },
-      ],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        declare const foo: number & {};
-        if (foo === Fruit.Apple) {
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Fruit {
-          Apple,
-        }
-        declare const foo: number & { __someBrand: void };
-        if (foo === Fruit.Apple) {
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-        }
-        declare const foo: string & {};
-        if (foo === Vegetable.Asparagus) {
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-    {
-      code: `
-        enum Vegetable {
-          Asparagus = 'asparagus',
-        }
-        declare const foo: string & { __someBrand: void };
-        if (foo === Vegetable.Asparagus) {
-        }
-      `,
-      errors: [{ messageId: 'mismatchedCondition' }],
-    },
-  ],
   valid: [
     "'a' > 'b';",
     "'a' < 'b';",
@@ -1113,138 +202,1049 @@ ruleTester.run('no-unsafe-enum-comparison', rule, {
         Banana2,
         Cherry2,
       }
-      declare const left: number | Fruit;
-      declare const right: number | Fruit2;
-      left === right;
+      declare const left: number | Fruit;
+      declare const right: number | Fruit2;
+      left === right;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      enum Vegetable2 {
+        Asparagus2 = 'asparagus2',
+        Beet2 = 'beet2',
+        Celery2 = 'celery2',
+      }
+      declare const left: string | Vegetable;
+      declare const right: string | Vegetable2;
+      left === right;
+    `,
+    `
+      enum Vegetable {
+        Asparagus = 'asparagus',
+        Beet = 'beet',
+        Celery = 'celery',
+      }
+      const foo = {};
+      const vegetable = Vegetable.Asparagus;
+      vegetable in foo;
+    `,
+    `
+      enum Fruit {
+        Apple,
+        Banana,
+        Cherry,
+      }
+      declare const fruitOrBoolean: Fruit | boolean;
+      fruitOrBoolean === true;
+    `,
+    `
+      enum Str {
+        A = 'a',
+      }
+      enum Num {
+        B = 1,
+      }
+      enum Mixed {
+        A = 'a',
+        B = 1,
+      }
+
+      declare const str: Str;
+      declare const strOrString: Str | string;
+
+      declare const num: Num;
+      declare const numOrNumber: Num | number;
+
+      declare const mixed: Mixed;
+      declare const mixedOrStringOrNumber: Mixed | string | number;
+
+      function someFunction() {}
+
+      // following are all ignored due to the presence of "| string" or "| number"
+      strOrString === 'a';
+      numOrNumber === 1;
+      mixedOrStringOrNumber === 'a';
+      mixedOrStringOrNumber === 1;
+
+      // following are all ignored because the value can never be an enum value
+      str === 1;
+      num === 'a';
+      str === {};
+      num === {};
+      mixed === {};
+      str === true;
+      num === true;
+      mixed === true;
+      str === someFunction;
+      num === someFunction;
+      mixed === someFunction;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      const bitShift = 1 << Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      const bitShift = 1 >> Fruit.Apple;
+    `,
+    `
+      enum Fruit {
+        Apple,
+      }
+
+      declare const fruit: Fruit;
+
+      switch (fruit) {
+        case Fruit.Apple: {
+          break;
+        }
+      }
     `,
     `
       enum Vegetable {
         Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
       }
-      enum Vegetable2 {
-        Asparagus2 = 'asparagus2',
-        Beet2 = 'beet2',
-        Celery2 = 'celery2',
+
+      declare const vegetable: Vegetable;
+
+      switch (vegetable) {
+        case Vegetable.Asparagus: {
+          break;
+        }
       }
-      declare const left: string | Vegetable;
-      declare const right: string | Vegetable2;
-      left === right;
     `,
     `
       enum Vegetable {
         Asparagus = 'asparagus',
-        Beet = 'beet',
-        Celery = 'celery',
       }
-      const foo = {};
-      const vegetable = Vegetable.Asparagus;
-      vegetable in foo;
-    `,
-    `
-      enum Fruit {
-        Apple,
-        Banana,
-        Cherry,
+
+      declare const vegetable: Vegetable;
+
+      switch (vegetable) {
+        default: {
+          break;
+        }
       }
-      declare const fruitOrBoolean: Fruit | boolean;
-      fruitOrBoolean === true;
     `,
-    `
-      enum Str {
-        A = 'a',
-      }
-      enum Num {
-        B = 1,
-      }
-      enum Mixed {
-        A = 'a',
-        B = 1,
-      }
+  ],
+  invalid: [
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple < 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple > 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple == 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple === 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple != 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        Fruit.Apple !== 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple = 0,
+          Banana = 'banana',
+        }
+        Fruit.Apple === 0;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Fruit {
+          Apple = 0,
+          Banana = 'banana',
+        }
+        Fruit.Apple === Fruit.Apple;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple = 0,
+          Banana = 'banana',
+        }
+        Fruit.Banana === '';
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        Vegetable.Asparagus === 'beet';
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+          Banana,
+          Cherry,
+        }
+        1 === Fruit.Apple;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        'beet' === Vegetable.Asparagus;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+          Banana,
+          Cherry,
+        }
+        const fruit = Fruit.Apple;
+        fruit === 1;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        const vegetable = Vegetable.Asparagus;
+        vegetable === 'beet';
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+          Banana,
+          Cherry,
+        }
+        const fruit = Fruit.Apple;
+        1 === fruit;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        const vegetable = Vegetable.Asparagus;
+        'beet' === vegetable;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code:
+        'enum Fruit { Apple, Banana, Cherry }' +
+        `enum Fruit2 {
+  Apple2,
+  Banana2,
+  Cherry2,
+}
+      Fruit.Apple === Fruit2.Apple2;
+        `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        enum Vegetable2 {
+          Asparagus2 = 'asparagus2',
+          Beet2 = 'beet2',
+          Celery2 = 'celery2',
+        }
+        Vegetable.Asparagus === Vegetable2.Asparagus2;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code:
+        'enum Fruit { Apple, Banana, Cherry }' +
+        `enum Fruit2 {
+  Apple2,
+  Banana2,
+  Cherry2,
+}
+      const fruit = Fruit.Apple;
+      fruit === Fruit2.Apple2;
+        `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+          Celery = 'celery',
+        }
+        enum Vegetable2 {
+          Asparagus2 = 'asparagus2',
+          Beet2 = 'beet2',
+          Celery2 = 'celery2',
+        }
+        const vegetable = Vegetable.Asparagus;
+        vegetable === Vegetable2.Asparagus2;
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Str {
+          A = 'a',
+        }
+        enum Num {
+          B = 1,
+        }
+        enum Mixed {
+          A = 'a',
+          B = 1,
+        }
 
-      declare const str: Str;
-      declare const strOrString: Str | string;
+        declare const str: Str;
+        declare const num: Num;
+        declare const mixed: Mixed;
 
-      declare const num: Num;
-      declare const numOrNumber: Num | number;
+        // following are all errors because the value might be an enum value
+        str === 'a';
+        num === 1;
+        mixed === 'a';
+        mixed === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+        }
+        enum Num {
+          B = 1,
+        }
+        enum Mixed {
+          A = 'a',
+          B = 1,
+        }
 
-      declare const mixed: Mixed;
-      declare const mixedOrStringOrNumber: Mixed | string | number;
+        declare const str: Str;
+        declare const num: Num;
+        declare const mixed: Mixed;
 
-      function someFunction() {}
+        // following are all errors because the value might be an enum value
+        str === Str.A;
+        num === 1;
+        mixed === 'a';
+        mixed === 1;
+      `,
+            },
+          ],
+        },
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+        }
+        enum Num {
+          B = 1,
+        }
+        enum Mixed {
+          A = 'a',
+          B = 1,
+        }
 
-      // following are all ignored due to the presence of "| string" or "| number"
-      strOrString === 'a';
-      numOrNumber === 1;
-      mixedOrStringOrNumber === 'a';
-      mixedOrStringOrNumber === 1;
+        declare const str: Str;
+        declare const num: Num;
+        declare const mixed: Mixed;
 
-      // following are all ignored because the value can never be an enum value
-      str === 1;
-      num === 'a';
-      str === {};
-      num === {};
-      mixed === {};
-      str === true;
-      num === true;
-      mixed === true;
-      str === someFunction;
-      num === someFunction;
-      mixed === someFunction;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
+        // following are all errors because the value might be an enum value
+        str === 'a';
+        num === Num.B;
+        mixed === 'a';
+        mixed === 1;
+      `,
+            },
+          ],
+        },
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+        }
+        enum Num {
+          B = 1,
+        }
+        enum Mixed {
+          A = 'a',
+          B = 1,
+        }
+
+        declare const str: Str;
+        declare const num: Num;
+        declare const mixed: Mixed;
+
+        // following are all errors because the value might be an enum value
+        str === 'a';
+        num === 1;
+        mixed === Mixed.A;
+        mixed === 1;
+      `,
+            },
+          ],
+        },
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+        }
+        enum Num {
+          B = 1,
+        }
+        enum Mixed {
+          A = 'a',
+          B = 1,
+        }
+
+        declare const str: Str;
+        declare const num: Num;
+        declare const mixed: Mixed;
+
+        // following are all errors because the value might be an enum value
+        str === 'a';
+        num === 1;
+        mixed === 'a';
+        mixed === Mixed.B;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple = 'apple',
+        }
+        type __String =
+          | (string & { __escapedIdentifier: void })
+          | (void & { __escapedIdentifier: void })
+          | Fruit;
+        declare const weirdString: __String;
+        weirdString === 'someArbitraryValue';
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+
+        declare const fruit: Fruit;
+
+        switch (fruit) {
+          case 0: {
+            break;
+          }
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCase' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+          Banana,
+        }
+
+        declare const fruit: Fruit;
+
+        switch (fruit) {
+          case Fruit.Apple: {
+            break;
+          }
+          case 1: {
+            break;
+          }
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCase' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+        }
+
+        declare const vegetable: Vegetable;
 
-      const bitShift = 1 << Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
+        switch (vegetable) {
+          case 'asparagus': {
+            break;
+          }
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCase' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+        }
 
-      const bitShift = 1 >> Fruit.Apple;
-    `,
-    `
-      enum Fruit {
-        Apple,
-      }
+        declare const vegetable: Vegetable;
 
-      declare const fruit: Fruit;
+        switch (vegetable) {
+          case Vegetable.Asparagus: {
+            break;
+          }
+          case 'beet': {
+            break;
+          }
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCase' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+          Beet = 'beet',
+        }
 
-      switch (fruit) {
-        case Fruit.Apple: {
-          break;
+        declare const vegetable: Vegetable;
+
+        switch (vegetable) {
+          case Vegetable.Asparagus: {
+            break;
+          }
+          case 'beet': {
+            break;
+          }
+          default: {
+            break;
+          }
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCase' }],
+    },
+    {
+      code: `
+        enum Str {
+          A = 'a',
+          B = 'b',
+        }
+        declare const str: Str;
+        str === 'b';
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+          B = 'b',
+        }
+        declare const str: Str;
+        str === Str.B;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Str {
+          A = 'a',
+          AB = 'ab',
+        }
+        declare const str: Str;
+        str === 'a' + 'b';
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Str {
+          A = 'a',
+          AB = 'ab',
+        }
+        declare const str: Str;
+        str === Str.AB;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        1 === num;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        Num.A === num;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        1 /* with */ === /* comment */ num;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        Num.A /* with */ === /* comment */ num;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        1 + 1 === num;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Num {
+          A = 1,
+          B = 2,
+        }
+        declare const num: Num;
+        Num.B === num;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Mixed {
+          A = 1,
+          B = 'b',
+        }
+        declare const mixed: Mixed;
+        mixed === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Mixed {
+          A = 1,
+          B = 'b',
+        }
+        declare const mixed: Mixed;
+        mixed === Mixed.A;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Mixed {
+          A = 1,
+          B = 'b',
+        }
+        declare const mixed: Mixed;
+        mixed === 'b';
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum Mixed {
+          A = 1,
+          B = 'b',
+        }
+        declare const mixed: Mixed;
+        mixed === Mixed.B;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum StringKey {
+          'test-key' /* with comment */ = 1,
         }
-      }
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-      }
-
-      declare const vegetable: Vegetable;
-
-      switch (vegetable) {
-        case Vegetable.Asparagus: {
-          break;
+        declare const stringKey: StringKey;
+        stringKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum StringKey {
+          'test-key' /* with comment */ = 1,
         }
-      }
-    `,
-    `
-      enum Vegetable {
-        Asparagus = 'asparagus',
-      }
-
-      declare const vegetable: Vegetable;
-
-      switch (vegetable) {
-        default: {
-          break;
+        declare const stringKey: StringKey;
+        stringKey === StringKey['test-key'];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum StringKey {
+          "key-'with-single'-quotes" = 1,
         }
-      }
-    `,
+        declare const stringKey: StringKey;
+        stringKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum StringKey {
+          "key-'with-single'-quotes" = 1,
+        }
+        declare const stringKey: StringKey;
+        stringKey === StringKey['key-\\'with-single\\'-quotes'];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum StringKey {
+          'key-"with-double"-quotes' = 1,
+        }
+        declare const stringKey: StringKey;
+        stringKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum StringKey {
+          'key-"with-double"-quotes' = 1,
+        }
+        declare const stringKey: StringKey;
+        stringKey === StringKey['key-"with-double"-quotes'];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum StringKey {
+          'key-\`with-backticks\`-quotes' = 1,
+        }
+        declare const stringKey: StringKey;
+        stringKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum StringKey {
+          'key-\`with-backticks\`-quotes' = 1,
+        }
+        declare const stringKey: StringKey;
+        stringKey === StringKey['key-\`with-backticks\`-quotes'];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum ComputedKey {
+          ['test-key' /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum ComputedKey {
+          ['test-key' /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === ComputedKey['test-key'];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum ComputedKey {
+          [\`test-key\` /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum ComputedKey {
+          [\`test-key\` /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === ComputedKey[\`test-key\`];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum ComputedKey {
+          [\`test-
+          key\` /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === 1;
+      `,
+      errors: [
+        {
+          messageId: 'mismatchedCondition',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `
+        enum ComputedKey {
+          [\`test-
+          key\` /* with comment */] = 1,
+        }
+        declare const computedKey: ComputedKey;
+        computedKey === ComputedKey[\`test-
+          key\`];
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        declare const foo: number & {};
+        if (foo === Fruit.Apple) {
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Fruit {
+          Apple,
+        }
+        declare const foo: number & { __someBrand: void };
+        if (foo === Fruit.Apple) {
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+        }
+        declare const foo: string & {};
+        if (foo === Vegetable.Asparagus) {
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
+    {
+      code: `
+        enum Vegetable {
+          Asparagus = 'asparagus',
+        }
+        declare const foo: string & { __someBrand: void };
+        if (foo === Vegetable.Asparagus) {
+        }
+      `,
+      errors: [{ messageId: 'mismatchedCondition' }],
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
index 2ec23a17db1b..0a60ad35209a 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-function-type.test.ts
@@ -5,6 +5,14 @@ import rule from '../../src/rules/no-unsafe-function-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-unsafe-function-type', rule, {
+  valid: [
+    'let value: () => void;',
+    'let value: <T>(t: T) => T;',
+    `
+      type Function = () => void;
+      let value: Function;
+    `,
+  ],
   invalid: [
     {
       code: 'let value: Function;',
@@ -70,12 +78,4 @@ ruleTester.run('no-unsafe-function-type', rule, {
       output: null,
     },
   ],
-  valid: [
-    'let value: () => void;',
-    'let value: <T>(t: T) => T;',
-    `
-      type Function = () => void;
-      let value: Function;
-    `,
-  ],
 });
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 78d08c4bceec..089d20ee6e19 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
@@ -14,6 +14,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];
+}
+    `,
+    `
+class B implements FG.A {}
+    `,
+    `
+interface B extends FG.A {}
+    `,
+    `
+class B implements F.S.T.A {}
+    `,
+    `
+interface B extends F.S.T.A {}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -329,58 +383,4 @@ class C {
       ],
     },
   ],
-  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];
-}
-    `,
-    `
-class B implements FG.A {}
-    `,
-    `
-interface B extends FG.A {}
-    `,
-    `
-class B implements F.S.T.A {}
-    `,
-    `
-interface B extends F.S.T.A {}
-    `,
-  ],
 });
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 3ffa255f92b8..49396e113b9f 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
@@ -14,6 +14,153 @@ 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;
+}
+    `,
+    // this actually types as `never[]`
+    `
+function foo() {
+  return [];
+}
+    `,
+    // explicit any return type is allowed, if you want to be unsafe like that
+    `
+function foo(): any {
+  return {} as any;
+}
+    `,
+    `
+declare function foo(arg: () => any): void;
+foo((): any => 'foo' as any);
+    `,
+    `
+declare function foo(arg: null | (() => any)): void;
+foo((): any => 'foo' as any);
+    `,
+    // explicit any array return type is allowed, if you want to be unsafe like that
+    `
+function foo(): any[] {
+  return [] as any[];
+}
+    `,
+    // explicit any generic return type is allowed, if you want to be unsafe like that
+    `
+function foo(): Set<any> {
+  return new Set<any>();
+}
+    `,
+    `
+async function foo(): Promise<any> {
+  return Promise.resolve({} as any);
+}
+    `,
+    `
+async function foo(): Promise<any> {
+  return {} as any;
+}
+    `,
+    `
+function foo(): object {
+  return Promise.resolve({} as 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]);
+}
+    `,
+    `
+      type Foo<T = number> = { prop: T };
+      function foo(): Foo {
+        return { prop: 1 } as Foo<number>;
+      }
+    `,
+    `
+      type Foo = { prop: any };
+      function foo(): Foo {
+        return { prop: '' } as Foo;
+      }
+    `,
+    // TS 3.9 changed this to be safe
+    `
+      function fn<T extends any>(x: T) {
+        return x;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): unknown {
+        return x as any;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): unknown[] {
+        return x as any[];
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): Set<unknown> {
+        return x as Set<any>;
+      }
+    `,
+    `
+      async function fn<T extends any>(x: T): Promise<unknown> {
+        return x as any;
+      }
+    `,
+    `
+      function fn<T extends any>(x: T): Promise<unknown> {
+        return Promise.resolve(x as any);
+      }
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+    `
+      function test(): Map<string, string> {
+        return new Map();
+      }
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3549
+    `
+      function foo(): any {
+        return [] as any[];
+      }
+    `,
+    `
+      function foo(): unknown {
+        return [] as any[];
+      }
+    `,
+    `
+      declare const value: Promise<any>;
+      function foo() {
+        return value;
+      }
+    `,
+    'const foo: (() => void) | undefined = () => 1;',
+  ],
   invalid: [
     {
       code: `
@@ -574,151 +721,4 @@ async function foo() {
       ],
     },
   ],
-  valid: [
-    `
-function foo() {
-  return;
-}
-    `,
-    `
-function foo() {
-  return 1;
-}
-    `,
-    `
-function foo() {
-  return '';
-}
-    `,
-    `
-function foo() {
-  return true;
-}
-    `,
-    // this actually types as `never[]`
-    `
-function foo() {
-  return [];
-}
-    `,
-    // explicit any return type is allowed, if you want to be unsafe like that
-    `
-function foo(): any {
-  return {} as any;
-}
-    `,
-    `
-declare function foo(arg: () => any): void;
-foo((): any => 'foo' as any);
-    `,
-    `
-declare function foo(arg: null | (() => any)): void;
-foo((): any => 'foo' as any);
-    `,
-    // explicit any array return type is allowed, if you want to be unsafe like that
-    `
-function foo(): any[] {
-  return [] as any[];
-}
-    `,
-    // explicit any generic return type is allowed, if you want to be unsafe like that
-    `
-function foo(): Set<any> {
-  return new Set<any>();
-}
-    `,
-    `
-async function foo(): Promise<any> {
-  return Promise.resolve({} as any);
-}
-    `,
-    `
-async function foo(): Promise<any> {
-  return {} as any;
-}
-    `,
-    `
-function foo(): object {
-  return Promise.resolve({} as 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]);
-}
-    `,
-    `
-      type Foo<T = number> = { prop: T };
-      function foo(): Foo {
-        return { prop: 1 } as Foo<number>;
-      }
-    `,
-    `
-      type Foo = { prop: any };
-      function foo(): Foo {
-        return { prop: '' } as Foo;
-      }
-    `,
-    // TS 3.9 changed this to be safe
-    `
-      function fn<T extends any>(x: T) {
-        return x;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): unknown {
-        return x as any;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): unknown[] {
-        return x as any[];
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): Set<unknown> {
-        return x as Set<any>;
-      }
-    `,
-    `
-      async function fn<T extends any>(x: T): Promise<unknown> {
-        return x as any;
-      }
-    `,
-    `
-      function fn<T extends any>(x: T): Promise<unknown> {
-        return Promise.resolve(x as any);
-      }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2109
-    `
-      function test(): Map<string, string> {
-        return new Map();
-      }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3549
-    `
-      function foo(): any {
-        return [] as any[];
-      }
-    `,
-    `
-      function foo(): unknown {
-        return [] as any[];
-      }
-    `,
-    `
-      declare const value: Promise<any>;
-      function foo() {
-        return value;
-      }
-    `,
-    'const foo: (() => void) | undefined = () => 1;',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
index 2e047a0477d4..0aea759ca375 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-unary-minus.test.ts
@@ -14,20 +14,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-unsafe-unary-minus', rule, {
-  invalid: [
-    { code: '(a: string) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: {}) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: number[]) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: "-'hello';", errors: [{ messageId: 'unaryMinus' }] },
-    { code: '-`hello`;', errors: [{ messageId: 'unaryMinus' }] },
-    {
-      code: '(a: { x: number }) => -a;',
-      errors: [{ messageId: 'unaryMinus' }],
-    },
-    { code: '(a: unknown) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '(a: void) => -a;', errors: [{ messageId: 'unaryMinus' }] },
-    { code: '<T,>(t: T) => -t;', errors: [{ messageId: 'unaryMinus' }] },
-  ],
   valid: [
     '+42;',
     '-42;',
@@ -44,4 +30,18 @@ ruleTester.run('no-unsafe-unary-minus', rule, {
     '(a: never) => -a;',
     '<T extends number>(t: T) => -t;',
   ],
+  invalid: [
+    { code: '(a: string) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: {}) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: number[]) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: "-'hello';", errors: [{ messageId: 'unaryMinus' }] },
+    { code: '-`hello`;', errors: [{ messageId: 'unaryMinus' }] },
+    {
+      code: '(a: { x: number }) => -a;',
+      errors: [{ messageId: 'unaryMinus' }],
+    },
+    { code: '(a: unknown) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '(a: void) => -a;', errors: [{ messageId: 'unaryMinus' }] },
+    { code: '<T,>(t: T) => -t;', errors: [{ messageId: 'unaryMinus' }] },
+  ],
 });
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 04a7e40a1025..8c02cc21e769 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
@@ -27,6 +27,68 @@ function error(
 }
 
 ruleTester.run('no-unused-expressions', rule, {
+  valid: [
+    `
+      test.age?.toLocaleString();
+    `,
+    `
+      let a = (a?.b).c;
+    `,
+    `
+      let b = a?.['b'];
+    `,
+    `
+      let c = one[2]?.[3][4];
+    `,
+    `
+      one[2]?.[3][4]?.();
+    `,
+    `
+      a?.['b']?.c();
+    `,
+    `
+      module Foo {
+        'use strict';
+      }
+    `,
+    `
+      namespace Foo {
+        'use strict';
+
+        export class Foo {}
+        export class Bar {}
+      }
+    `,
+    `
+      function foo() {
+        'use strict';
+
+        return null;
+      }
+    `,
+    `
+      import('./foo');
+    `,
+    `
+      import('./foo').then(() => {});
+    `,
+    `
+      class Foo<T> {}
+      new Foo<string>();
+    `,
+    {
+      code: 'foo && foo?.();',
+      options: [{ allowShortCircuit: true }],
+    },
+    {
+      code: "foo && import('./foo');",
+      options: [{ allowShortCircuit: true }],
+    },
+    {
+      code: "foo ? import('./foo') : import('./bar');",
+      options: [{ allowTernary: true }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -320,66 +382,4 @@ foo!;
       ]),
     },
   ],
-  valid: [
-    `
-      test.age?.toLocaleString();
-    `,
-    `
-      let a = (a?.b).c;
-    `,
-    `
-      let b = a?.['b'];
-    `,
-    `
-      let c = one[2]?.[3][4];
-    `,
-    `
-      one[2]?.[3][4]?.();
-    `,
-    `
-      a?.['b']?.c();
-    `,
-    `
-      module Foo {
-        'use strict';
-      }
-    `,
-    `
-      namespace Foo {
-        'use strict';
-
-        export class Foo {}
-        export class Bar {}
-      }
-    `,
-    `
-      function foo() {
-        'use strict';
-
-        return null;
-      }
-    `,
-    `
-      import('./foo');
-    `,
-    `
-      import('./foo').then(() => {});
-    `,
-    `
-      class Foo<T> {}
-      new Foo<string>();
-    `,
-    {
-      code: 'foo && foo?.();',
-      options: [{ allowShortCircuit: true }],
-    },
-    {
-      code: "foo && import('./foo');",
-      options: [{ allowShortCircuit: true }],
-    },
-    {
-      code: "foo ? import('./foo') : import('./bar');",
-      options: [{ allowTernary: true }],
-    },
-  ],
 });
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 ff60637746e2..f22187095ed0 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
@@ -8,1056 +8,825 @@ const ruleTester = new RuleTester();
 const parserOptions = { ecmaVersion: 6 as const };
 
 ruleTester.run('no-use-before-define', rule, {
-  invalid: [
+  valid: [
+    `
+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);
+}
+    `,
+    'Object.hasOwnProperty.call(a);',
+    `
+function a() {
+  alert(arguments);
+}
+    `,
+    'declare function a();',
+    `
+declare class a {
+  foo();
+}
+    `,
+    'const updatedAt = data?.updatedAt;',
+    `
+function f() {
+  return function t() {};
+}
+f()?.();
+    `,
+    `
+var a = { b: 5 };
+alert(a?.b);
+    `,
     {
       code: `
-a++;
-var a = 19;
+a();
+function a() {
+  alert(arguments);
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: {
-        parserOptions: { sourceType: 'module' },
-      },
+      options: ['nofunc'],
     },
     {
       code: `
-a++;
-var a = 19;
+(() => {
+  var a = 42;
+  alert(a);
+})();
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
     },
+    `
+a();
+try {
+  throw new Error();
+} catch (a) {}
+    `,
     {
       code: `
-a++;
-var a = 19;
-      `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: `
-a();
-var a = function () {};
+class A {}
+new A();
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions },
     },
+    `
+var a = 0,
+  b = a;
+    `,
+    { code: 'var { a = 0, b = a } = {};', languageOptions: { parserOptions } },
+    { code: 'var [a = 0, b = a] = {};', languageOptions: { parserOptions } },
+    `
+function foo() {
+  foo();
+}
+    `,
+    `
+var foo = function () {
+  foo();
+};
+    `,
+    `
+var a;
+for (a in a) {
+}
+    `,
     {
       code: `
-alert(a[1]);
-var a = [1, 3];
+var a;
+for (a of a) {
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions },
     },
+
+    // Block-level bindings
     {
       code: `
+'use strict';
 a();
-function a() {
-  alert(b);
-  var b = 10;
-  a();
+{
+  function a() {}
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-        {
-          data: { name: 'b' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-a();
-var a = function () {};
+'use strict';
+{
+  a();
+  function a() {}
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      languageOptions: { parserOptions },
       options: ['nofunc'],
     },
     {
       code: `
-(() => {
-  alert(a);
-  var a = 42;
-})();
+switch (foo) {
+  case 1: {
+    a();
+  }
+  default: {
+    let a;
+  }
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-(() => a())();
-function a() {}
+a();
+{
+  let a = function () {};
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
     },
+
+    // object style options
     {
       code: `
 a();
-try {
-  throw new Error();
-} catch (foo) {
-  var a;
+function a() {
+  alert(arguments);
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      options: [{ functions: false }],
     },
     {
       code: `
-var f = () => a;
-var a;
+'use strict';
+{
+  a();
+  function a() {}
+}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
+      options: [{ functions: false }],
     },
     {
       code: `
-new A();
+function foo() {
+  new A();
+}
 class A {}
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
+      options: [{ classes: false }],
     },
+
+    // "variables" option
     {
       code: `
 function foo() {
-  new A();
+  bar;
 }
-class A {}
+var bar;
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ variables: false }],
     },
     {
       code: `
-new A();
-var A = class {};
+var foo = () => bar;
+var bar;
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
+      options: [{ variables: false }],
     },
+
+    // "typedefs" option
     {
       code: `
-function foo() {
-  new A();
+var x: Foo = 2;
+type Foo = string | number;
+      `,
+      options: [{ typedefs: false }],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2572
+    {
+      code: `
+interface Bar {
+  type: typeof Foo;
 }
-var A = class {};
+
+const Foo = 2;
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ ignoreTypeReferences: true }],
     },
+    {
+      code: `
+interface Bar {
+  type: typeof Foo.FOO;
+}
 
-    // Block-level bindings
+class Foo {
+  public static readonly FOO = '';
+}
+      `,
+      options: [{ ignoreTypeReferences: true }],
+    },
     {
       code: `
-a++;
-{
-  var a;
+interface Bar {
+  type: typeof Foo.Bar.Baz;
 }
+
+const Foo = {
+  Bar: {
+    Baz: 1,
+  },
+};
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ ignoreTypeReferences: true }],
     },
+    // https://github.com/bradzacher/eslint-plugin-typescript/issues/141
     {
       code: `
-'use strict';
-{
-  a();
-  function a() {}
+interface ITest {
+  first: boolean;
+  second: string;
+  third: boolean;
+}
+
+let first = () => console.log('first');
+
+export let second = () => console.log('second');
+
+export namespace Third {
+  export let third = () => console.log('third');
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      languageOptions: {
+        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;
+}
+    `,
+    // https://github.com/eslint/typescript-eslint-parser/issues/435
+    `
+interface Foo {
+  bar: string;
+}
+const bar = 'blah';
+    `,
     {
       code: `
-{
-  a;
-  let a = 1;
+function foo(): Foo {
+  return Foo.FOO;
+}
+
+enum Foo {
+  FOO,
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ enums: false }],
     },
     {
       code: `
-switch (foo) {
-  case 1:
-    a();
-  default:
-    let a;
+let foo: Foo;
+
+enum Foo {
+  FOO,
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ enums: false }],
     },
     {
       code: `
-if (true) {
-  function foo() {
-    a;
+class Test {
+  foo(args: Foo): Foo {
+    return Foo.FOO;
   }
-  let a;
+}
+
+enum Foo {
+  FOO,
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ enums: false }],
     },
 
-    // object style options
+    // "allowNamedExports" option
     {
       code: `
-a();
-var a = function () {};
+export { a };
+const a = 1;
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      options: [{ classes: false, functions: false }],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-new A();
-var A = class {};
+export { a as b };
+const a = 1;
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
-      options: [{ classes: false }],
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-function foo() {
-  new A();
-}
-var A = class {};
+export { a, b };
+let a, b;
       `,
-      errors: [
-        {
-          data: { name: 'A' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
-      options: [{ classes: false }],
+      options: [{ allowNamedExports: true }],
     },
-
-    // invalid initializers
     {
-      code: 'var a = a;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      code: `
+export { a };
+var a;
+      `,
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
-      code: 'let a = a + b;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'const a = foo(a);',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'function foo(a = a) {}',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var { a = a } = [];',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var [a = a] = [];',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var { b = a, a } = {};',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var [b = a, a] = {};',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var { a = 0 } = a;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      languageOptions: { parserOptions },
-    },
-    {
-      code: 'var [a = 0] = a;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
+      code: `
+export { f };
+function f() {}
+      `,
       languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-for (var a in a) {
-}
-      `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-    },
-    {
-      code: `
-for (var a of a) {
-}
+export { C };
+class C {}
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
       languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
-
-    // "ignoreTypeReferences" option
     {
       code: `
-interface Bar {
-  type: typeof Foo;
-}
+export { Foo };
 
-const Foo = 2;
+enum Foo {
+  BAR,
+}
       `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      options: [{ ignoreTypeReferences: false }],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-interface Bar {
-  type: typeof Foo.FOO;
-}
+export { Foo };
 
-class Foo {
-  public static readonly FOO = '';
+namespace Foo {
+  export let bar = () => console.log('bar');
 }
       `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      options: [{ ignoreTypeReferences: false }],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-interface Bar {
-  type: typeof Foo.Bar.Baz;
+export { Foo, baz };
+
+enum Foo {
+  BAR,
 }
 
-const Foo = {
-  Bar: {
-    Baz: 1,
-  },
-};
+let baz: Enum;
+enum Enum {}
       `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
-        },
-      ],
-      options: [{ ignoreTypeReferences: false }],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: true }],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2502
     {
       code: `
-const foo = {
-  bar: 'bar',
-} satisfies {
-  bar: typeof baz;
-};
+import * as React from 'react';
 
-const baz = '';
+<div />;
       `,
-      errors: [
-        {
-          data: { name: 'baz' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          sourceType: 'module',
         },
-      ],
-      options: [{ ignoreTypeReferences: false }],
+      },
     },
-
-    // "variables" option
     {
       code: `
-function foo() {
-  bar;
-  var bar = 1;
-}
-var bar;
+import React from 'react';
+
+<div />;
       `,
-      errors: [
-        {
-          data: { name: 'bar' },
-          messageId: 'noUseBeforeDefine',
-          type: AST_NODE_TYPES.Identifier,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          sourceType: 'module',
         },
-      ],
-      languageOptions: { parserOptions },
-      options: [{ variables: false }],
+      },
     },
     {
       code: `
-class Test {
-  foo(args: Foo): Foo {
-    return Foo.FOO;
-  }
-}
+import { h } from 'preact';
 
-enum Foo {
-  FOO,
-}
+<div />;
       `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          line: 4,
-          messageId: 'noUseBeforeDefine',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: 'h',
+          sourceType: 'module',
         },
-      ],
-      options: [{ enums: true }],
+      },
     },
     {
       code: `
-function foo(): Foo {
-  return Foo.FOO;
-}
+const React = require('react');
 
-enum Foo {
-  FOO,
-}
+<div />;
       `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          line: 3,
-          messageId: 'noUseBeforeDefine',
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
-      ],
-      options: [{ enums: true }],
+      },
     },
-    {
-      code: `
-const foo = Foo.Foo;
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2527
+    `
+type T = (value: unknown) => value is Id;
+    `,
+    `
+global.foo = true;
 
-enum Foo {
-  FOO,
+declare global {
+  namespace NodeJS {
+    interface Global {
+      foo?: boolean;
+    }
+  }
 }
-      `,
-      errors: [
-        {
-          data: { name: 'Foo' },
-          line: 2,
-          messageId: 'noUseBeforeDefine',
-        },
-      ],
-      options: [{ enums: true }],
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2824
+    `
+@Directive({
+  selector: '[rcCidrIpPattern]',
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      useExisting: CidrIpPatternDirective,
+      multi: true,
     },
-    // "allowNamedExports" option
+  ],
+})
+export class CidrIpPatternDirective implements Validator {}
+    `,
     {
       code: `
-export { a };
-const a = 1;
+@Directive({
+  selector: '[rcCidrIpPattern]',
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      useExisting: CidrIpPatternDirective,
+      multi: true,
+    },
+  ],
+})
+export class CidrIpPatternDirective implements Validator {}
       `,
-      errors: [
+      options: [
         {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
+          classes: false,
         },
       ],
-      languageOptions: { parserOptions },
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/2941
+    `
+class A {
+  constructor(printName) {
+    this.printName = printName;
+  }
+
+  openPort(printerName = this.printerName) {
+    this.tscOcx.ActiveXopenport(printerName);
+
+    return this;
+  }
+}
+    `,
     {
       code: `
-export { a };
-const a = 1;
+const obj = {
+  foo: 'foo-value',
+  bar: 'bar-value',
+} satisfies {
+  [key in 'foo' | 'bar']: \`\${key}-value\`;
+};
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-        },
-      ],
-      languageOptions: { parserOptions },
-      options: [{}],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
-export { a };
-const a = 1;
+const obj = {
+  foo: 'foo-value',
+  bar: 'bar-value',
+} as {
+  [key in 'foo' | 'bar']: \`\${key}-value\`;
+};
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-        },
-      ],
-      languageOptions: { parserOptions },
-      options: [{ allowNamedExports: false }],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
-export { a };
-const a = 1;
+const obj = {
+  foo: {
+    foo: 'foo',
+  } as {
+    [key in 'foo' | 'bar']: key;
+  },
+};
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-        },
-      ],
-      languageOptions: { parserOptions },
-      options: ['nofunc'],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
-export { a as b };
-const a = 1;
+const foo = {
+  bar: 'bar',
+} satisfies {
+  bar: typeof baz;
+};
+
+const baz = '';
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'noUseBeforeDefine',
-        },
-      ],
-      languageOptions: { parserOptions },
+      options: [{ ignoreTypeReferences: true }],
     },
+  ],
+  invalid: [
     {
       code: `
-export { a, b };
-let a, b;
+a++;
+var a = 19;
       `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
-        },
-        {
-          data: { name: 'b' },
-          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
+      languageOptions: {
+        parserOptions: { sourceType: 'module' },
+      },
     },
     {
       code: `
-export { a };
-var a;
+a++;
+var a = 19;
       `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-export { f };
-function f() {}
+a++;
+var a = 19;
       `,
       errors: [
         {
-          data: { name: 'f' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
     },
     {
       code: `
-export { C };
-class C {}
+a();
+var a = function () {};
       `,
       errors: [
         {
-          data: { name: 'C' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
     },
     {
       code: `
-export const foo = a;
-const a = 1;
+alert(a[1]);
+var a = [1, 3];
       `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export function foo() {
-  return a;
+a();
+function a() {
+  alert(b);
+  var b = 10;
+  a();
 }
-const a = 1;
       `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
-      ],
-      languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
-    },
-    {
-      code: `
-export class C {
-  foo() {
-    return a;
-  }
-}
-const a = 1;
-      `,
-      errors: [
         {
-          data: { name: 'a' },
+          data: { name: 'b' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { Foo };
-
-enum Foo {
-  BAR,
-}
+a();
+var a = function () {};
       `,
       errors: [
         {
-          data: { name: 'Foo' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-      languageOptions: { parserOptions },
+      options: ['nofunc'],
     },
     {
       code: `
-export { Foo };
-
-namespace Foo {
-  export let bar = () => console.log('bar');
-}
+(() => {
+  alert(a);
+  var a = 42;
+})();
       `,
       errors: [
         {
-          data: { name: 'Foo' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-export { Foo, baz };
-
-enum Foo {
-  BAR,
-}
-
-let baz: Enum;
-enum Enum {}
+(() => a())();
+function a() {}
       `,
       errors: [
         {
-          data: { name: 'Foo' },
-          messageId: 'noUseBeforeDefine',
-        },
-        {
-          data: { name: 'baz' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: false, ignoreTypeReferences: true }],
     },
     {
       code: `
-f();
-function f() {}
+a();
+try {
+  throw new Error();
+} catch (foo) {
+  var a;
+}
       `,
       errors: [
         {
-          data: { name: 'f' },
+          data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
     },
     {
       code: `
-alert(a);
-var a = 10;
+var f = () => a;
+var a;
       `,
       errors: [
         {
           data: { name: 'a' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-f()?.();
-function f() {
-  return function t() {};
-}
+new A();
+class A {}
       `,
       errors: [
         {
-          data: { name: 'f' },
+          data: { name: 'A' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-alert(a?.b);
-var a = { b: 5 };
+function foo() {
+  new A();
+}
+class A {}
       `,
       errors: [
         {
-          data: { name: 'a' },
+          data: { name: 'A' },
           messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
         },
       ],
-    },
-  ],
-  valid: [
-    `
-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);
-}
-    `,
-    'Object.hasOwnProperty.call(a);',
-    `
-function a() {
-  alert(arguments);
-}
-    `,
-    'declare function a();',
-    `
-declare class a {
-  foo();
-}
-    `,
-    'const updatedAt = data?.updatedAt;',
-    `
-function f() {
-  return function t() {};
-}
-f()?.();
-    `,
-    `
-var a = { b: 5 };
-alert(a?.b);
-    `,
-    {
-      code: `
-a();
-function a() {
-  alert(arguments);
-}
-      `,
-      options: ['nofunc'],
-    },
-    {
-      code: `
-(() => {
-  var a = 42;
-  alert(a);
-})();
-      `,
       languageOptions: { parserOptions },
     },
-    `
-a();
-try {
-  throw new Error();
-} catch (a) {}
-    `,
     {
       code: `
-class A {}
 new A();
+var A = class {};
       `,
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
-    `
-var a = 0,
-  b = a;
-    `,
-    { code: 'var { a = 0, b = a } = {};', languageOptions: { parserOptions } },
-    { code: 'var [a = 0, b = a] = {};', languageOptions: { parserOptions } },
-    `
-function foo() {
-  foo();
-}
-    `,
-    `
-var foo = function () {
-  foo();
-};
-    `,
-    `
-var a;
-for (a in a) {
-}
-    `,
     {
       code: `
-var a;
-for (a of a) {
+function foo() {
+  new A();
 }
+var A = class {};
       `,
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
 
     // Block-level bindings
     {
       code: `
-'use strict';
-a();
+a++;
 {
-  function a() {}
+  var a;
 }
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
@@ -1068,29 +837,65 @@ a();
   function a() {}
 }
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: `
+{
+  a;
+  let a = 1;
+}
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
-      options: ['nofunc'],
     },
     {
       code: `
 switch (foo) {
-  case 1: {
+  case 1:
     a();
-  }
-  default: {
+  default:
     let a;
-  }
 }
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
     {
       code: `
-a();
-{
-  let a = function () {};
+if (true) {
+  function foo() {
+    a;
+  }
+  let a;
 }
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
     },
 
@@ -1098,62 +903,189 @@ a();
     {
       code: `
 a();
-function a() {
-  alert(arguments);
-}
+var a = function () {};
       `,
-      options: [{ functions: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ classes: false, functions: false }],
     },
     {
       code: `
-'use strict';
-{
-  a();
-  function a() {}
-}
+new A();
+var A = class {};
       `,
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ functions: false }],
+      options: [{ classes: false }],
     },
     {
       code: `
 function foo() {
   new A();
 }
-class A {}
+var A = class {};
       `,
+      errors: [
+        {
+          data: { name: 'A' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
       languageOptions: { parserOptions },
       options: [{ classes: false }],
     },
 
-    // "variables" option
+    // invalid initializers
     {
-      code: `
-function foo() {
-  bar;
-}
-var bar;
-      `,
-      options: [{ variables: false }],
+      code: 'var a = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
+    {
+      code: 'let a = a + b;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'const a = foo(a);',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'function foo(a = a) {}',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { a = a } = [];',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [a = a] = [];',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { b = a, a } = {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [b = a, a] = {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var { a = 0 } = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: 'var [a = 0] = a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
     {
       code: `
-var foo = () => bar;
-var bar;
+for (var a in a) {
+}
       `,
-      languageOptions: { parserOptions },
-      options: [{ variables: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
     },
-
-    // "typedefs" option
     {
       code: `
-var x: Foo = 2;
-type Foo = string | number;
+for (var a of a) {
+}
       `,
-      options: [{ typedefs: false }],
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2572
+
+    // "ignoreTypeReferences" option
     {
       code: `
 interface Bar {
@@ -1162,7 +1094,14 @@ interface Bar {
 
 const Foo = 2;
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
@@ -1174,7 +1113,14 @@ class Foo {
   public static readonly FOO = '';
 }
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
     {
       code: `
@@ -1188,127 +1134,281 @@ const Foo = {
   },
 };
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeReferences: false }],
     },
-    // https://github.com/bradzacher/eslint-plugin-typescript/issues/141
     {
       code: `
-interface ITest {
-  first: boolean;
-  second: string;
-  third: boolean;
-}
-
-let first = () => console.log('first');
+const foo = {
+  bar: 'bar',
+} satisfies {
+  bar: typeof baz;
+};
 
-export let second = () => console.log('second');
+const baz = '';
+      `,
+      errors: [
+        {
+          data: { name: 'baz' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      options: [{ ignoreTypeReferences: false }],
+    },
 
-export namespace Third {
-  export let third = () => console.log('third');
+    // "variables" option
+    {
+      code: `
+function foo() {
+  bar;
+  var bar = 1;
 }
+var bar;
       `,
-      languageOptions: {
-        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      },
+      errors: [
+        {
+          data: { name: 'bar' },
+          messageId: 'noUseBeforeDefine',
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [{ variables: false }],
     },
-    // 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;
-}
-    `,
-    // https://github.com/eslint/typescript-eslint-parser/issues/435
-    `
-interface Foo {
-  bar: string;
-}
-const bar = 'blah';
-    `,
     {
       code: `
-function foo(): Foo {
-  return Foo.FOO;
+class Test {
+  foo(args: Foo): Foo {
+    return Foo.FOO;
+  }
 }
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          line: 4,
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      options: [{ enums: true }],
     },
     {
       code: `
-let foo: Foo;
+function foo(): Foo {
+  return Foo.FOO;
+}
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          line: 3,
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      options: [{ enums: true }],
     },
     {
       code: `
-class Test {
-  foo(args: Foo): Foo {
-    return Foo.FOO;
-  }
-}
+const foo = Foo.Foo;
 
 enum Foo {
   FOO,
 }
       `,
-      options: [{ enums: false }],
+      errors: [
+        {
+          data: { name: 'Foo' },
+          line: 2,
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      options: [{ enums: true }],
     },
-
     // "allowNamedExports" option
     {
       code: `
 export { a };
 const a = 1;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
+    },
+    {
+      code: `
+export { a };
+const a = 1;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [{}],
+    },
+    {
+      code: `
+export { a };
+const a = 1;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: false }],
+    },
+    {
+      code: `
+export { a };
+const a = 1;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+      options: ['nofunc'],
     },
     {
       code: `
 export { a as b };
 const a = 1;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: `
+export { a, b };
+let a, b;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: `
+export { a };
+var a;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
+      languageOptions: { parserOptions },
+    },
+    {
+      code: `
+export { f };
+function f() {}
+      `,
+      errors: [
+        {
+          data: { name: 'f' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { a, b };
-let a, b;
+export { C };
+class C {}
       `,
+      errors: [
+        {
+          data: { name: 'C' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { a };
-var a;
+export const foo = a;
+const a = 1;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { f };
-function f() {}
+export function foo() {
+  return a;
+}
+const a = 1;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [{ allowNamedExports: true }],
     },
     {
       code: `
-export { C };
-class C {}
+export class C {
+  foo() {
+    return a;
+  }
+}
+const a = 1;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
       options: [{ allowNamedExports: true }],
     },
@@ -1320,8 +1420,13 @@ enum Foo {
   BAR,
 }
       `,
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
@@ -1331,8 +1436,13 @@ namespace Foo {
   export let bar = () => console.log('bar');
 }
       `,
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
+        },
+      ],
       languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
     },
     {
       code: `
@@ -1345,178 +1455,68 @@ enum Foo {
 let baz: Enum;
 enum Enum {}
       `,
-      languageOptions: { parserOptions },
-      options: [{ allowNamedExports: true }],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2502
-    {
-      code: `
-import * as React from 'react';
-
-<div />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          sourceType: 'module',
+      errors: [
+        {
+          data: { name: 'Foo' },
+          messageId: 'noUseBeforeDefine',
         },
-      },
-    },
-    {
-      code: `
-import React from 'react';
-
-<div />;
-      `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          sourceType: 'module',
+        {
+          data: { name: 'baz' },
+          messageId: 'noUseBeforeDefine',
         },
-      },
+      ],
+      languageOptions: { parserOptions },
+      options: [{ allowNamedExports: false, ignoreTypeReferences: true }],
     },
     {
       code: `
-import { h } from 'preact';
-
-<div />;
+f();
+function f() {}
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          jsxPragma: 'h',
-          sourceType: 'module',
+      errors: [
+        {
+          data: { name: 'f' },
+          messageId: 'noUseBeforeDefine',
         },
-      },
+      ],
     },
     {
       code: `
-const React = require('react');
-
-<div />;
+alert(a);
+var a = 10;
       `,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'noUseBeforeDefine',
         },
-      },
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2527
-    `
-type T = (value: unknown) => value is Id;
-    `,
-    `
-global.foo = true;
-
-declare global {
-  namespace NodeJS {
-    interface Global {
-      foo?: boolean;
-    }
-  }
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2824
-    `
-@Directive({
-  selector: '[rcCidrIpPattern]',
-  providers: [
-    {
-      provide: NG_VALIDATORS,
-      useExisting: CidrIpPatternDirective,
-      multi: true,
+      ],
     },
-  ],
-})
-export class CidrIpPatternDirective implements Validator {}
-    `,
     {
       code: `
-@Directive({
-  selector: '[rcCidrIpPattern]',
-  providers: [
-    {
-      provide: NG_VALIDATORS,
-      useExisting: CidrIpPatternDirective,
-      multi: true,
-    },
-  ],
-})
-export class CidrIpPatternDirective implements Validator {}
+f()?.();
+function f() {
+  return function t() {};
+}
       `,
-      options: [
+      errors: [
         {
-          classes: false,
+          data: { name: 'f' },
+          messageId: 'noUseBeforeDefine',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/2941
-    `
-class A {
-  constructor(printName) {
-    this.printName = printName;
-  }
-
-  openPort(printerName = this.printerName) {
-    this.tscOcx.ActiveXopenport(printerName);
-
-    return this;
-  }
-}
-    `,
-    {
-      code: `
-const obj = {
-  foo: 'foo-value',
-  bar: 'bar-value',
-} satisfies {
-  [key in 'foo' | 'bar']: \`\${key}-value\`;
-};
-      `,
-      options: [{ ignoreTypeReferences: false }],
-    },
-    {
-      code: `
-const obj = {
-  foo: 'foo-value',
-  bar: 'bar-value',
-} as {
-  [key in 'foo' | 'bar']: \`\${key}-value\`;
-};
-      `,
-      options: [{ ignoreTypeReferences: false }],
-    },
-    {
-      code: `
-const obj = {
-  foo: {
-    foo: 'foo',
-  } as {
-    [key in 'foo' | 'bar']: key;
-  },
-};
-      `,
-      options: [{ ignoreTypeReferences: false }],
-    },
     {
       code: `
-const foo = {
-  bar: 'bar',
-} satisfies {
-  bar: typeof baz;
-};
-
-const baz = '';
+alert(a?.b);
+var a = { b: 5 };
       `,
-      options: [{ ignoreTypeReferences: true }],
+      errors: [
+        {
+          data: { name: 'a' },
+          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 de9a26690bf1..a49055b6c0d9 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
@@ -11,94 +11,6 @@ const error = {
 };
 
 ruleTester.run('no-useless-constructor', rule, {
-  invalid: [
-    {
-      code: `
-class A {
-  constructor() {}
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor() {
-    super();
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(foo) {
-    super(foo);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(foo, bar) {
-    super(foo, bar);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(...args) {
-    super(...args);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B.C {
-  constructor() {
-    super(...arguments);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(a, b, ...c) {
-    super(...arguments);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A extends B {
-  constructor(a, b, ...c) {
-    super(a, b, ...c);
-  }
-}
-      `,
-      errors: [error],
-    },
-    {
-      code: `
-class A {
-  public constructor() {}
-}
-      `,
-      errors: [error],
-    },
-  ],
   valid: [
     'class A {}',
     `
@@ -301,4 +213,92 @@ class A extends Object {
 }
     `,
   ],
+  invalid: [
+    {
+      code: `
+class A {
+  constructor() {}
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor() {
+    super();
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(foo) {
+    super(foo);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(foo, bar) {
+    super(foo, bar);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(...args) {
+    super(...args);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B.C {
+  constructor() {
+    super(...arguments);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(...arguments);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(a, b, ...c);
+  }
+}
+      `,
+      errors: [error],
+    },
+    {
+      code: `
+class A {
+  public constructor() {}
+}
+      `,
+      errors: [error],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts b/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
index 422c01c58185..f0e37327ba6a 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-empty-export.test.ts
@@ -20,6 +20,54 @@ const error = {
 } as const;
 
 ruleTester.run('no-useless-empty-export', rule, {
+  valid: [
+    "declare module '_'",
+    "import {} from '_';",
+    "import * as _ from '_';",
+    'export = {};',
+    'export = 3;',
+    'export const _ = {};',
+    `
+      const _ = {};
+      export default _;
+    `,
+    `
+      export * from '_';
+      export = {};
+    `,
+    `
+      export {};
+    `,
+    // https://github.com/microsoft/TypeScript/issues/38592
+    {
+      code: `
+        export type A = 1;
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        export declare const a = 2;
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        import type { A } from '_';
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+    {
+      code: `
+        import { A } from '_';
+        export {};
+      `,
+      filename: 'foo.d.ts',
+    },
+  ],
   invalid: [
     {
       code: `
@@ -118,52 +166,4 @@ import _ = require('_');
       `,
     },
   ],
-  valid: [
-    "declare module '_'",
-    "import {} from '_';",
-    "import * as _ from '_';",
-    'export = {};',
-    'export = 3;',
-    'export const _ = {};',
-    `
-      const _ = {};
-      export default _;
-    `,
-    `
-      export * from '_';
-      export = {};
-    `,
-    `
-      export {};
-    `,
-    // https://github.com/microsoft/TypeScript/issues/38592
-    {
-      code: `
-        export type A = 1;
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        export declare const a = 2;
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        import type { A } from '_';
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-    {
-      code: `
-        import { A } from '_';
-        export {};
-      `,
-      filename: 'foo.d.ts',
-    },
-  ],
 });
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 741d543ec74c..451771c61a98 100644
--- a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
@@ -5,6 +5,40 @@ import rule from '../../src/rules/no-var-requires';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-var-requires', rule, {
+  valid: [
+    "import foo = require('foo');",
+    "require('foo');",
+    "require?.('foo');",
+    `
+import { createRequire } from 'module';
+const require = createRequire('foo');
+const json = require('./some.json');
+    `,
+    {
+      code: "const pkg = require('./package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('../packages/package.json');",
+      options: [{ allow: ['/package\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('data.json');",
+      options: [{ allow: ['\\.json$'] }],
+    },
+    {
+      code: "const pkg = require('some-package');",
+      options: [{ allow: ['^some-package$'] }],
+    },
+    {
+      code: 'const pkg = require(`some-package`);',
+      options: [{ allow: ['^some-package$'] }],
+    },
+  ],
   invalid: [
     {
       code: "var foo = require('foo');",
@@ -189,38 +223,4 @@ configValidator.addSchema(require('./a.json'));
       options: [{ allow: ['^some-package$'] }],
     },
   ],
-  valid: [
-    "import foo = require('foo');",
-    "require('foo');",
-    "require?.('foo');",
-    `
-import { createRequire } from 'module';
-const require = createRequire('foo');
-const json = require('./some.json');
-    `,
-    {
-      code: "const pkg = require('./package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('../packages/package.json');",
-      options: [{ allow: ['/package\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('data.json');",
-      options: [{ allow: ['\\.json$'] }],
-    },
-    {
-      code: "const pkg = require('some-package');",
-      options: [{ allow: ['^some-package$'] }],
-    },
-    {
-      code: 'const pkg = require(`some-package`);',
-      options: [{ allow: ['^some-package$'] }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts b/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
index 700f415d282a..2229c2b65558 100644
--- a/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-wrapper-object-types.test.ts
@@ -6,6 +6,61 @@ import rule from '../../src/rules/no-wrapper-object-types';
 const ruleTester = new RuleTester();
 
 ruleTester.run('no-wrapper-object-types', rule, {
+  valid: [
+    'let value: NumberLike;',
+    'let value: Other;',
+    'let value: bigint;',
+    'let value: boolean;',
+    'let value: never;',
+    'let value: null;',
+    'let value: number;',
+    'let value: symbol;',
+    'let value: undefined;',
+    'let value: unknown;',
+    'let value: void;',
+    'let value: () => void;',
+    'let value: () => () => void;',
+    'let Bigint;',
+    'let Boolean;',
+    'let Never;',
+    'let Null;',
+    'let Number;',
+    'let Symbol;',
+    'let Undefined;',
+    'let Unknown;',
+    'let Void;',
+    'interface Bigint {}',
+    'interface Boolean {}',
+    'interface Never {}',
+    'interface Null {}',
+    'interface Number {}',
+    'interface Symbol {}',
+    'interface Undefined {}',
+    'interface Unknown {}',
+    'interface Void {}',
+    'type Bigint = {};',
+    'type Boolean = {};',
+    'type Never = {};',
+    'type Null = {};',
+    'type Number = {};',
+    'type Symbol = {};',
+    'type Undefined = {};',
+    'type Unknown = {};',
+    'type Void = {};',
+    'class MyClass extends Number {}',
+    `
+      type Number = 0 | 1;
+      let value: Number;
+    `,
+    `
+      type Bigint = 0 | 1;
+      let value: Bigint;
+    `,
+    `
+      type T<Symbol> = Symbol;
+      type U<UU> = UU extends T<infer Function> ? Function : never;
+    `,
+  ],
   invalid: [
     {
       code: 'let value: BigInt;',
@@ -182,59 +237,4 @@ ruleTester.run('no-wrapper-object-types', rule, {
       output: 'type MyType = number & string;',
     },
   ],
-  valid: [
-    'let value: NumberLike;',
-    'let value: Other;',
-    'let value: bigint;',
-    'let value: boolean;',
-    'let value: never;',
-    'let value: null;',
-    'let value: number;',
-    'let value: symbol;',
-    'let value: undefined;',
-    'let value: unknown;',
-    'let value: void;',
-    'let value: () => void;',
-    'let value: () => () => void;',
-    'let Bigint;',
-    'let Boolean;',
-    'let Never;',
-    'let Null;',
-    'let Number;',
-    'let Symbol;',
-    'let Undefined;',
-    'let Unknown;',
-    'let Void;',
-    'interface Bigint {}',
-    'interface Boolean {}',
-    'interface Never {}',
-    'interface Null {}',
-    'interface Number {}',
-    'interface Symbol {}',
-    'interface Undefined {}',
-    'interface Unknown {}',
-    'interface Void {}',
-    'type Bigint = {};',
-    'type Boolean = {};',
-    'type Never = {};',
-    'type Null = {};',
-    'type Number = {};',
-    'type Symbol = {};',
-    'type Undefined = {};',
-    'type Unknown = {};',
-    'type Void = {};',
-    'class MyClass extends Number {}',
-    `
-      type Number = 0 | 1;
-      let value: Number;
-    `,
-    `
-      type Bigint = 0 | 1;
-      let value: Bigint;
-    `,
-    `
-      type T<Symbol> = Symbol;
-      type U<UU> = UU extends T<infer Function> ? Function : never;
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts b/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
index 900421f7a6d1..2ecc5cb73f11 100644
--- a/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/non-nullable-type-assertion-style.test.ts
@@ -13,6 +13,55 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('non-nullable-type-assertion-style', rule, {
+  valid: [
+    `
+declare const original: number | string;
+const cast = original as string;
+    `,
+    `
+declare const original: number | undefined;
+const cast = original as string | number | undefined;
+    `,
+    `
+declare const original: number | any;
+const cast = original as string | number | undefined;
+    `,
+    `
+declare const original: number | undefined;
+const cast = original as any;
+    `,
+    `
+declare const original: number | null | undefined;
+const cast = original as number | null;
+    `,
+    `
+type Type = { value: string };
+declare const original: Type | number;
+const cast = original as Type;
+    `,
+    `
+type T = string;
+declare const x: T | number;
+
+const y = x as NonNullable<T>;
+    `,
+    `
+type T = string | null;
+declare const x: T | number;
+
+const y = x as NonNullable<T>;
+    `,
+    `
+const foo = [] as const;
+    `,
+    `
+const x = 1 as 1;
+    `,
+    `
+declare function foo<T = any>(): T;
+const bar = foo() as number;
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -192,56 +241,6 @@ const b = (a || undefined)!;
       `,
     },
   ],
-
-  valid: [
-    `
-declare const original: number | string;
-const cast = original as string;
-    `,
-    `
-declare const original: number | undefined;
-const cast = original as string | number | undefined;
-    `,
-    `
-declare const original: number | any;
-const cast = original as string | number | undefined;
-    `,
-    `
-declare const original: number | undefined;
-const cast = original as any;
-    `,
-    `
-declare const original: number | null | undefined;
-const cast = original as number | null;
-    `,
-    `
-type Type = { value: string };
-declare const original: Type | number;
-const cast = original as Type;
-    `,
-    `
-type T = string;
-declare const x: T | number;
-
-const y = x as NonNullable<T>;
-    `,
-    `
-type T = string | null;
-declare const x: T | number;
-
-const y = x as NonNullable<T>;
-    `,
-    `
-const foo = [] as const;
-    `,
-    `
-const x = 1 as 1;
-    `,
-    `
-declare function foo<T = any>(): T;
-const bar = foo() as number;
-    `,
-  ],
 });
 
 const ruleTesterWithNoUncheckedIndexAccess = new RuleTester({
@@ -259,27 +258,6 @@ ruleTesterWithNoUncheckedIndexAccess.run(
   'non-nullable-type-assertion-style - noUncheckedIndexedAccess',
   rule,
   {
-    invalid: [
-      {
-        code: `
-function first<T extends string | number>(array: ArrayLike<T>): T | null {
-  return array.length > 0 ? (array[0] as T) : null;
-}
-        `,
-        errors: [
-          {
-            column: 30,
-            line: 3,
-            messageId: 'preferNonNullAssertion',
-          },
-        ],
-        output: `
-function first<T extends string | number>(array: ArrayLike<T>): T | null {
-  return array.length > 0 ? (array[0]!) : null;
-}
-        `,
-      },
-    ],
     valid: [
       `
 function first<T>(array: ArrayLike<T>): T | null {
@@ -311,5 +289,26 @@ function first<T extends A | B | null>(array: ArrayLike<T>): T | null {
 }
       `,
     ],
+    invalid: [
+      {
+        code: `
+function first<T extends string | number>(array: ArrayLike<T>): T | null {
+  return array.length > 0 ? (array[0] as T) : null;
+}
+        `,
+        errors: [
+          {
+            column: 30,
+            line: 3,
+            messageId: 'preferNonNullAssertion',
+          },
+        ],
+        output: `
+function first<T extends string | number>(array: ArrayLike<T>): T | null {
+  return array.length > 0 ? (array[0]!) : null;
+}
+        `,
+      },
+    ],
   },
 );
diff --git a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
index 5c63874ff9a7..b8209943597a 100644
--- a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
+++ b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
@@ -13,6 +13,128 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('only-throw-error', rule, {
+  valid: [
+    'throw new Error();',
+    "throw new Error('error');",
+    "throw Error('error');",
+    `
+const e = new Error();
+throw e;
+    `,
+    `
+try {
+  throw new Error();
+} catch (e) {
+  throw e;
+}
+    `,
+    `
+function foo() {
+  return new Error();
+}
+throw foo();
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+throw foo.bar;
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+
+throw foo['bar'];
+    `,
+    `
+const foo = {
+  bar: new Error(),
+};
+
+const bar = 'bar';
+throw foo[bar];
+    `,
+    `
+class CustomError extends Error {}
+throw new CustomError();
+    `,
+    `
+class CustomError1 extends Error {}
+class CustomError2 extends CustomError1 {}
+throw new CustomError2();
+    `,
+    'throw (foo = new Error());',
+    'throw (1, 2, new Error());',
+    "throw 'literal' && new Error();",
+    "throw new Error() || 'literal';",
+    'throw foo ? new Error() : new Error();',
+    `
+function* foo() {
+  let index = 0;
+  throw yield index++;
+}
+    `,
+    `
+async function foo() {
+  throw await bar;
+}
+    `,
+    `
+import { Error } from './missing';
+throw Error;
+    `,
+    `
+class CustomError<T, C> extends Error {}
+throw new CustomError<string, string>();
+    `,
+    `
+class CustomError<T = {}> extends Error {}
+throw new CustomError();
+    `,
+    `
+class CustomError<T extends object> extends Error {}
+throw new CustomError();
+    `,
+    `
+function foo() {
+  throw Object.assign(new Error('message'), { foo: 'bar' });
+}
+    `,
+    `
+const foo: Error | SyntaxError = bar();
+function bar() {
+  throw foo;
+}
+    `,
+    `
+declare const foo: Error | string;
+throw foo as Error;
+    `,
+    'throw new Error() as Error;',
+    `
+declare const nullishError: Error | undefined;
+throw nullishError ?? new Error();
+    `,
+    `
+declare const nullishError: Error | undefined;
+throw nullishError || new Error();
+    `,
+    `
+declare const nullishError: Error | undefined;
+throw nullishError ? nullishError : new Error();
+    `,
+    `
+function fun(value: any) {
+  throw value;
+}
+    `,
+    `
+function fun(value: unknown) {
+  throw value;
+}
+    `,
+  ],
   invalid: [
     {
       code: 'throw undefined;',
@@ -347,126 +469,4 @@ function fun(value: unknown) {
       ],
     },
   ],
-  valid: [
-    'throw new Error();',
-    "throw new Error('error');",
-    "throw Error('error');",
-    `
-const e = new Error();
-throw e;
-    `,
-    `
-try {
-  throw new Error();
-} catch (e) {
-  throw e;
-}
-    `,
-    `
-function foo() {
-  return new Error();
-}
-throw foo();
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-throw foo.bar;
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-
-throw foo['bar'];
-    `,
-    `
-const foo = {
-  bar: new Error(),
-};
-
-const bar = 'bar';
-throw foo[bar];
-    `,
-    `
-class CustomError extends Error {}
-throw new CustomError();
-    `,
-    `
-class CustomError1 extends Error {}
-class CustomError2 extends CustomError1 {}
-throw new CustomError2();
-    `,
-    'throw (foo = new Error());',
-    'throw (1, 2, new Error());',
-    "throw 'literal' && new Error();",
-    "throw new Error() || 'literal';",
-    'throw foo ? new Error() : new Error();',
-    `
-function* foo() {
-  let index = 0;
-  throw yield index++;
-}
-    `,
-    `
-async function foo() {
-  throw await bar;
-}
-    `,
-    `
-import { Error } from './missing';
-throw Error;
-    `,
-    `
-class CustomError<T, C> extends Error {}
-throw new CustomError<string, string>();
-    `,
-    `
-class CustomError<T = {}> extends Error {}
-throw new CustomError();
-    `,
-    `
-class CustomError<T extends object> extends Error {}
-throw new CustomError();
-    `,
-    `
-function foo() {
-  throw Object.assign(new Error('message'), { foo: 'bar' });
-}
-    `,
-    `
-const foo: Error | SyntaxError = bar();
-function bar() {
-  throw foo;
-}
-    `,
-    `
-declare const foo: Error | string;
-throw foo as Error;
-    `,
-    'throw new Error() as Error;',
-    `
-declare const nullishError: Error | undefined;
-throw nullishError ?? new Error();
-    `,
-    `
-declare const nullishError: Error | undefined;
-throw nullishError || new Error();
-    `,
-    `
-declare const nullishError: Error | undefined;
-throw nullishError ? nullishError : new Error();
-    `,
-    `
-function fun(value: any) {
-  throw value;
-}
-    `,
-    `
-function fun(value: unknown) {
-  throw value;
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
index 74ab71267250..36a14677339e 100644
--- a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
+++ b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
@@ -5,23 +5,43 @@ import rule from '../../src/rules/parameter-properties';
 const ruleTester = new RuleTester();
 
 ruleTester.run('parameter-properties', rule, {
-  invalid: [
+  valid: [
+    `
+class Foo {
+  constructor(name: string) {}
+}
+    `,
+    {
+      code: `
+class Foo {
+  constructor(name: string) {}
+}
+      `,
+      options: [{ prefer: 'class-property' }],
+    },
+    `
+class Foo {
+  constructor(...name: string[]) {}
+}
+    `,
+    `
+class Foo {
+  constructor(name: string, age: number) {}
+}
+    `,
+    `
+class Foo {
+  constructor(name: string) {}
+  constructor(name: string, age?: number) {}
+}
+    `,
     {
       code: `
 class Foo {
   constructor(readonly name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['readonly'] }],
     },
     {
       code: `
@@ -29,16 +49,7 @@ class Foo {
   constructor(private name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
@@ -46,16 +57,7 @@ class Foo {
   constructor(protected name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['protected'] }],
     },
     {
       code: `
@@ -63,16 +65,7 @@ class Foo {
   constructor(public name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['public'] }],
     },
     {
       code: `
@@ -80,16 +73,7 @@ class Foo {
   constructor(private readonly name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['private readonly'] }],
     },
     {
       code: `
@@ -97,16 +81,7 @@ class Foo {
   constructor(protected readonly name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['protected readonly'] }],
     },
     {
       code: `
@@ -114,183 +89,247 @@ class Foo {
   constructor(public readonly name: string) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['public readonly'] }],
     },
     {
       code: `
 class Foo {
   constructor(
-    public name: string,
-    age: number,
+    readonly name: string,
+    private age: number,
   ) {}
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 4,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
   constructor(
-    private name: string,
+    public readonly name: string,
     private age: number,
   ) {}
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 4,
-          messageId: 'preferClassProperty',
-        },
-        {
-          column: 5,
-          data: {
-            parameter: 'age',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ allow: ['public readonly', 'private'] }],
     },
+    // Semantically invalid test case
+    `
+class Foo {
+  constructor(private ...name: string[]) {}
+}
+    `,
+    // Semantically invalid test case
+    `
+class Foo {
+  constructor(private [test]: [string]) {}
+}
+    `,
     {
       code: `
 class Foo {
-  constructor(
-    protected name: string,
-    protected age: number,
-  ) {}
+  constructor(private name: string[]) {}
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 4,
-          messageId: 'preferClassProperty',
-        },
-        {
-          column: 5,
-          data: {
-            parameter: 'age',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(
-    public name: string,
-    public age: number,
-  ) {}
+  constructor(...name: string[]) {}
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 4,
-          messageId: 'preferClassProperty',
-        },
-        {
-          column: 5,
-          data: {
-            parameter: 'age',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(name: string) {}
-  constructor(
-    private name: string,
-    age?: number,
-  ) {}
+  constructor(age: string, ...name: string[]) {}
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
   constructor(
-    private name: string,
-    age?: number,
+    private age: string,
+    ...name: string[]
   ) {}
 }
       `,
-      errors: [
-        {
-          column: 15,
-          data: {
-            parameter: 'name',
-          },
-          line: 3,
-          messageId: 'preferClassProperty',
-        },
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-      ],
+      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
-  constructor(
-    private name: string,
-    private age?: number,
-  ) {}
+  public age: number;
+  constructor(age: string) {
+    this.age = age;
+  }
 }
       `,
-      errors: [
-        {
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age = '';
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: string;
+  constructor(age) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: string;
+  constructor(age: string) {
+    console.log('unrelated');
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  other: string;
+  constructor(age: string) {
+    this.other = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  age: string;
+  constructor(age: string) {
+    this.age = '';
+    console.log(age);
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  age() {
+    return '';
+  }
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['public'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  public readonly age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['public readonly'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  protected age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['protected'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  protected readonly age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [
+        { allow: ['protected readonly'], prefer: 'parameter-property' },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  private age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['private'], prefer: 'parameter-property' }],
+    },
+    {
+      code: `
+class Foo {
+  private readonly age: string;
+  constructor(age: string) {
+    this.age = age;
+  }
+}
+      `,
+      options: [{ allow: ['private readonly'], prefer: 'parameter-property' }],
+    },
+  ],
+  invalid: [
+    {
+      code: `
+class Foo {
+  constructor(readonly name: string) {}
+}
+      `,
+      errors: [
+        {
           column: 15,
           data: {
             parameter: 'name',
@@ -298,41 +337,21 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
-        {
-          column: 5,
-          data: {
-            parameter: 'name',
-          },
-          line: 5,
-          messageId: 'preferClassProperty',
-        },
-        {
-          column: 5,
-          data: {
-            parameter: 'age',
-          },
-          line: 6,
-          messageId: 'preferClassProperty',
-        },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(name: string) {}
-  constructor(
-    protected name: string,
-    age?: number,
-  ) {}
+  constructor(private name: string) {}
 }
       `,
       errors: [
         {
-          column: 5,
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 5,
+          line: 3,
           messageId: 'preferClassProperty',
         },
       ],
@@ -341,10 +360,6 @@ class Foo {
       code: `
 class Foo {
   constructor(protected name: string) {}
-  constructor(
-    protected name: string,
-    age?: number,
-  ) {}
 }
       `,
       errors: [
@@ -356,12 +371,21 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  constructor(public name: string) {}
+}
+      `,
+      errors: [
         {
-          column: 5,
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 5,
+          line: 3,
           messageId: 'preferClassProperty',
         },
       ],
@@ -369,11 +393,7 @@ class Foo {
     {
       code: `
 class Foo {
-  constructor(protected name: string) {}
-  constructor(
-    protected name: string,
-    protected age?: number,
-  ) {}
+  constructor(private readonly name: string) {}
 }
       `,
       errors: [
@@ -385,20 +405,38 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  constructor(protected readonly name: string) {}
+}
+      `,
+      errors: [
         {
-          column: 5,
+          column: 15,
           data: {
             parameter: 'name',
           },
-          line: 5,
+          line: 3,
           messageId: 'preferClassProperty',
         },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  constructor(public readonly name: string) {}
+}
+      `,
+      errors: [
         {
-          column: 5,
+          column: 15,
           data: {
-            parameter: 'age',
+            parameter: 'name',
           },
-          line: 6,
+          line: 3,
           messageId: 'preferClassProperty',
         },
       ],
@@ -406,10 +444,9 @@ class Foo {
     {
       code: `
 class Foo {
-  constructor(name: string) {}
   constructor(
     public name: string,
-    age?: number,
+    age: number,
   ) {}
 }
       `,
@@ -419,7 +456,7 @@ class Foo {
           data: {
             parameter: 'name',
           },
-          line: 5,
+          line: 4,
           messageId: 'preferClassProperty',
         },
       ],
@@ -427,26 +464,25 @@ class Foo {
     {
       code: `
 class Foo {
-  constructor(public name: string) {}
   constructor(
-    public name: string,
-    age?: number,
+    private name: string,
+    private age: number,
   ) {}
 }
       `,
       errors: [
         {
-          column: 15,
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
+          line: 4,
           messageId: 'preferClassProperty',
         },
         {
           column: 5,
           data: {
-            parameter: 'name',
+            parameter: 'age',
           },
           line: 5,
           messageId: 'preferClassProperty',
@@ -456,63 +492,88 @@ class Foo {
     {
       code: `
 class Foo {
-  constructor(public name: string) {}
   constructor(
-    public name: string,
-    public age?: number,
+    protected name: string,
+    protected age: number,
   ) {}
 }
       `,
       errors: [
         {
-          column: 15,
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
+          line: 4,
           messageId: 'preferClassProperty',
         },
         {
           column: 5,
           data: {
-            parameter: 'name',
+            parameter: 'age',
           },
           line: 5,
           messageId: 'preferClassProperty',
         },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  constructor(
+    public name: string,
+    public age: number,
+  ) {}
+}
+      `,
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 4,
+          messageId: 'preferClassProperty',
+        },
         {
           column: 5,
           data: {
             parameter: 'age',
           },
-          line: 6,
+          line: 5,
           messageId: 'preferClassProperty',
         },
       ],
     },
-
     {
       code: `
 class Foo {
-  constructor(readonly name: string) {}
+  constructor(name: string) {}
+  constructor(
+    private name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          column: 15,
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
+          line: 5,
           messageId: 'preferClassProperty',
         },
       ],
-      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
   constructor(private name: string) {}
+  constructor(
+    private name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
@@ -524,13 +585,24 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
       ],
-      options: [{ allow: ['readonly'] }],
     },
     {
       code: `
 class Foo {
-  constructor(protected name: string) {}
+  constructor(private name: string) {}
+  constructor(
+    private name: string,
+    private age?: number,
+  ) {}
 }
       `,
       errors: [
@@ -542,45 +614,53 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
-      ],
-      options: [
         {
-          allow: ['readonly', 'private', 'public', 'protected readonly'],
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(public name: string) {}
+  constructor(name: string) {}
+  constructor(
+    protected name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          column: 15,
+          column: 5,
           data: {
             parameter: 'name',
           },
-          line: 3,
+          line: 5,
           messageId: 'preferClassProperty',
         },
       ],
-      options: [
-        {
-          allow: [
-            'readonly',
-            'private',
-            'protected',
-            'protected readonly',
-            'public readonly',
-          ],
-        },
-      ],
     },
     {
       code: `
 class Foo {
-  constructor(private readonly name: string) {}
+  constructor(protected name: string) {}
+  constructor(
+    protected name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
@@ -592,13 +672,24 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
       ],
-      options: [{ allow: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
-  constructor(protected readonly name: string) {}
+  constructor(protected name: string) {}
+  constructor(
+    protected name: string,
+    protected age?: number,
+  ) {}
 }
       `,
       errors: [
@@ -610,25 +701,31 @@ class Foo {
           line: 3,
           messageId: 'preferClassProperty',
         },
-      ],
-      options: [
         {
-          allow: [
-            'readonly',
-            'protected',
-            'private readonly',
-            'public readonly',
-          ],
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
     },
     {
       code: `
 class Foo {
-  constructor(private name: string) {}
+  constructor(name: string) {}
   constructor(
-    private name: string,
-    protected age?: number,
+    public name: string,
+    age?: number,
   ) {}
 }
       `,
@@ -636,159 +733,137 @@ class Foo {
         {
           column: 5,
           data: {
-            parameter: 'age',
+            parameter: 'name',
           },
-          line: 6,
+          line: 5,
           messageId: 'preferClassProperty',
         },
       ],
-      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
-  member: string;
-
-  constructor(member: string) {
-    this.member = member;
-  }
+  constructor(public name: string) {}
+  constructor(
+    public name: string,
+    age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          column: 3,
+          column: 15,
           data: {
-            parameter: 'member',
+            parameter: 'name',
           },
           line: 3,
-          messageId: 'preferParameterProperty',
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
         },
       ],
-      options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  constructor(member: string) {
-    this.member = member;
-  }
-
-  member: string;
+  constructor(public name: string) {}
+  constructor(
+    public name: string,
+    public age?: number,
+  ) {}
 }
       `,
       errors: [
         {
-          column: 3,
+          column: 15,
           data: {
-            parameter: 'member',
+            parameter: 'name',
           },
-          line: 7,
-          messageId: 'preferParameterProperty',
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'name',
+          },
+          line: 5,
+          messageId: 'preferClassProperty',
+        },
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
         },
       ],
-      options: [{ prefer: 'parameter-property' }],
     },
+
     {
       code: `
 class Foo {
-  member;
-  constructor(member) {
-    this.member = member;
-  }
+  constructor(readonly name: string) {}
 }
       `,
       errors: [
         {
-          column: 3,
+          column: 15,
           data: {
-            parameter: 'member',
+            parameter: 'name',
           },
           line: 3,
-          messageId: 'preferParameterProperty',
+          messageId: 'preferClassProperty',
         },
       ],
-      options: [{ prefer: 'parameter-property' }],
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
-  public member: string;
-  constructor(member: string) {
-    this.member = member;
-  }
+  constructor(private name: string) {}
 }
       `,
       errors: [
         {
-          column: 3,
+          column: 15,
           data: {
-            parameter: 'member',
+            parameter: 'name',
           },
           line: 3,
-          messageId: 'preferParameterProperty',
-        },
-      ],
-      options: [
-        {
-          allow: ['protected', 'private', 'readonly'],
-          prefer: 'parameter-property',
+          messageId: 'preferClassProperty',
         },
       ],
+      options: [{ allow: ['readonly'] }],
     },
-  ],
-  valid: [
-    `
-class Foo {
-  constructor(name: string) {}
-}
-    `,
     {
       code: `
 class Foo {
-  constructor(name: string) {}
+  constructor(protected name: string) {}
 }
       `,
-      options: [{ prefer: 'class-property' }],
-    },
-    `
-class Foo {
-  constructor(...name: string[]) {}
-}
-    `,
-    `
-class Foo {
-  constructor(name: string, age: number) {}
-}
-    `,
-    `
-class Foo {
-  constructor(name: string) {}
-  constructor(name: string, age?: number) {}
-}
-    `,
-    {
-      code: `
-class Foo {
-  constructor(readonly name: string) {}
-}
-      `,
-      options: [{ allow: ['readonly'] }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(private name: string) {}
-}
-      `,
-      options: [{ allow: ['private'] }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(protected name: string) {}
-}
-      `,
-      options: [{ allow: ['protected'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
+      options: [
+        {
+          allow: ['readonly', 'private', 'public', 'protected readonly'],
+        },
+      ],
     },
     {
       code: `
@@ -796,7 +871,27 @@ class Foo {
   constructor(public name: string) {}
 }
       `,
-      options: [{ allow: ['public'] }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
+      options: [
+        {
+          allow: [
+            'readonly',
+            'private',
+            'protected',
+            'protected readonly',
+            'public readonly',
+          ],
+        },
+      ],
     },
     {
       code: `
@@ -804,252 +899,157 @@ class Foo {
   constructor(private readonly name: string) {}
 }
       `,
-      options: [{ allow: ['private readonly'] }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(protected readonly name: string) {}
-}
-      `,
-      options: [{ allow: ['protected readonly'] }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(public readonly name: string) {}
-}
-      `,
-      options: [{ allow: ['public readonly'] }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(
-    readonly name: string,
-    private age: number,
-  ) {}
-}
-      `,
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
       options: [{ allow: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
-  constructor(
-    public readonly name: string,
-    private age: number,
-  ) {}
-}
-      `,
-      options: [{ allow: ['public readonly', 'private'] }],
-    },
-    // Semantically invalid test case
-    `
-class Foo {
-  constructor(private ...name: string[]) {}
-}
-    `,
-    // Semantically invalid test case
-    `
-class Foo {
-  constructor(private [test]: [string]) {}
-}
-    `,
-    {
-      code: `
-class Foo {
-  constructor(private name: string[]) {}
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(...name: string[]) {}
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  constructor(age: string, ...name: string[]) {}
+  constructor(protected readonly name: string) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 15,
+          data: {
+            parameter: 'name',
+          },
+          line: 3,
+          messageId: 'preferClassProperty',
+        },
+      ],
+      options: [
+        {
+          allow: [
+            'readonly',
+            'protected',
+            'private readonly',
+            'public readonly',
+          ],
+        },
+      ],
     },
     {
       code: `
 class Foo {
+  constructor(private name: string) {}
   constructor(
-    private age: string,
-    ...name: string[]
+    private name: string,
+    protected age?: number,
   ) {}
 }
       `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: number;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age = '';
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: string;
-  constructor(age) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public age: string;
-  constructor(age: string) {
-    console.log('unrelated');
-    this.age = age;
-  }
-}
-      `,
-      options: [{ prefer: 'parameter-property' }],
+      errors: [
+        {
+          column: 5,
+          data: {
+            parameter: 'age',
+          },
+          line: 6,
+          messageId: 'preferClassProperty',
+        },
+      ],
+      options: [{ allow: ['private'] }],
     },
     {
       code: `
 class Foo {
-  other: string;
-  constructor(age: string) {
-    this.other = age;
+  member: string;
+
+  constructor(member: string) {
+    this.member = member;
   }
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            parameter: 'member',
+          },
+          line: 3,
+          messageId: 'preferParameterProperty',
+        },
+      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  age: string;
-  constructor(age: string) {
-    this.age = '';
-    console.log(age);
+  constructor(member: string) {
+    this.member = member;
   }
+
+  member: string;
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            parameter: 'member',
+          },
+          line: 7,
+          messageId: 'preferParameterProperty',
+        },
+      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  age() {
-    return '';
-  }
-  constructor(age: string) {
-    this.age = age;
+  member;
+  constructor(member) {
+    this.member = member;
   }
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            parameter: 'member',
+          },
+          line: 3,
+          messageId: 'preferParameterProperty',
+        },
+      ],
       options: [{ prefer: 'parameter-property' }],
     },
     {
       code: `
 class Foo {
-  public age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['public'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  public readonly age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['public readonly'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  protected age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['protected'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  protected readonly age: string;
-  constructor(age: string) {
-    this.age = age;
+  public member: string;
+  constructor(member: string) {
+    this.member = member;
   }
 }
       `,
+      errors: [
+        {
+          column: 3,
+          data: {
+            parameter: 'member',
+          },
+          line: 3,
+          messageId: 'preferParameterProperty',
+        },
+      ],
       options: [
-        { allow: ['protected readonly'], prefer: 'parameter-property' },
+        {
+          allow: ['protected', 'private', 'readonly'],
+          prefer: 'parameter-property',
+        },
       ],
     },
-    {
-      code: `
-class Foo {
-  private age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['private'], prefer: 'parameter-property' }],
-    },
-    {
-      code: `
-class Foo {
-  private readonly age: string;
-  constructor(age: string) {
-    this.age = age;
-  }
-}
-      `,
-      options: [{ allow: ['private readonly'], prefer: 'parameter-property' }],
-    },
   ],
 });
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 e2edb2fe0349..398102d6649b 100644
--- a/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
@@ -5,6 +5,89 @@ import rule from '../../src/rules/prefer-as-const';
 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 = <bar>'bar';",
+    "let foo = <string>'bar';",
+    "let foo = 'bar' as string;",
+    'let foo = `bar` as `bar`;',
+    'let foo = `bar` as `foo`;',
+    "let foo = `bar` as 'bar';",
+    "let foo: string = 'bar';",
+    'let foo: number = 1;',
+    "let foo: 'bar' = baz;",
+    "let foo = 'bar';",
+    "let foo: 'bar';",
+    'let foo = { bar };',
+    "let foo: 'baz' = 'baz' as const;",
+    `
+      class foo {
+        bar = 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar;
+      }
+    `,
+    `
+      class foo {
+        bar = <baz>'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: string = 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar: number = 1;
+      }
+    `,
+    `
+      class foo {
+        bar = 'baz' as const;
+      }
+    `,
+    `
+      class foo {
+        bar = 2 as const;
+      }
+    `,
+    `
+      class foo {
+        get bar(): 'bar' {}
+        set bar(bar: 'bar') {}
+      }
+    `,
+    `
+      class foo {
+        bar = () => 'bar' as const;
+      }
+    `,
+    `
+      type BazFunction = () => 'baz';
+      class foo {
+        bar: BazFunction = () => 'bar';
+      }
+    `,
+    `
+      class foo {
+        bar(): void {}
+      }
+    `,
+  ],
   invalid: [
     {
       code: "let foo = { bar: 'baz' as 'baz' };",
@@ -242,87 +325,4 @@ class foo {
       `,
     },
   ],
-  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 = <bar>'bar';",
-    "let foo = <string>'bar';",
-    "let foo = 'bar' as string;",
-    'let foo = `bar` as `bar`;',
-    'let foo = `bar` as `foo`;',
-    "let foo = `bar` as 'bar';",
-    "let foo: string = 'bar';",
-    'let foo: number = 1;',
-    "let foo: 'bar' = baz;",
-    "let foo = 'bar';",
-    "let foo: 'bar';",
-    'let foo = { bar };',
-    "let foo: 'baz' = 'baz' as const;",
-    `
-      class foo {
-        bar = 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar;
-      }
-    `,
-    `
-      class foo {
-        bar = <baz>'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: string = 'baz';
-      }
-    `,
-    `
-      class foo {
-        bar: number = 1;
-      }
-    `,
-    `
-      class foo {
-        bar = 'baz' as const;
-      }
-    `,
-    `
-      class foo {
-        bar = 2 as const;
-      }
-    `,
-    `
-      class foo {
-        get bar(): 'bar' {}
-        set bar(bar: 'bar') {}
-      }
-    `,
-    `
-      class foo {
-        bar = () => 'bar' as const;
-      }
-    `,
-    `
-      type BazFunction = () => 'baz';
-      class foo {
-        bar: BazFunction = () => 'bar';
-      }
-    `,
-    `
-      class foo {
-        bar(): void {}
-      }
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
index 5c90b135fd24..452990eadbcd 100644
--- a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
@@ -16,358 +16,271 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-destructuring', rule, {
-  invalid: [
+  valid: [
+    // type annotated
+    `
+      declare const object: { foo: string };
+      var foo: string = object.foo;
+    `,
+    `
+      declare const array: number[];
+      const bar: number = array[0];
+    `,
     // enforceForDeclarationWithTypeAnnotation: true
     {
-      code: 'var foo: string = object.foo;',
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
+      code: `
+        declare const object: { foo: string };
+        var { foo } = object;
+      `,
       options: [
         { object: true },
         { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
     {
-      code: 'var foo: string = array[0];',
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      code: `
+        declare const object: { foo: string };
+        var { foo }: { foo: number } = object;
+      `,
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
+    },
+    {
+      code: `
+        declare const array: number[];
+        var [foo] = array;
+      `,
       options: [
         { array: true },
         { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
     {
-      code: 'var foo: unknown = object.bar;',
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
+      code: `
+        declare const array: number[];
+        var [foo]: [foo: number] = array;
+      `,
       options: [
         { object: true },
-        {
-          enforceForDeclarationWithTypeAnnotation: true,
-          enforceForRenamedProperties: true,
-        },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
-
-    // numeric property for iterable / non-iterable
     {
       code: `
-        let x: { [Symbol.iterator]: unknown };
-        let y = x[0];
+        declare const object: { bar: string };
+        var foo: unknown = object.bar;
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: { [Symbol.iterator]: unknown };
-        y = x[0];
+        declare const object: { foo: string };
+        var { foo: bar } = object;
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: [1, 2, 3];
-        let y = x[0];
+        declare const object: { foo: boolean };
+        var { foo: bar }: { foo: boolean } = object;
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: [1, 2, 3];
-        y = x[0];
+        declare class Foo {
+          foo: string;
+        }
+
+        class Bar extends Foo {
+          static foo() {
+            var foo: any = super.foo;
+          }
+        }
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: null,
     },
+
+    // numeric property for iterable / non-iterable
+    `
+      let x: { 0: unknown };
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown };
+      y = x[0];
+    `,
+    `
+      let x: unknown;
+      let y = x[0];
+    `,
+    `
+      let x: unknown;
+      y = x[0];
+    `,
+    `
+      let x: { 0: unknown } | unknown[];
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown } | unknown[];
+      y = x[0];
+    `,
+    `
+      let x: { 0: unknown } & (() => void);
+      let y = x[0];
+    `,
+    `
+      let x: { 0: unknown } & (() => void);
+      y = x[0];
+    `,
+    `
+      let x: Record<number, unknown>;
+      let y = x[0];
+    `,
+    `
+      let x: Record<number, unknown>;
+      y = x[0];
+    `,
     {
       code: `
-        function* it() {
-          yield 1;
-        }
-        let y = it()[0];
+        let x: { 0: unknown };
+        let { 0: y } = x;
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        function* it() {
-          yield 1;
-        }
-        y = it()[0];
+        let x: { 0: unknown };
+        ({ 0: y } = x);
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: any;
+        let x: { 0: unknown };
         let y = x[0];
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      output: null,
+      options: [{ array: true }, { enforceForRenamedProperties: true }],
     },
     {
       code: `
-        let x: any;
+        let x: { 0: unknown };
         y = x[0];
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
-      output: null,
+      options: [{ array: true }, { enforceForRenamedProperties: true }],
     },
     {
       code: `
-        let x: string[] | { [Symbol.iterator]: unknown };
+        let x: { 0: unknown };
         let y = x[0];
       `,
-      errors: [
+      options: [
         {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
+          AssignmentExpression: { array: true, object: true },
+          VariableDeclarator: { array: true, object: false },
         },
+        { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: string[] | { [Symbol.iterator]: unknown };
+        let x: { 0: unknown };
         y = x[0];
       `,
-      errors: [
+      options: [
         {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
+          AssignmentExpression: { array: true, object: false },
+          VariableDeclarator: { array: true, object: true },
         },
+        { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: object & unknown[];
-        let y = x[0];
+        let x: Record<number, unknown>;
+        let i: number = 0;
+        y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      output: null,
-    },
-    {
-      code: `
-        let x: object & unknown[];
-        y = x[0];
-      `,
-      errors: [
-        {
-          data: { type: 'array' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
-      output: null,
-    },
-    {
-      code: `
-        let x: { 0: string };
-        let y = x[0];
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
-    },
-    {
-      code: `
-        let x: { 0: string };
-        y = x[0];
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { array: true, object: false },
+        { enforceForRenamedProperties: true },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
     },
     {
       code: `
-        let x: { 0: string };
-        let y = x[0];
+        let x: Record<number, unknown>;
+        let i: 0 = 0;
+        y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
       options: [
-        {
-          AssignmentExpression: { array: false, object: false },
-          VariableDeclarator: { array: false, object: true },
-        },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: { 0: string };
-        y = x[0];
+        let x: Record<number, unknown>;
+        let i: 0 | 1 | 2 = 0;
+        y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
-        {
-          AssignmentExpression: { array: false, object: true },
-          VariableDeclarator: { array: false, object: false },
-        },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
+        let x: unknown[];
         let i: number = 0;
         y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
-        { array: true, object: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
+        let x: unknown[];
         let i: 0 = 0;
         y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
-        { array: true, object: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: Record<number, unknown>;
+        let x: unknown[];
         let i: 0 | 1 | 2 = 0;
         y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
-        { array: true, object: true },
+        { array: true, object: false },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
@@ -375,160 +288,196 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: number = 0;
         y = x[i];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
         { array: true, object: true },
-        { enforceForRenamedProperties: true },
+        { enforceForRenamedProperties: false },
       ],
-      output: null,
     },
     {
       code: `
-        let x: unknown[];
-        let i: 0 = 0;
-        y = x[i];
+        let x: { 0: unknown };
+        y += x[0];
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
         { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
     },
     {
       code: `
-        let x: unknown[];
-        let i: 0 | 1 | 2 = 0;
-        y = x[i];
+        class Bar {
+          public [0]: unknown;
+        }
+        class Foo extends Bar {
+          static foo() {
+            let y = super[0];
+          }
+        }
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
-      ],
       options: [
         { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
-      output: null,
-    },
-    {
-      code: `
-        let x: { 0: unknown } | unknown[];
-        let y = x[0];
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
     },
     {
       code: `
-        let x: { 0: unknown } | unknown[];
-        y = x[0];
+        class Bar {
+          public [0]: unknown;
+        }
+        class Foo extends Bar {
+          static foo() {
+            y = super[0];
+          }
+        }
       `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.AssignmentExpression,
-        },
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
-      output: null,
     },
 
-    // auto fixes
-    {
-      code: `
-        let obj = { foo: 'bar' };
-        const foo = obj.foo;
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      output: `
-        let obj = { foo: 'bar' };
-        const {foo} = obj;
-      `,
-    },
-    {
-      code: `
-        let obj = { foo: 'bar' };
-        var x: null = null;
-        const foo = (x, obj).foo;
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      output: `
-        let obj = { foo: 'bar' };
-        var x: null = null;
-        const {foo} = (x, obj);
-      `,
-    },
-    {
-      code: 'const call = (() => null).call;',
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
-      ],
-      output: 'const {call} = () => null;',
-    },
-    {
-      code: `
-        const obj = { foo: 'bar' };
-        let a: any;
-        var foo = (a = obj).foo;
-      `,
-      errors: [
-        {
-          data: { type: 'object' },
-          messageId: 'preferDestructuring',
-          type: AST_NODE_TYPES.VariableDeclarator,
-        },
+    // already destructured
+    `
+      let xs: unknown[] = [1];
+      let [x] = xs;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      const { x } = obj;
+    `,
+    `
+      var obj: { x: unknown } = { x: 1 };
+      var { x: y } = obj;
+    `,
+    `
+      let obj: { x: unknown } = { x: 1 };
+      let key: 'x' = 'x';
+      let { [key]: foo } = obj;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      let x: unknown;
+      ({ x } = obj);
+    `,
+
+    // valid unless enforceForRenamedProperties is true
+    `
+      let obj: { x: unknown } = { x: 1 };
+      let y = obj.x;
+    `,
+    `
+      var obj: { x: unknown } = { x: 1 };
+      var y: unknown;
+      y = obj.x;
+    `,
+    `
+      const obj: { x: unknown } = { x: 1 };
+      const y = obj['x'];
+    `,
+    `
+      let obj: Record<string, unknown> = {};
+      let key = 'abc';
+      var y = obj[key];
+    `,
+
+    // shorthand operators shouldn't be reported;
+    `
+      let obj: { x: number } = { x: 1 };
+      let x = 10;
+      x += obj.x;
+    `,
+    `
+      let obj: { x: boolean } = { x: false };
+      let x = true;
+      x ||= obj.x;
+    `,
+    `
+      const xs: number[] = [1];
+      let x = 3;
+      x *= xs[0];
+    `,
+
+    // optional chaining shouldn't be reported
+    `
+      let xs: unknown[] | undefined;
+      let x = xs?.[0];
+    `,
+    `
+      let obj: Record<string, unknown> | undefined;
+      let x = obj?.x;
+    `,
+
+    // private identifiers
+    `
+      class C {
+        #foo: string;
+
+        method() {
+          const foo: unknown = this.#foo;
+        }
+      }
+    `,
+    `
+      class C {
+        #foo: string;
+
+        method() {
+          let foo: unknown;
+          foo = this.#foo;
+        }
+      }
+    `,
+    {
+      code: `
+        class C {
+          #foo: string;
+
+          method() {
+            const bar: unknown = this.#foo;
+          }
+        }
+      `,
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
       ],
-      output: `
-        const obj = { foo: 'bar' };
-        let a: any;
-        var {foo} = a = obj;
+    },
+    {
+      code: `
+        class C {
+          #foo: string;
+
+          method(another: C) {
+            let bar: unknown;
+            bar: unknown = another.#foo;
+          }
+        }
       `,
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
+      ],
     },
     {
       code: `
-        const obj = { asdf: { qwer: null } };
-        const qwer = obj.asdf.qwer;
+        class C {
+          #foo: string;
+
+          method() {
+            const foo: unknown = this.#foo;
+          }
+        }
       `,
+      options: [
+        { array: true, object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
+      ],
+    },
+  ],
+  invalid: [
+    // enforceForDeclarationWithTypeAnnotation: true
+    {
+      code: 'var foo: string = object.foo;',
       errors: [
         {
           data: { type: 'object' },
@@ -536,16 +485,29 @@ ruleTester.run('prefer-destructuring', rule, {
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
-      output: `
-        const obj = { asdf: { qwer: null } };
-        const {qwer} = obj.asdf;
-      `,
+      options: [
+        { object: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
+      ],
+      output: null,
     },
     {
-      code: `
-        const obj = { foo: 100 };
-        const /* comment */ foo = obj.foo;
-      `,
+      code: 'var foo: string = array[0];',
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      options: [
+        { array: true },
+        { enforceForDeclarationWithTypeAnnotation: true },
+      ],
+      output: null,
+    },
+    {
+      code: 'var foo: unknown = object.bar;',
       errors: [
         {
           data: { type: 'object' },
@@ -553,277 +515,260 @@ ruleTester.run('prefer-destructuring', rule, {
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
-      output: `
-        const obj = { foo: 100 };
-        const /* comment */ {foo} = obj;
-      `,
+      options: [
+        { object: true },
+        {
+          enforceForDeclarationWithTypeAnnotation: true,
+          enforceForRenamedProperties: true,
+        },
+      ],
+      output: null,
     },
 
-    // enforceForRenamedProperties: true
+    // numeric property for iterable / non-iterable
     {
       code: `
-        let obj = { foo: 'bar' };
-        const x = obj.foo;
+        let x: { [Symbol.iterator]: unknown };
+        let y = x[0];
       `,
       errors: [
         {
-          data: { type: 'object' },
+          data: { type: 'array' },
           messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
       output: null,
     },
     {
       code: `
-        let obj = { foo: 'bar' };
-        let x: unknown;
-        x = obj.foo;
+        let x: { [Symbol.iterator]: unknown };
+        y = x[0];
       `,
       errors: [
         {
-          data: { type: 'object' },
+          data: { type: 'array' },
           messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.AssignmentExpression,
         },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
       output: null,
     },
     {
       code: `
-        let obj: Record<string, unknown>;
-        let key = 'abc';
-        const x = obj[key];
+        let x: [1, 2, 3];
+        let y = x[0];
       `,
       errors: [
         {
-          data: { type: 'object' },
+          data: { type: 'array' },
           messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.VariableDeclarator,
         },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
       output: null,
     },
     {
       code: `
-        let obj: Record<string, unknown>;
-        let key = 'abc';
-        let x: unknown;
-        x = obj[key];
+        let x: [1, 2, 3];
+        y = x[0];
       `,
       errors: [
         {
-          data: { type: 'object' },
+          data: { type: 'array' },
           messageId: 'preferDestructuring',
           type: AST_NODE_TYPES.AssignmentExpression,
         },
       ],
-      options: [{ object: true }, { enforceForRenamedProperties: true }],
       output: null,
     },
-  ],
-  valid: [
-    // type annotated
-    `
-      declare const object: { foo: string };
-      var foo: string = object.foo;
-    `,
-    `
-      declare const array: number[];
-      const bar: number = array[0];
-    `,
-    // enforceForDeclarationWithTypeAnnotation: true
     {
       code: `
-        declare const object: { foo: string };
-        var { foo } = object;
+        function* it() {
+          yield 1;
+        }
+        let y = it()[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { foo: string };
-        var { foo }: { foo: number } = object;
+        function* it() {
+          yield 1;
+        }
+        y = it()[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
-    },
-    {
-      code: `
-        declare const array: number[];
-        var [foo] = array;
-      `,
-      options: [
-        { array: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
-      ],
-    },
-    {
-      code: `
-        declare const array: number[];
-        var [foo]: [foo: number] = array;
-      `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { bar: string };
-        var foo: unknown = object.bar;
+        let x: any;
+        let y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { foo: string };
-        var { foo: bar } = object;
+        let x: any;
+        y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare const object: { foo: boolean };
-        var { foo: bar }: { foo: boolean } = object;
+        let x: string[] | { [Symbol.iterator]: unknown };
+        let y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        declare class Foo {
-          foo: string;
-        }
-
-        class Bar extends Foo {
-          static foo() {
-            var foo: any = super.foo;
-          }
-        }
+        let x: string[] | { [Symbol.iterator]: unknown };
+        y = x[0];
       `,
-      options: [
-        { object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
-
-    // numeric property for iterable / non-iterable
-    `
-      let x: { 0: unknown };
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown };
-      y = x[0];
-    `,
-    `
-      let x: unknown;
-      let y = x[0];
-    `,
-    `
-      let x: unknown;
-      y = x[0];
-    `,
-    `
-      let x: { 0: unknown } | unknown[];
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown } | unknown[];
-      y = x[0];
-    `,
-    `
-      let x: { 0: unknown } & (() => void);
-      let y = x[0];
-    `,
-    `
-      let x: { 0: unknown } & (() => void);
-      y = x[0];
-    `,
-    `
-      let x: Record<number, unknown>;
-      let y = x[0];
-    `,
-    `
-      let x: Record<number, unknown>;
-      y = x[0];
-    `,
     {
       code: `
-        let x: { 0: unknown };
-        let { 0: y } = x;
+        let x: object & unknown[];
+        let y = x[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
-        ({ 0: y } = x);
+        let x: object & unknown[];
+        y = x[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'array' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: { 0: string };
         let y = x[0];
       `,
-      options: [{ array: true }, { enforceForRenamedProperties: true }],
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: { 0: string };
         y = x[0];
       `,
-      options: [{ array: true }, { enforceForRenamedProperties: true }],
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: { 0: string };
         let y = x[0];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
       options: [
         {
-          AssignmentExpression: { array: true, object: true },
-          VariableDeclarator: { array: true, object: false },
+          AssignmentExpression: { array: false, object: false },
+          VariableDeclarator: { array: false, object: true },
         },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
+        let x: { 0: string };
         y = x[0];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
         {
-          AssignmentExpression: { array: true, object: false },
-          VariableDeclarator: { array: true, object: true },
+          AssignmentExpression: { array: false, object: true },
+          VariableDeclarator: { array: false, object: false },
         },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -831,10 +776,18 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: number = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { array: true, object: false },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -842,10 +795,18 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: 0 = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { array: true, object: false },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -853,10 +814,18 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: 0 | 1 | 2 = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { array: true, object: false },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -864,10 +833,18 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: number = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { array: true, object: false },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
@@ -875,10 +852,18 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: 0 = 0;
         y = x[i];
       `,
-      options: [
-        { array: true, object: false },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      options: [
+        { array: true, object: true },
+        { enforceForRenamedProperties: true },
+      ],
+      output: null,
     },
     {
       code: `
@@ -886,201 +871,216 @@ ruleTester.run('prefer-destructuring', rule, {
         let i: 0 | 1 | 2 = 0;
         y = x[i];
       `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
       options: [
-        { array: true, object: false },
+        { array: true, object: true },
         { enforceForRenamedProperties: true },
       ],
+      output: null,
     },
     {
       code: `
-        let x: unknown[];
-        let i: number = 0;
-        y = x[i];
+        let x: { 0: unknown } | unknown[];
+        let y = x[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: false },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
     {
       code: `
-        let x: { 0: unknown };
-        y += x[0];
+        let x: { 0: unknown } | unknown[];
+        y = x[0];
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
+
+    // auto fixes
     {
       code: `
-        class Bar {
-          public [0]: unknown;
-        }
-        class Foo extends Bar {
-          static foo() {
-            let y = super[0];
-          }
-        }
+        let obj = { foo: 'bar' };
+        const foo = obj.foo;
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: `
+        let obj = { foo: 'bar' };
+        const {foo} = obj;
+      `,
     },
     {
       code: `
-        class Bar {
-          public [0]: unknown;
-        }
-        class Foo extends Bar {
-          static foo() {
-            y = super[0];
-          }
-        }
+        let obj = { foo: 'bar' };
+        var x: null = null;
+        const foo = (x, obj).foo;
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForRenamedProperties: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: `
+        let obj = { foo: 'bar' };
+        var x: null = null;
+        const {foo} = (x, obj);
+      `,
+    },
+    {
+      code: 'const call = (() => null).call;',
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      output: 'const {call} = () => null;',
     },
-
-    // already destructured
-    `
-      let xs: unknown[] = [1];
-      let [x] = xs;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      const { x } = obj;
-    `,
-    `
-      var obj: { x: unknown } = { x: 1 };
-      var { x: y } = obj;
-    `,
-    `
-      let obj: { x: unknown } = { x: 1 };
-      let key: 'x' = 'x';
-      let { [key]: foo } = obj;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      let x: unknown;
-      ({ x } = obj);
-    `,
-
-    // valid unless enforceForRenamedProperties is true
-    `
-      let obj: { x: unknown } = { x: 1 };
-      let y = obj.x;
-    `,
-    `
-      var obj: { x: unknown } = { x: 1 };
-      var y: unknown;
-      y = obj.x;
-    `,
-    `
-      const obj: { x: unknown } = { x: 1 };
-      const y = obj['x'];
-    `,
-    `
-      let obj: Record<string, unknown> = {};
-      let key = 'abc';
-      var y = obj[key];
-    `,
-
-    // shorthand operators shouldn't be reported;
-    `
-      let obj: { x: number } = { x: 1 };
-      let x = 10;
-      x += obj.x;
-    `,
-    `
-      let obj: { x: boolean } = { x: false };
-      let x = true;
-      x ||= obj.x;
-    `,
-    `
-      const xs: number[] = [1];
-      let x = 3;
-      x *= xs[0];
-    `,
-
-    // optional chaining shouldn't be reported
-    `
-      let xs: unknown[] | undefined;
-      let x = xs?.[0];
-    `,
-    `
-      let obj: Record<string, unknown> | undefined;
-      let x = obj?.x;
-    `,
-
-    // private identifiers
-    `
-      class C {
-        #foo: string;
-
-        method() {
-          const foo: unknown = this.#foo;
-        }
-      }
-    `,
-    `
-      class C {
-        #foo: string;
-
-        method() {
-          let foo: unknown;
-          foo = this.#foo;
-        }
-      }
-    `,
     {
       code: `
-        class C {
-          #foo: string;
-
-          method() {
-            const bar: unknown = this.#foo;
-          }
-        }
+        const obj = { foo: 'bar' };
+        let a: any;
+        var foo = (a = obj).foo;
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: `
+        const obj = { foo: 'bar' };
+        let a: any;
+        var {foo} = a = obj;
+      `,
     },
     {
       code: `
-        class C {
-          #foo: string;
-
-          method(another: C) {
-            let bar: unknown;
-            bar: unknown = another.#foo;
-          }
-        }
+        const obj = { asdf: { qwer: null } };
+        const qwer = obj.asdf.qwer;
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      output: `
+        const obj = { asdf: { qwer: null } };
+        const {qwer} = obj.asdf;
+      `,
     },
     {
       code: `
-        class C {
-          #foo: string;
+        const obj = { foo: 100 };
+        const /* comment */ foo = obj.foo;
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      output: `
+        const obj = { foo: 100 };
+        const /* comment */ {foo} = obj;
+      `,
+    },
 
-          method() {
-            const foo: unknown = this.#foo;
-          }
-        }
+    // enforceForRenamedProperties: true
+    {
+      code: `
+        let obj = { foo: 'bar' };
+        const x = obj.foo;
       `,
-      options: [
-        { array: true, object: true },
-        { enforceForDeclarationWithTypeAnnotation: true },
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let obj = { foo: 'bar' };
+        let x: unknown;
+        x = obj.foo;
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let obj: Record<string, unknown>;
+        let key = 'abc';
+        const x = obj[key];
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.VariableDeclarator,
+        },
       ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
+    },
+    {
+      code: `
+        let obj: Record<string, unknown>;
+        let key = 'abc';
+        let x: unknown;
+        x = obj[key];
+      `,
+      errors: [
+        {
+          data: { type: 'object' },
+          messageId: 'preferDestructuring',
+          type: AST_NODE_TYPES.AssignmentExpression,
+        },
+      ],
+      options: [{ object: true }, { enforceForRenamedProperties: true }],
+      output: null,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-find.test.ts b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
index 310f4abe0940..14026c51b96e 100644
--- a/packages/eslint-plugin/tests/rules/prefer-find.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
@@ -15,6 +15,69 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-find', rule, {
+  valid: [
+    `
+      interface JerkCode<T> {
+        filter(predicate: (item: T) => boolean): JerkCode<T>;
+      }
+
+      declare const jerkCode: JerkCode<string>;
+
+      jerkCode.filter(item => item === 'aha')[0];
+    `,
+    `
+      declare const arr: readonly string[];
+      arr.filter(item => item === 'aha')[1];
+    `,
+    `
+      declare const arr: string[];
+      arr.filter(item => item === 'aha').at(1);
+    `,
+    `
+      declare const notNecessarilyAnArray: unknown[] | undefined | null | string;
+      notNecessarilyAnArray?.filter(item => true)[0];
+    `,
+    // Be sure that we don't try to mess with this case, since the member access
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter(() => true)?.[0];',
+    // Be sure that we don't try to mess with this case, since the member access
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter(() => true)?.at?.(0);',
+    // Be sure that we don't try to mess with this case, since the function call
+    // should not need to be optional for the cases the rule is concerned with.
+    '[].filter?.(() => true)[0];',
+    '[1, 2, 3].filter(x => x > 0).at(-Infinity);',
+    `
+      declare const arr: string[];
+      declare const cond: Parameters<Array<string>['filter']>[0];
+      const a = { arr };
+      a?.arr.filter(cond).at(1);
+    `,
+    "['Just', 'a', 'filter'].filter(x => x.length > 4);",
+    "['Just', 'a', 'find'].find(x => x.length > 4);",
+    'undefined.filter(x => x)[0];',
+    'null?.filter(x => x)[0];',
+    // Should not throw. See https://github.com/typescript-eslint/typescript-eslint/issues/8386
+    `
+      declare function foo(param: any): any;
+      foo(Symbol.for('foo'));
+    `,
+    // Specifically need to test Symbol.for(), not just Symbol(), since only
+    // Symbol.for() creates a static value that the rule inspects.
+    `
+      declare const arr: string[];
+      const s = Symbol.for("Don't throw!");
+      arr.filter(item => item === 'aha').at(s);
+    `,
+    "[1, 2, 3].filter(x => x)[Symbol('0')];",
+    "[1, 2, 3].filter(x => x)[Symbol.for('0')];",
+    '(Math.random() < 0.5 ? [1, 2, 3].filter(x => true) : [1, 2, 3])[0];',
+    `
+      (Math.random() < 0.5
+        ? [1, 2, 3].find(x => true)
+        : [1, 2, 3].filter(x => true))[0];
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -665,68 +728,4 @@ declare const spreadArgs: [(x: unknown) => boolean];
       ],
     },
   ],
-
-  valid: [
-    `
-      interface JerkCode<T> {
-        filter(predicate: (item: T) => boolean): JerkCode<T>;
-      }
-
-      declare const jerkCode: JerkCode<string>;
-
-      jerkCode.filter(item => item === 'aha')[0];
-    `,
-    `
-      declare const arr: readonly string[];
-      arr.filter(item => item === 'aha')[1];
-    `,
-    `
-      declare const arr: string[];
-      arr.filter(item => item === 'aha').at(1);
-    `,
-    `
-      declare const notNecessarilyAnArray: unknown[] | undefined | null | string;
-      notNecessarilyAnArray?.filter(item => true)[0];
-    `,
-    // Be sure that we don't try to mess with this case, since the member access
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter(() => true)?.[0];',
-    // Be sure that we don't try to mess with this case, since the member access
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter(() => true)?.at?.(0);',
-    // Be sure that we don't try to mess with this case, since the function call
-    // should not need to be optional for the cases the rule is concerned with.
-    '[].filter?.(() => true)[0];',
-    '[1, 2, 3].filter(x => x > 0).at(-Infinity);',
-    `
-      declare const arr: string[];
-      declare const cond: Parameters<Array<string>['filter']>[0];
-      const a = { arr };
-      a?.arr.filter(cond).at(1);
-    `,
-    "['Just', 'a', 'filter'].filter(x => x.length > 4);",
-    "['Just', 'a', 'find'].find(x => x.length > 4);",
-    'undefined.filter(x => x)[0];',
-    'null?.filter(x => x)[0];',
-    // Should not throw. See https://github.com/typescript-eslint/typescript-eslint/issues/8386
-    `
-      declare function foo(param: any): any;
-      foo(Symbol.for('foo'));
-    `,
-    // Specifically need to test Symbol.for(), not just Symbol(), since only
-    // Symbol.for() creates a static value that the rule inspects.
-    `
-      declare const arr: string[];
-      const s = Symbol.for("Don't throw!");
-      arr.filter(item => item === 'aha').at(s);
-    `,
-    "[1, 2, 3].filter(x => x)[Symbol('0')];",
-    "[1, 2, 3].filter(x => x)[Symbol.for('0')];",
-    '(Math.random() < 0.5 ? [1, 2, 3].filter(x => true) : [1, 2, 3])[0];',
-    `
-      (Math.random() < 0.5
-        ? [1, 2, 3].find(x => true)
-        : [1, 2, 3].filter(x => true))[0];
-    `,
-  ],
 });
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 f44352bc3bcf..781020b933e5 100644
--- a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
@@ -5,6 +5,191 @@ import rule from '../../src/rules/prefer-for-of';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-for-of', rule, {
+  valid: [
+    `
+for (let i = 0; i < arr1.length; i++) {
+  const x = arr1[i] === arr2[i];
+}
+    `,
+    `
+for (let i = 0; i < arr.length; i++) {
+  arr[i] = 0;
+}
+    `,
+    `
+for (var c = 0; c < arr.length; c++) {
+  doMath(c);
+}
+    `,
+    `
+for (var d = 0; d < arr.length; d++) doMath(d);
+    `,
+    `
+for (var e = 0; e < arr.length; e++) {
+  if (e > 5) {
+    doMath(e);
+  }
+  console.log(arr[e]);
+}
+    `,
+    `
+for (var f = 0; f <= 40; f++) {
+  doMath(f);
+}
+    `,
+    `
+for (var g = 0; g <= 40; g++) doMath(g);
+    `,
+    `
+for (var h = 0, len = arr.length; h < len; h++) {}
+    `,
+    `
+for (var i = 0, len = arr.length; i < len; i++) arr[i];
+    `,
+    `
+var m = 0;
+for (;;) {
+  if (m > 3) break;
+  console.log(m);
+  m++;
+}
+    `,
+    `
+var n = 0;
+for (; n < 9; n++) {
+  console.log(n);
+}
+    `,
+    `
+var o = 0;
+for (; o < arr.length; o++) {
+  console.log(arr[o]);
+}
+    `,
+    `
+for (; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; ; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; ) {}
+    `,
+    `
+for (let x = 0; NOTX < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; NOTX++) {}
+    `,
+    `
+for (let NOTX = 0; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; x--) {}
+    `,
+    `
+for (let x = 0; x <= arr.length; x++) {}
+    `,
+    `
+for (let x = 1; x < arr.length; x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length(); x++) {}
+    `,
+    `
+for (let x = 0; x < arr.length; x += 11) {}
+    `,
+    `
+for (let x = arr.length; x > 1; x -= 1) {}
+    `,
+    `
+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++;
+}
+    `,
+    `
+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];
+}
+    `,
+    `
+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 c = 0; c < arr.length; c++) {
+  doMath?.(c);
+}
+    `,
+    `
+for (var d = 0; d < arr.length; d++) doMath?.(d);
+    `,
+    `
+for (let i = 0; i < test.length; ++i) {
+  this[i];
+}
+    `,
+    `
+for (let i = 0; i < this.length; ++i) {
+  yield this[i];
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -214,189 +399,4 @@ for (let i = 0; i < this.array.length; ++i) {
       ],
     },
   ],
-  valid: [
-    `
-for (let i = 0; i < arr1.length; i++) {
-  const x = arr1[i] === arr2[i];
-}
-    `,
-    `
-for (let i = 0; i < arr.length; i++) {
-  arr[i] = 0;
-}
-    `,
-    `
-for (var c = 0; c < arr.length; c++) {
-  doMath(c);
-}
-    `,
-    `
-for (var d = 0; d < arr.length; d++) doMath(d);
-    `,
-    `
-for (var e = 0; e < arr.length; e++) {
-  if (e > 5) {
-    doMath(e);
-  }
-  console.log(arr[e]);
-}
-    `,
-    `
-for (var f = 0; f <= 40; f++) {
-  doMath(f);
-}
-    `,
-    `
-for (var g = 0; g <= 40; g++) doMath(g);
-    `,
-    `
-for (var h = 0, len = arr.length; h < len; h++) {}
-    `,
-    `
-for (var i = 0, len = arr.length; i < len; i++) arr[i];
-    `,
-    `
-var m = 0;
-for (;;) {
-  if (m > 3) break;
-  console.log(m);
-  m++;
-}
-    `,
-    `
-var n = 0;
-for (; n < 9; n++) {
-  console.log(n);
-}
-    `,
-    `
-var o = 0;
-for (; o < arr.length; o++) {
-  console.log(arr[o]);
-}
-    `,
-    `
-for (; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; ; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; ) {}
-    `,
-    `
-for (let x = 0; NOTX < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; NOTX++) {}
-    `,
-    `
-for (let NOTX = 0; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; x--) {}
-    `,
-    `
-for (let x = 0; x <= arr.length; x++) {}
-    `,
-    `
-for (let x = 1; x < arr.length; x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length(); x++) {}
-    `,
-    `
-for (let x = 0; x < arr.length; x += 11) {}
-    `,
-    `
-for (let x = arr.length; x > 1; x -= 1) {}
-    `,
-    `
-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++;
-}
-    `,
-    `
-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];
-}
-    `,
-    `
-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 c = 0; c < arr.length; c++) {
-  doMath?.(c);
-}
-    `,
-    `
-for (var d = 0; d < arr.length; d++) doMath?.(d);
-    `,
-    `
-for (let i = 0; i < test.length; ++i) {
-  this[i];
-}
-    `,
-    `
-for (let i = 0; i < this.length; ++i) {
-  yield this[i];
-}
-    `,
-  ],
 });
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 792377467b90..2ef07ddc0344 100644
--- a/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
@@ -6,6 +6,41 @@ import rule, { phrases } from '../../src/rules/prefer-function-type';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-function-type', rule, {
+  valid: [
+    `
+interface Foo {
+  (): void;
+  bar: number;
+}
+    `,
+    `
+type Foo = {
+  (): void;
+  bar: number;
+};
+    `,
+    `
+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: [
     {
       code: `
@@ -370,40 +405,4 @@ type X = {} & (() => void);
       `,
     },
   ],
-
-  valid: [
-    `
-interface Foo {
-  (): void;
-  bar: number;
-}
-    `,
-    `
-type Foo = {
-  (): void;
-  bar: number;
-};
-    `,
-    `
-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;
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
index 0dd67d146c14..35830c45ad9d 100644
--- a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
@@ -15,6 +15,89 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-includes', rule, {
+  valid: [
+    `
+      function f(a: string): void {
+        a.indexOf(b);
+      }
+    `,
+    `
+      function f(a: string): void {
+        a.indexOf(b) + 0;
+      }
+    `,
+    `
+      function f(a: string | { value: string }): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any): number; // don't have 'includes'
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes(x: any): boolean; // different parameters
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes(x: any, fromIndex: number): boolean; // different parameters
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number;
+        includes: boolean; // different type
+      };
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1;
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/i.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /ba[rz]/.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /foo|bar/.test(a);
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/.test();
+      }
+    `,
+    `
+      function f(a: string): void {
+        something.test(a);
+      }
+    `,
+    `
+      const pattern = new RegExp('bar');
+      function f(a) {
+        return pattern.test(a);
+      }
+    `,
+  ],
   invalid: [
     // positive
     {
@@ -432,87 +515,4 @@ ruleTester.run('prefer-includes', rule, {
       `,
     },
   ],
-  valid: [
-    `
-      function f(a: string): void {
-        a.indexOf(b);
-      }
-    `,
-    `
-      function f(a: string): void {
-        a.indexOf(b) + 0;
-      }
-    `,
-    `
-      function f(a: string | { value: string }): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any): number; // don't have 'includes'
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes(x: any): boolean; // different parameters
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes(x: any, fromIndex: number): boolean; // different parameters
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      type UserDefined = {
-        indexOf(x: any, fromIndex?: number): number;
-        includes: boolean; // different type
-      };
-      function f(a: UserDefined): void {
-        a.indexOf(b) !== -1;
-      }
-    `,
-    `
-      function f(a: string): void {
-        /bar/i.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /ba[rz]/.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /foo|bar/.test(a);
-      }
-    `,
-    `
-      function f(a: string): void {
-        /bar/.test();
-      }
-    `,
-    `
-      function f(a: string): void {
-        something.test(a);
-      }
-    `,
-    `
-      const pattern = new RegExp('bar');
-      function f(a) {
-        return pattern.test(a);
-      }
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts b/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
index 0bfdc11ae56e..a909f9e636a1 100644
--- a/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-literal-enum-member.test.ts
@@ -5,6 +5,116 @@ import rule from '../../src/rules/prefer-literal-enum-member';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-literal-enum-member', rule, {
+  valid: [
+    `
+enum ValidRegex {
+  A = /test/,
+}
+    `,
+    `
+enum ValidString {
+  A = 'test',
+}
+    `,
+    `
+enum ValidLiteral {
+  A = \`test\`,
+}
+    `,
+    `
+enum ValidNumber {
+  A = 42,
+}
+    `,
+    `
+enum ValidNumber {
+  A = -42,
+}
+    `,
+    `
+enum ValidNumber {
+  A = +42,
+}
+    `,
+    `
+enum ValidNull {
+  A = null,
+}
+    `,
+    `
+enum ValidPlain {
+  A,
+}
+    `,
+    `
+enum ValidQuotedKey {
+  'a',
+}
+    `,
+    `
+enum ValidQuotedKeyWithAssignment {
+  'a' = 1,
+}
+    `,
+    noFormat`
+enum ValidKeyWithComputedSyntaxButNoComputedKey {
+  ['a'],
+}
+    `,
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = 1 >>> 0,
+  D = 1 | 0,
+  E = 1 & 0,
+  F = 1 ^ 0,
+  G = ~1,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = A | B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = Foo.A | Foo.B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  A = 1 << 0,
+  B = 1 >> 0,
+  C = Foo['A'] | B,
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+    {
+      code: `
+enum Foo {
+  ['A-1'] = 1 << 0,
+  C = ~Foo['A-1'],
+}
+      `,
+      options: [{ allowBitwiseExpressions: true }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -324,114 +434,4 @@ enum Foo {
       options: [{ allowBitwiseExpressions: true }],
     },
   ],
-  valid: [
-    `
-enum ValidRegex {
-  A = /test/,
-}
-    `,
-    `
-enum ValidString {
-  A = 'test',
-}
-    `,
-    `
-enum ValidLiteral {
-  A = \`test\`,
-}
-    `,
-    `
-enum ValidNumber {
-  A = 42,
-}
-    `,
-    `
-enum ValidNumber {
-  A = -42,
-}
-    `,
-    `
-enum ValidNumber {
-  A = +42,
-}
-    `,
-    `
-enum ValidNull {
-  A = null,
-}
-    `,
-    `
-enum ValidPlain {
-  A,
-}
-    `,
-    `
-enum ValidQuotedKey {
-  'a',
-}
-    `,
-    `
-enum ValidQuotedKeyWithAssignment {
-  'a' = 1,
-}
-    `,
-    noFormat`
-enum ValidKeyWithComputedSyntaxButNoComputedKey {
-  ['a'],
-}
-    `,
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = 1 >>> 0,
-  D = 1 | 0,
-  E = 1 & 0,
-  F = 1 ^ 0,
-  G = ~1,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = A | B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = Foo.A | Foo.B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  A = 1 << 0,
-  B = 1 >> 0,
-  C = Foo['A'] | B,
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-    {
-      code: `
-enum Foo {
-  ['A-1'] = 1 << 0,
-  C = ~Foo['A-1'],
-}
-      `,
-      options: [{ allowBitwiseExpressions: true }],
-    },
-  ],
 });
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 0ceb95d77cb5..e47eb5c390c6 100644
--- a/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
@@ -5,6 +5,13 @@ import rule from '../../src/rules/prefer-namespace-keyword';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-namespace-keyword', rule, {
+  valid: [
+    "declare module 'foo';",
+    "declare module 'foo' {}",
+    'namespace foo {}',
+    'declare namespace foo {}',
+    'declare global {}',
+  ],
   invalid: [
     {
       code: 'module foo {}',
@@ -53,11 +60,4 @@ declare namespace foo {
       `,
     },
   ],
-  valid: [
-    "declare module 'foo';",
-    "declare module 'foo' {}",
-    'namespace foo {}',
-    'declare namespace foo {}',
-    'declare global {}',
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts b/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
index 2988d9d7c0d5..3cea4fbbfe6e 100644
--- a/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
@@ -62,500 +62,550 @@ function nullishTypeInvalidTest(
 }
 
 ruleTester.run('prefer-nullish-coalescing', rule, {
-  invalid: [
-    ...nullishTypeInvalidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
+  valid: [
+    ...typeValidTest(
+      type => `
+declare const x: ${type};
 x || 'foo';
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 5,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
+    ),
+    ...nullishTypeValidTest(
+      (nullish, type) => `
 declare const x: ${type} | ${nullish};
 x ?? 'foo';
       `,
-            },
-          ],
-        },
-      ],
-      output: null,
-    })),
-
-    ...[
-      'x !== undefined && x !== null ? x : y;',
-      'x !== null && x !== undefined ? x : y;',
-      'x === undefined || x === null ? y : x;',
-      'x === null || x === undefined ? y : x;',
-      'undefined !== x && x !== null ? x : y;',
-      'null !== x && x !== undefined ? x : y;',
-      'undefined === x || x === null ? y : x;',
-      'null === x || x === undefined ? y : x;',
-      'x !== undefined && null !== x ? x : y;',
-      'x !== null && undefined !== x ? x : y;',
-      'x === undefined || null === x ? y : x;',
-      'x === null || undefined === x ? y : x;',
-      'undefined !== x && null !== x ? x : y;',
-      'null !== x && undefined !== x ? x : y;',
-      'undefined === x || null === x ? y : x;',
-      'null === x || undefined === x ? y : x;',
-      'x != undefined && x != null ? x : y;',
-      'x == undefined || x == null ? y : x;',
-      'x != undefined && x !== null ? x : y;',
-      'x == undefined || x === null ? y : x;',
-      'x !== undefined && x != null ? x : y;',
-      'undefined != x ? x : y;',
-      'null != x ? x : y;',
-      'undefined == x ? y : x;',
-      'null == x ? y : x;',
-      'x != undefined ? x : y;',
-      'x != null ? x : y;',
-      'x == undefined  ? y : x;',
-      'x == null ? y : x;',
-    ].flatMap(code => [
-      {
-        code,
-        errors: [
-          {
-            column: 1,
-            endColumn: code.length,
-            endLine: 1,
-            line: 1,
-            messageId: 'preferNullishOverTernary' as const,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x ?? y;',
-              },
-            ],
-          },
-        ],
-        options: [{ ignoreTernaryTests: false }] as const,
-        output: null,
-      },
-      {
-        code: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]'),
-        errors: [
-          {
-            column: 1,
-            endColumn: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]')
-              .length,
-            endLine: 1,
-            line: 1,
-            messageId: 'preferNullishOverTernary' as const,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x.z[1][this[this.o]]["3"][a.b.c] ?? y;',
-              },
-            ],
-          },
-        ],
-        options: [{ ignoreTernaryTests: false }] as const,
-        output: null,
-      },
-      {
-        code: code.replaceAll('y', '(z = y)'),
-        errors: [
-          {
-            column: 1,
-            endColumn: code.replaceAll('y', '(z = y)').length,
-            endLine: 1,
-            line: 1,
-            messageId: 'preferNullishOverTernary' as const,
-            suggestions: [
-              {
-                messageId: 'suggestNullish' as const,
-                output: 'x ?? (z = y);',
-              },
-            ],
-          },
-        ],
-        options: [{ ignoreTernaryTests: false }] as const,
-        output: null,
-      },
-    ]),
+    ),
 
     {
-      code: 'this != undefined ? this : y;',
-      errors: [
-        {
-          column: 1,
-          endColumn: 29,
-          endLine: 1,
-          line: 1,
-          messageId: 'preferNullishOverTernary' as const,
-          suggestions: [
-            {
-              messageId: 'suggestNullish' as const,
-              output: 'this ?? y;',
-            },
-          ],
-        },
-      ],
-      options: [{ ignoreTernaryTests: false }] as const,
-      output: null,
+      code: 'x !== undefined && x !== null ? x : y;',
+      options: [{ ignoreTernaryTests: true }],
     },
 
     ...[
+      'x !== undefined && x !== null ? "foo" : "bar";',
+      'x !== null && x !== undefined && x !== 5 ? x : y',
+      'x === null || x === undefined || x === 5 ? x : y',
+      'x === undefined && x !== null ? x : y;',
+      'x === undefined && x === null ? x : y;',
+      'x !== undefined && x === null ? x : y;',
+      'x === undefined || x !== null ? x : y;',
+      'x === undefined || x === null ? x : y;',
+      'x !== undefined || x === null ? x : y;',
+      'x !== undefined || x === null ? y : x;',
+      'x === null || x === null ? y : x;',
+      'x === undefined || x === undefined ? y : x;',
+      'x == null ? x : y;',
+      'undefined == null ? x : y;',
+      'undefined != z ? x : y;',
+      'x == undefined ? x : y;',
+      'x != null ? y : x;',
+      'x != undefined ? y : x;',
+      'null == x ? x : y;',
+      'undefined == x ? x : y;',
+      'null != x ? y : x;',
+      'undefined != x ? y : x;',
       `
-declare const x: string | undefined;
-x !== undefined ? x : y;
+declare const x: string;
+x === null ? x : y;
       `,
       `
 declare const x: string | undefined;
-undefined !== x ? x : y;
+x === null ? x : y;
       `,
       `
-declare const x: string | undefined;
-x === undefined ? y : x;
+declare const x: string | null;
+x === undefined ? x : y;
       `,
       `
-declare const x: string | undefined;
-undefined === x ? y : x;
+declare const x: string | undefined | null;
+x !== undefined ? x : y;
       `,
       `
-declare const x: string | null;
+declare const x: string | undefined | null;
 x !== null ? x : y;
       `,
       `
-declare const x: string | null;
-null !== x ? x : y;
-      `,
-      `
-declare const x: string | null;
-x === null ? y : x;
+declare const x: string | null | any;
+x === null ? x : y;
       `,
       `
-declare const x: string | null;
-null === x ? y : x;
+declare const x: string | null | unknown;
+x === null ? x : y;
       `,
     ].map(code => ({
       code,
-      errors: [
-        {
-          column: 1,
-          endColumn: code.split('\n')[2].length,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverTernary' as const,
-          suggestions: [
-            {
-              messageId: 'suggestNullish' as const,
-              output: `
-${code.split('\n')[1]}
-x ?? y;
-      `,
-            },
-          ],
-        },
-      ],
       options: [{ ignoreTernaryTests: false }] as const,
-      output: null,
     })),
 
-    // noStrictNullCheck
-    {
-      code: `
-declare const x: string[] | null;
-if (x) {
-}
-      `,
-      errors: [
-        {
-          column: 1,
-          line: 0,
-          messageId: 'noStrictNullCheck',
-        },
-      ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
-      output: null,
-    },
-
     // ignoreConditionalTests
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    ...nullishTypeValidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
 x || 'foo' ? null : null;
       `,
-      errors: [
-        {
-          column: 3,
-          endColumn: 5,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
 declare const x: ${type} | ${nullish};
-x ?? 'foo' ? null : null;
+if (x || 'foo') {}
       `,
-            },
-          ],
-        },
-      ],
-      options: [{ ignoreConditionalTests: false }],
-      output: null,
     })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    ...nullishTypeValidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-if (x || 'foo') {}
+do {} while (x || 'foo')
       `,
-      errors: [
-        {
-          column: 7,
-          endColumn: 9,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
 declare const x: ${type} | ${nullish};
-if (x ?? 'foo') {}
+for (;x || 'foo';) {}
       `,
-            },
-          ],
-        },
-      ],
-      options: [{ ignoreConditionalTests: false }],
-      output: null,
     })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    ...nullishTypeValidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-do {} while (x || 'foo')
+while (x || 'foo') {}
       `,
-      errors: [
-        {
-          column: 16,
-          endColumn: 18,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: ${type} | ${nullish};
-do {} while (x ?? 'foo')
+    })),
+
+    // ignoreMixedLogicalExpressions
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+a || b && c;
       `,
-            },
-          ],
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a || b || c && d;
+      `,
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...nullishTypeValidTest((nullish, type) => ({
+      code: `
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c || d;
+      `,
+      options: [{ ignoreMixedLogicalExpressions: true }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: ${type} | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: { [type]: true } }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: ${type} | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: true }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: (${type} & { __brand?: any }) | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: { [type]: true } }],
+    })),
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: (${type} & { __brand?: any }) | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: true }],
+    })),
+    `
+      declare const x: any;
+      declare const y: number;
+      x || y;
+    `,
+    `
+      declare const x: unknown;
+      declare const y: number;
+      x || y;
+    `,
+    `
+      declare const x: never;
+      declare const y: number;
+      x || y;
+    `,
+    {
+      code: `
+declare const x: 0 | 1 | 0n | 1n | undefined;
+x || y;
+      `,
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
+          },
         },
       ],
-      options: [{ ignoreConditionalTests: false }],
-      output: null,
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    },
+    {
       code: `
-declare const x: ${type} | ${nullish};
-for (;x || 'foo';) {}
+declare const x: 0 | 1 | 0n | 1n | undefined;
+x || y;
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          endColumn: 11,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: ${type} | ${nullish};
-for (;x ?? 'foo';) {}
+          ignorePrimitives: {
+            bigint: false,
+            boolean: true,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+declare const x: 0 | 'foo' | undefined;
+x || y;
       `,
-            },
-          ],
+      options: [
+        {
+          ignorePrimitives: {
+            number: true,
+            string: true,
+          },
         },
       ],
-      options: [{ ignoreConditionalTests: false }],
-      output: null,
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    },
+    {
       code: `
-declare const x: ${type} | ${nullish};
-while (x || 'foo') {}
+declare const x: 0 | 'foo' | undefined;
+x || y;
       `,
-      errors: [
+      options: [
         {
-          column: 10,
-          endColumn: 12,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const x: ${type} | ${nullish};
-while (x ?? 'foo') {}
+          ignorePrimitives: {
+            number: true,
+            string: false,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum | undefined;
+x || y;
       `,
-            },
-          ],
+      options: [
+        {
+          ignorePrimitives: {
+            number: true,
+          },
         },
       ],
-      options: [{ ignoreConditionalTests: false }],
-      output: null,
-    })),
-
-    // ignoreMixedLogicalExpressions
-    ...nullishTypeInvalidTest((nullish, type) => ({
+    },
+    {
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-a || b && c;
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum.A | Enum.B | undefined;
+x || y;
       `,
-      errors: [
+      options: [
         {
-          column: 3,
-          endColumn: 5,
-          endLine: 5,
-          line: 5,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-a ?? b && c;
+          ignorePrimitives: {
+            number: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum | undefined;
+x || y;
       `,
-            },
-          ],
+      options: [
+        {
+          ignorePrimitives: {
+            string: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum.A | Enum.B | undefined;
+x || y;
+      `,
+      options: [
+        {
+          ignorePrimitives: {
+            string: true,
+          },
         },
       ],
-      options: [{ ignoreMixedLogicalExpressions: false }],
-    })),
+    },
+  ],
+  invalid: [
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a || b || c && d;
+declare const x: ${type} | ${nullish};
+x || 'foo';
       `,
       errors: [
         {
           column: 3,
           endColumn: 5,
-          endLine: 6,
-          line: 6,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-(a ?? b) || c && d;
+declare const x: ${type} | ${nullish};
+x ?? 'foo';
       `,
             },
           ],
         },
+      ],
+      output: null,
+    })),
+
+    ...[
+      'x !== undefined && x !== null ? x : y;',
+      'x !== null && x !== undefined ? x : y;',
+      'x === undefined || x === null ? y : x;',
+      'x === null || x === undefined ? y : x;',
+      'undefined !== x && x !== null ? x : y;',
+      'null !== x && x !== undefined ? x : y;',
+      'undefined === x || x === null ? y : x;',
+      'null === x || x === undefined ? y : x;',
+      'x !== undefined && null !== x ? x : y;',
+      'x !== null && undefined !== x ? x : y;',
+      'x === undefined || null === x ? y : x;',
+      'x === null || undefined === x ? y : x;',
+      'undefined !== x && null !== x ? x : y;',
+      'null !== x && undefined !== x ? x : y;',
+      'undefined === x || null === x ? y : x;',
+      'null === x || undefined === x ? y : x;',
+      'x != undefined && x != null ? x : y;',
+      'x == undefined || x == null ? y : x;',
+      'x != undefined && x !== null ? x : y;',
+      'x == undefined || x === null ? y : x;',
+      'x !== undefined && x != null ? x : y;',
+      'undefined != x ? x : y;',
+      'null != x ? x : y;',
+      'undefined == x ? y : x;',
+      'null == x ? y : x;',
+      'x != undefined ? x : y;',
+      'x != null ? x : y;',
+      'x == undefined  ? y : x;',
+      'x == null ? y : x;',
+    ].flatMap(code => [
+      {
+        code,
+        errors: [
+          {
+            column: 1,
+            endColumn: code.length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x ?? y;',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+      {
+        code: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]'),
+        errors: [
+          {
+            column: 1,
+            endColumn: code.replaceAll('x', 'x.z[1][this[this.o]]["3"][a.b.c]')
+              .length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x.z[1][this[this.o]]["3"][a.b.c] ?? y;',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+      {
+        code: code.replaceAll('y', '(z = y)'),
+        errors: [
+          {
+            column: 1,
+            endColumn: code.replaceAll('y', '(z = y)').length,
+            endLine: 1,
+            line: 1,
+            messageId: 'preferNullishOverTernary' as const,
+            suggestions: [
+              {
+                messageId: 'suggestNullish' as const,
+                output: 'x ?? (z = y);',
+              },
+            ],
+          },
+        ],
+        options: [{ ignoreTernaryTests: false }] as const,
+        output: null,
+      },
+    ]),
+
+    {
+      code: 'this != undefined ? this : y;',
+      errors: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 6,
-          line: 6,
-          messageId: 'preferNullishOverOr',
+          column: 1,
+          endColumn: 29,
+          endLine: 1,
+          line: 1,
+          messageId: 'preferNullishOverTernary' as const,
           suggestions: [
             {
-              messageId: 'suggestNullish',
-              output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a || b ?? c && d;
-      `,
+              messageId: 'suggestNullish' as const,
+              output: 'this ?? y;',
             },
           ],
         },
       ],
-      options: [{ ignoreMixedLogicalExpressions: false }],
-    })),
-    ...nullishTypeInvalidTest((nullish, type) => ({
-      code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && b || c || d;
+      options: [{ ignoreTernaryTests: false }] as const,
+      output: null,
+    },
+
+    ...[
+      `
+declare const x: string | undefined;
+x !== undefined ? x : y;
+      `,
+      `
+declare const x: string | undefined;
+undefined !== x ? x : y;
+      `,
+      `
+declare const x: string | undefined;
+x === undefined ? y : x;
+      `,
+      `
+declare const x: string | undefined;
+undefined === x ? y : x;
+      `,
+      `
+declare const x: string | null;
+x !== null ? x : y;
+      `,
+      `
+declare const x: string | null;
+null !== x ? x : y;
+      `,
+      `
+declare const x: string | null;
+x === null ? y : x;
+      `,
+      `
+declare const x: string | null;
+null === x ? y : x;
       `,
+    ].map(code => ({
+      code,
       errors: [
         {
-          column: 8,
-          endColumn: 10,
-          endLine: 6,
-          line: 6,
-          messageId: 'preferNullishOverOr',
+          column: 1,
+          endColumn: code.split('\n')[2].length,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferNullishOverTernary' as const,
           suggestions: [
             {
-              messageId: 'suggestNullish',
+              messageId: 'suggestNullish' as const,
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && (b ?? c) || d;
+${code.split('\n')[1]}
+x ?? y;
       `,
             },
           ],
         },
-        {
-          column: 13,
-          endColumn: 15,
-          endLine: 6,
-          line: 6,
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && b || c ?? d;
+      ],
+      options: [{ ignoreTernaryTests: false }] as const,
+      output: null,
+    })),
+
+    // noStrictNullCheck
+    {
+      code: `
+declare const x: string[] | null;
+if (x) {
+}
       `,
-            },
-          ],
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
         },
       ],
-      options: [{ ignoreMixedLogicalExpressions: false }],
-    })),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      output: null,
+    },
 
-    // should not false positive for functions inside conditional tests
+    // ignoreConditionalTests
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-if (() => x || 'foo') {}
+x || 'foo' ? null : null;
       `,
       errors: [
         {
-          column: 13,
-          endColumn: 15,
+          column: 3,
+          endColumn: 5,
           endLine: 3,
           line: 3,
           messageId: 'preferNullishOverOr',
@@ -564,23 +614,24 @@ if (() => x || 'foo') {}
               messageId: 'suggestNullish',
               output: `
 declare const x: ${type} | ${nullish};
-if (() => x ?? 'foo') {}
+x ?? 'foo' ? null : null;
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreConditionalTests: false }],
       output: null,
     })),
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
 declare const x: ${type} | ${nullish};
-if (function werid() { return x || 'foo' }) {}
+if (x || 'foo') {}
       `,
       errors: [
         {
-          column: 33,
-          endColumn: 35,
+          column: 7,
+          endColumn: 9,
           endLine: 3,
           line: 3,
           messageId: 'preferNullishOverOr',
@@ -589,340 +640,310 @@ if (function werid() { return x || 'foo' }) {}
               messageId: 'suggestNullish',
               output: `
 declare const x: ${type} | ${nullish};
-if (function werid() { return x ?? 'foo' }) {}
+if (x ?? 'foo') {}
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreConditionalTests: false }],
       output: null,
     })),
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1290
     ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type};
-declare const c: ${type};
-a || b || c;
+declare const x: ${type} | ${nullish};
+do {} while (x || 'foo')
       `,
       errors: [
         {
-          column: 3,
-          endColumn: 5,
-          endLine: 5,
-          line: 5,
+          column: 16,
+          endColumn: 18,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type};
-declare const c: ${type};
-(a ?? b) || c;
+declare const x: ${type} | ${nullish};
+do {} while (x ?? 'foo')
       `,
             },
           ],
         },
       ],
+      options: [{ ignoreConditionalTests: false }],
       output: null,
     })),
-    // default for missing option
-    {
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: string | undefined;
-x || y;
+declare const x: ${type} | ${nullish};
+for (;x || 'foo';) {}
       `,
       errors: [
         {
+          column: 9,
+          endColumn: 11,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: string | undefined;
-x ?? y;
+declare const x: ${type} | ${nullish};
+for (;x ?? 'foo';) {}
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: { bigint: true, boolean: true, number: true },
-        },
-      ],
+      options: [{ ignoreConditionalTests: false }],
       output: null,
-    },
-    {
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: number | undefined;
-x || y;
+declare const x: ${type} | ${nullish};
+while (x || 'foo') {}
       `,
       errors: [
         {
+          column: 10,
+          endColumn: 12,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: number | undefined;
-x ?? y;
+declare const x: ${type} | ${nullish};
+while (x ?? 'foo') {}
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: { bigint: true, boolean: true, string: true },
-        },
-      ],
+      options: [{ ignoreConditionalTests: false }],
       output: null,
-    },
-    {
+    })),
+
+    // ignoreMixedLogicalExpressions
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: boolean | undefined;
-x || y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+a || b && c;
       `,
       errors: [
         {
+          column: 3,
+          endColumn: 5,
+          endLine: 5,
+          line: 5,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: boolean | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+a ?? b && c;
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: { bigint: true, number: true, string: true },
-        },
-      ],
-      output: null,
-    },
-    {
+      options: [{ ignoreMixedLogicalExpressions: false }],
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: bigint | undefined;
-x || y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a || b || c && d;
       `,
       errors: [
         {
+          column: 3,
+          endColumn: 5,
+          endLine: 6,
+          line: 6,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: bigint | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+(a ?? b) || c && d;
       `,
             },
           ],
         },
-      ],
-      options: [
-        {
-          ignorePrimitives: { boolean: true, number: true, string: true },
-        },
-      ],
-      output: null,
-    },
-    // falsy
-    {
-      code: `
-declare const x: '' | undefined;
-x || y;
-      `,
-      errors: [
         {
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: '' | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a || b ?? c && d;
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: true,
-            string: false,
-          },
-        },
-      ],
-      output: null,
-    },
-    {
+      options: [{ ignoreMixedLogicalExpressions: false }],
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: \`\` | undefined;
-x || y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c || d;
       `,
       errors: [
         {
+          column: 8,
+          endColumn: 10,
+          endLine: 6,
+          line: 6,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: \`\` | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && (b ?? c) || d;
       `,
             },
           ],
         },
-      ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: true,
-            string: false,
-          },
-        },
-      ],
-      output: null,
-    },
-    {
-      code: `
-declare const x: 0 | undefined;
-x || y;
-      `,
-      errors: [
         {
+          column: 13,
+          endColumn: 15,
+          endLine: 6,
+          line: 6,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0 | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type} | ${nullish};
+declare const c: ${type} | ${nullish};
+declare const d: ${type} | ${nullish};
+a && b || c ?? d;
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: false,
-            string: true,
-          },
-        },
-      ],
-      output: null,
-    },
-    {
+      options: [{ ignoreMixedLogicalExpressions: false }],
+    })),
+
+    // should not false positive for functions inside conditional tests
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: 0n | undefined;
-x || y;
+declare const x: ${type} | ${nullish};
+if (() => x || 'foo') {}
       `,
       errors: [
         {
+          column: 13,
+          endColumn: 15,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0n | undefined;
-x ?? y;
+declare const x: ${type} | ${nullish};
+if (() => x ?? 'foo') {}
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: false,
-            boolean: true,
-            number: true,
-            string: true,
-          },
-        },
-      ],
       output: null,
-    },
-    {
+    })),
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: false | undefined;
-x || y;
+declare const x: ${type} | ${nullish};
+if (function werid() { return x || 'foo' }) {}
       `,
       errors: [
         {
+          column: 33,
+          endColumn: 35,
+          endLine: 3,
+          line: 3,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: false | undefined;
-x ?? y;
+declare const x: ${type} | ${nullish};
+if (function werid() { return x ?? 'foo' }) {}
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: false,
-            number: true,
-            string: true,
-          },
-        },
-      ],
       output: null,
-    },
-    // truthy
-    {
+    })),
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1290
+    ...nullishTypeInvalidTest((nullish, type) => ({
       code: `
-declare const x: 'a' | undefined;
-x || y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type};
+declare const c: ${type};
+a || b || c;
       `,
       errors: [
         {
+          column: 3,
+          endColumn: 5,
+          endLine: 5,
+          line: 5,
           messageId: 'preferNullishOverOr',
           suggestions: [
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | undefined;
-x ?? y;
+declare const a: ${type} | ${nullish};
+declare const b: ${type};
+declare const c: ${type};
+(a ?? b) || c;
       `,
             },
           ],
         },
       ],
-      options: [
-        {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: true,
-            string: false,
-          },
-        },
-      ],
       output: null,
-    },
+    })),
+    // default for missing option
     {
       code: `
-declare const x: \`hello\${'string'}\` | undefined;
+declare const x: string | undefined;
 x || y;
       `,
       errors: [
@@ -932,7 +953,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: \`hello\${'string'}\` | undefined;
+declare const x: string | undefined;
 x ?? y;
       `,
             },
@@ -941,19 +962,14 @@ x ?? y;
       ],
       options: [
         {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: true,
-            string: false,
-          },
+          ignorePrimitives: { bigint: true, boolean: true, number: true },
         },
       ],
       output: null,
     },
     {
       code: `
-declare const x: 1 | undefined;
+declare const x: number | undefined;
 x || y;
       `,
       errors: [
@@ -963,7 +979,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1 | undefined;
+declare const x: number | undefined;
 x ?? y;
       `,
             },
@@ -972,19 +988,14 @@ x ?? y;
       ],
       options: [
         {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: true,
-            number: false,
-            string: true,
-          },
+          ignorePrimitives: { bigint: true, boolean: true, string: true },
         },
       ],
       output: null,
     },
     {
       code: `
-declare const x: 1n | undefined;
+declare const x: boolean | undefined;
 x || y;
       `,
       errors: [
@@ -994,7 +1005,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1n | undefined;
+declare const x: boolean | undefined;
 x ?? y;
       `,
             },
@@ -1003,19 +1014,14 @@ x ?? y;
       ],
       options: [
         {
-          ignorePrimitives: {
-            bigint: false,
-            boolean: true,
-            number: true,
-            string: true,
-          },
+          ignorePrimitives: { bigint: true, number: true, string: true },
         },
       ],
       output: null,
     },
     {
       code: `
-declare const x: true | undefined;
+declare const x: bigint | undefined;
 x || y;
       `,
       errors: [
@@ -1025,7 +1031,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: true | undefined;
+declare const x: bigint | undefined;
 x ?? y;
       `,
             },
@@ -1034,20 +1040,15 @@ x ?? y;
       ],
       options: [
         {
-          ignorePrimitives: {
-            bigint: true,
-            boolean: false,
-            number: true,
-            string: true,
-          },
+          ignorePrimitives: { boolean: true, number: true, string: true },
         },
       ],
       output: null,
     },
-    // Unions of same primitive
+    // falsy
     {
       code: `
-declare const x: 'a' | 'b' | undefined;
+declare const x: '' | undefined;
 x || y;
       `,
       errors: [
@@ -1057,7 +1058,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | 'b' | undefined;
+declare const x: '' | undefined;
 x ?? y;
       `,
             },
@@ -1078,7 +1079,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: 'a' | \`b\` | undefined;
+declare const x: \`\` | undefined;
 x || y;
       `,
       errors: [
@@ -1088,7 +1089,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 'a' | \`b\` | undefined;
+declare const x: \`\` | undefined;
 x ?? y;
       `,
             },
@@ -1109,7 +1110,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: 0 | 1 | undefined;
+declare const x: 0 | undefined;
 x || y;
       `,
       errors: [
@@ -1119,7 +1120,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0 | 1 | undefined;
+declare const x: 0 | undefined;
 x ?? y;
       `,
             },
@@ -1140,7 +1141,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: 1 | 2 | 3 | undefined;
+declare const x: 0n | undefined;
 x || y;
       `,
       errors: [
@@ -1150,7 +1151,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1 | 2 | 3 | undefined;
+declare const x: 0n | undefined;
 x ?? y;
       `,
             },
@@ -1160,9 +1161,9 @@ x ?? y;
       options: [
         {
           ignorePrimitives: {
-            bigint: true,
+            bigint: false,
             boolean: true,
-            number: false,
+            number: true,
             string: true,
           },
         },
@@ -1171,7 +1172,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: 0n | 1n | undefined;
+declare const x: false | undefined;
 x || y;
       `,
       errors: [
@@ -1181,7 +1182,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0n | 1n | undefined;
+declare const x: false | undefined;
 x ?? y;
       `,
             },
@@ -1191,8 +1192,8 @@ x ?? y;
       options: [
         {
           ignorePrimitives: {
-            bigint: false,
-            boolean: true,
+            bigint: true,
+            boolean: false,
             number: true,
             string: true,
           },
@@ -1200,9 +1201,10 @@ x ?? y;
       ],
       output: null,
     },
+    // truthy
     {
       code: `
-declare const x: 1n | 2n | 3n | undefined;
+declare const x: 'a' | undefined;
 x || y;
       `,
       errors: [
@@ -1212,7 +1214,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 1n | 2n | 3n | undefined;
+declare const x: 'a' | undefined;
 x ?? y;
       `,
             },
@@ -1222,10 +1224,10 @@ x ?? y;
       options: [
         {
           ignorePrimitives: {
-            bigint: false,
+            bigint: true,
             boolean: true,
             number: true,
-            string: true,
+            string: false,
           },
         },
       ],
@@ -1233,7 +1235,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: true | false | undefined;
+declare const x: \`hello\${'string'}\` | undefined;
 x || y;
       `,
       errors: [
@@ -1243,7 +1245,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: true | false | undefined;
+declare const x: \`hello\${'string'}\` | undefined;
 x ?? y;
       `,
             },
@@ -1254,18 +1256,17 @@ x ?? y;
         {
           ignorePrimitives: {
             bigint: true,
-            boolean: false,
+            boolean: true,
             number: true,
-            string: true,
+            string: false,
           },
         },
       ],
       output: null,
     },
-    // Mixed unions
     {
       code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
+declare const x: 1 | undefined;
 x || y;
       `,
       errors: [
@@ -1275,7 +1276,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
+declare const x: 1 | undefined;
 x ?? y;
       `,
             },
@@ -1285,7 +1286,7 @@ x ?? y;
       options: [
         {
           ignorePrimitives: {
-            bigint: false,
+            bigint: true,
             boolean: true,
             number: false,
             string: true,
@@ -1296,7 +1297,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: true | false | null | undefined;
+declare const x: 1n | undefined;
 x || y;
       `,
       errors: [
@@ -1306,7 +1307,7 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: true | false | null | undefined;
+declare const x: 1n | undefined;
 x ?? y;
       `,
             },
@@ -1316,8 +1317,8 @@ x ?? y;
       options: [
         {
           ignorePrimitives: {
-            bigint: true,
-            boolean: false,
+            bigint: false,
+            boolean: true,
             number: true,
             string: true,
           },
@@ -1327,7 +1328,7 @@ x ?? y;
     },
     {
       code: `
-declare const x: null;
+declare const x: true | undefined;
 x || y;
       `,
       errors: [
@@ -1337,39 +1338,30 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-declare const x: null;
+declare const x: true | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-      output: null,
-    },
-    {
-      code: `
-const x = undefined;
-x || y;
-      `,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-const x = undefined;
-x ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            bigint: true,
+            boolean: false,
+            number: true,
+            string: true,
+          },
         },
       ],
       output: null,
     },
+    // Unions of same primitive
     {
       code: `
-null || y;
+declare const x: 'a' | 'b' | undefined;
+x || y;
       `,
       errors: [
         {
@@ -1378,41 +1370,28 @@ null || y;
             {
               messageId: 'suggestNullish',
               output: `
-null ?? y;
+declare const x: 'a' | 'b' | undefined;
+x ?? y;
       `,
             },
           ],
         },
       ],
-      output: null,
-    },
-    {
-      code: `
-undefined || y;
-      `,
-      errors: [
+      options: [
         {
-          messageId: 'preferNullishOverOr',
-          suggestions: [
-            {
-              messageId: 'suggestNullish',
-              output: `
-undefined ?? y;
-      `,
-            },
-          ],
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
         },
       ],
       output: null,
     },
     {
       code: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum | undefined;
+declare const x: 'a' | \`b\` | undefined;
 x || y;
       `,
       errors: [
@@ -1422,28 +1401,28 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum | undefined;
+declare const x: 'a' | \`b\` | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: true,
+            string: false,
+          },
+        },
+      ],
       output: null,
     },
     {
       code: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum.A | Enum.B | undefined;
+declare const x: 0 | 1 | undefined;
 x || y;
       `,
       errors: [
@@ -1453,28 +1432,28 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-enum Enum {
-  A = 0,
-  B = 1,
-  C = 2,
-}
-declare const x: Enum.A | Enum.B | undefined;
+declare const x: 0 | 1 | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
+          },
+        },
+      ],
       output: null,
     },
     {
       code: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum | undefined;
+declare const x: 1 | 2 | 3 | undefined;
 x || y;
       `,
       errors: [
@@ -1484,28 +1463,28 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum | undefined;
+declare const x: 1 | 2 | 3 | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: true,
+            boolean: true,
+            number: false,
+            string: true,
+          },
+        },
+      ],
       output: null,
     },
     {
       code: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum.A | Enum.B | undefined;
+declare const x: 0n | 1n | undefined;
 x || y;
       `,
       errors: [
@@ -1515,260 +1494,229 @@ x || y;
             {
               messageId: 'suggestNullish',
               output: `
-enum Enum {
-  A = 'a',
-  B = 'b',
-  C = 'c',
-}
-declare const x: Enum.A | Enum.B | undefined;
+declare const x: 0n | 1n | undefined;
 x ?? y;
       `,
             },
           ],
         },
       ],
-      output: null,
-    },
-  ],
-  valid: [
-    ...typeValidTest(
-      type => `
-declare const x: ${type};
-x || 'foo';
-      `,
-    ),
-    ...nullishTypeValidTest(
-      (nullish, type) => `
-declare const x: ${type} | ${nullish};
-x ?? 'foo';
-      `,
-    ),
-
-    {
-      code: 'x !== undefined && x !== null ? x : y;',
-      options: [{ ignoreTernaryTests: true }],
-    },
-
-    ...[
-      'x !== undefined && x !== null ? "foo" : "bar";',
-      'x !== null && x !== undefined && x !== 5 ? x : y',
-      'x === null || x === undefined || x === 5 ? x : y',
-      'x === undefined && x !== null ? x : y;',
-      'x === undefined && x === null ? x : y;',
-      'x !== undefined && x === null ? x : y;',
-      'x === undefined || x !== null ? x : y;',
-      'x === undefined || x === null ? x : y;',
-      'x !== undefined || x === null ? x : y;',
-      'x !== undefined || x === null ? y : x;',
-      'x === null || x === null ? y : x;',
-      'x === undefined || x === undefined ? y : x;',
-      'x == null ? x : y;',
-      'undefined == null ? x : y;',
-      'undefined != z ? x : y;',
-      'x == undefined ? x : y;',
-      'x != null ? y : x;',
-      'x != undefined ? y : x;',
-      'null == x ? x : y;',
-      'undefined == x ? x : y;',
-      'null != x ? y : x;',
-      'undefined != x ? y : x;',
-      `
-declare const x: string;
-x === null ? x : y;
-      `,
-      `
-declare const x: string | undefined;
-x === null ? x : y;
-      `,
-      `
-declare const x: string | null;
-x === undefined ? x : y;
-      `,
-      `
-declare const x: string | undefined | null;
-x !== undefined ? x : y;
-      `,
-      `
-declare const x: string | undefined | null;
-x !== null ? x : y;
-      `,
-      `
-declare const x: string | null | any;
-x === null ? x : y;
-      `,
-      `
-declare const x: string | null | unknown;
-x === null ? x : y;
-      `,
-    ].map(code => ({
-      code,
-      options: [{ ignoreTernaryTests: false }] as const,
-    })),
-
-    // ignoreConditionalTests
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-x || 'foo' ? null : null;
-      `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-if (x || 'foo') {}
-      `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-do {} while (x || 'foo')
-      `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-for (;x || 'foo';) {}
-      `,
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const x: ${type} | ${nullish};
-while (x || 'foo') {}
-      `,
-    })),
-
-    // ignoreMixedLogicalExpressions
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-a || b && c;
-      `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a || b || c && d;
-      `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
-    })),
-    ...nullishTypeValidTest((nullish, type) => ({
-      code: `
-declare const a: ${type} | ${nullish};
-declare const b: ${type} | ${nullish};
-declare const c: ${type} | ${nullish};
-declare const d: ${type} | ${nullish};
-a && b || c || d;
-      `,
-      options: [{ ignoreMixedLogicalExpressions: true }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: ${type} | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: { [type]: true } }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: ${type} | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: true }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: (${type} & { __brand?: any }) | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: { [type]: true } }],
-    })),
-    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
-      code: `
-declare const x: (${type} & { __brand?: any }) | undefined;
-x || y;
-      `,
-      options: [{ ignorePrimitives: true }],
-    })),
-    `
-      declare const x: any;
-      declare const y: number;
-      x || y;
-    `,
-    `
-      declare const x: unknown;
-      declare const y: number;
-      x || y;
-    `,
-    `
-      declare const x: never;
-      declare const y: number;
-      x || y;
-    `,
+      options: [
+        {
+          ignorePrimitives: {
+            bigint: false,
+            boolean: true,
+            number: true,
+            string: true,
+          },
+        },
+      ],
+      output: null,
+    },
     {
       code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
+declare const x: 1n | 2n | 3n | undefined;
 x || y;
       `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: 1n | 2n | 3n | undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           ignorePrimitives: {
-            bigint: true,
+            bigint: false,
             boolean: true,
-            number: false,
+            number: true,
             string: true,
           },
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 0 | 1 | 0n | 1n | undefined;
+declare const x: true | false | undefined;
 x || y;
       `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: true | false | undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           ignorePrimitives: {
-            bigint: false,
-            boolean: true,
+            bigint: true,
+            boolean: false,
             number: true,
             string: true,
           },
         },
       ],
+      output: null,
     },
+    // Mixed unions
     {
       code: `
-declare const x: 0 | 'foo' | undefined;
+declare const x: 0 | 1 | 0n | 1n | undefined;
 x || y;
       `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: 0 | 1 | 0n | 1n | undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           ignorePrimitives: {
-            number: true,
+            bigint: false,
+            boolean: true,
+            number: false,
             string: true,
           },
         },
       ],
+      output: null,
     },
     {
       code: `
-declare const x: 0 | 'foo' | undefined;
+declare const x: true | false | null | undefined;
 x || y;
       `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: true | false | null | undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           ignorePrimitives: {
+            bigint: true,
+            boolean: false,
             number: true,
-            string: false,
+            string: true,
           },
         },
       ],
+      output: null,
+    },
+    {
+      code: `
+declare const x: null;
+x || y;
+      `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+declare const x: null;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+const x = undefined;
+x || y;
+      `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+const x = undefined;
+x ?? y;
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+null || y;
+      `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+null ?? y;
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
+    {
+      code: `
+undefined || y;
+      `,
+      errors: [
+        {
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+undefined ?? y;
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
@@ -1780,13 +1728,26 @@ enum Enum {
 declare const x: Enum | undefined;
 x || y;
       `,
-      options: [
+      errors: [
         {
-          ignorePrimitives: {
-            number: true,
-          },
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum | undefined;
+x ?? y;
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -1798,13 +1759,26 @@ enum Enum {
 declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      options: [
+      errors: [
         {
-          ignorePrimitives: {
-            number: true,
-          },
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+enum Enum {
+  A = 0,
+  B = 1,
+  C = 2,
+}
+declare const x: Enum.A | Enum.B | undefined;
+x ?? y;
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -1816,13 +1790,26 @@ enum Enum {
 declare const x: Enum | undefined;
 x || y;
       `,
-      options: [
+      errors: [
         {
-          ignorePrimitives: {
-            string: true,
-          },
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum | undefined;
+x ?? y;
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
     {
       code: `
@@ -1834,13 +1821,26 @@ enum Enum {
 declare const x: Enum.A | Enum.B | undefined;
 x || y;
       `,
-      options: [
+      errors: [
         {
-          ignorePrimitives: {
-            string: true,
-          },
+          messageId: 'preferNullishOverOr',
+          suggestions: [
+            {
+              messageId: 'suggestNullish',
+              output: `
+enum Enum {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+declare const x: Enum.A | Enum.B | undefined;
+x ?? y;
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts b/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
index 5a7429331370..518453c83e02 100644
--- a/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-promise-reject-errors.test.ts
@@ -15,6 +15,258 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-promise-reject-errors', rule, {
+  valid: [
+    'Promise.resolve(5);',
+    {
+      code: 'Promise.reject();',
+      options: [
+        {
+          allowEmptyReject: true,
+        },
+      ],
+    },
+    'Promise.reject(new Error());',
+    'Promise.reject(new TypeError());',
+    "Promise.reject(new Error('foo'));",
+    `
+      class CustomError extends Error {}
+      Promise.reject(new CustomError());
+    `,
+    `
+      declare const foo: () => { err: SyntaxError };
+      Promise.reject(foo().err);
+    `,
+    `
+      declare const foo: () => Promise<Error>;
+      Promise.reject(await foo());
+    `,
+    'Promise.reject((foo = new Error()));',
+    `
+      const foo = Promise;
+      foo.reject(new Error());
+    `,
+    "Promise['reject'](new Error());",
+    'Promise.reject(true && new Error());',
+    `
+      const foo = false;
+      Promise.reject(false || new Error());
+    `,
+    `
+      declare const foo: Readonly<Error>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> | Readonly<TypeError>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> & Readonly<TypeError>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error> & { foo: 'bar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Readonly<Error>>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<Readonly<Readonly<Error>>>;
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Readonly<
+        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
+          fooBar: 'barFoo';
+        }
+      > & { barFoo: 'fooBar' };
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo:
+        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
+        | Readonly<Error>;
+      Promise.reject(foo);
+    `,
+    `
+      type Wrapper<T> = { foo: Readonly<T>[] };
+      declare const foo: Wrapper<Error>['foo'][5];
+      Promise.reject(foo);
+    `,
+    `
+      declare const foo: Error[];
+      Promise.reject(foo[5]);
+    `,
+    `
+      declare const foo: ReadonlyArray<Error>;
+      Promise.reject(foo[5]);
+    `,
+    `
+      declare const foo: [Error];
+      Promise.reject(foo[0]);
+    `,
+
+    `
+      new Promise(function (resolve, reject) {
+        resolve(5);
+      });
+    `,
+    `
+      new Promise(function (resolve, reject) {
+        reject(new Error());
+      });
+    `,
+    `
+      new Promise((resolve, reject) => {
+        reject(new Error());
+      });
+    `,
+    'new Promise((resolve, reject) => reject(new Error()));',
+    {
+      code: `
+        new Promise(function (resolve, reject) {
+          reject();
+        });
+      `,
+      options: [
+        {
+          allowEmptyReject: true,
+        },
+      ],
+    },
+    'new Promise((yes, no) => no(new Error()));',
+    'new Promise();',
+    'new Promise(5);',
+    'new Promise((resolve, { apply }) => {});',
+    'new Promise((resolve, reject) => {});',
+    'new Promise((resolve, reject) => reject);',
+    `
+      class CustomError extends Error {}
+      new Promise(function (resolve, reject) {
+        reject(new CustomError());
+      });
+    `,
+    `
+      declare const foo: () => { err: SyntaxError };
+      new Promise(function (resolve, reject) {
+        reject(foo().err);
+      });
+    `,
+    'new Promise((resolve, reject) => reject((foo = new Error())));',
+    `
+      new Foo((resolve, reject) => reject(5));
+    `,
+    `
+      class Foo {
+        constructor(
+          executor: (resolve: () => void, reject: (reason?: any) => void) => void,
+        ): Promise<any> {}
+      }
+      new Foo((resolve, reject) => reject(5));
+    `,
+    `
+      new Promise((resolve, reject) => {
+        return function (reject) {
+          reject(5);
+        };
+      });
+    `,
+    'new Promise((resolve, reject) => resolve(5, reject));',
+    `
+      class C {
+        #error: Error;
+        foo() {
+          Promise.reject(this.#error);
+        }
+      }
+    `,
+    `
+      const foo = Promise;
+      new foo((resolve, reject) => reject(new Error()));
+    `,
+    `
+      declare const foo: Readonly<Error>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> | Readonly<TypeError>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> & Readonly<TypeError>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error> & { foo: 'bar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Readonly<Error>>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<Readonly<Readonly<Error>>>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Readonly<
+        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
+          fooBar: 'barFoo';
+        }
+      > & { barFoo: 'fooBar' };
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo:
+        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
+        | Readonly<Error>;
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      type Wrapper<T> = { foo: Readonly<T>[] };
+      declare const foo: Wrapper<Error>['foo'][5];
+      new Promise((resolve, reject) => reject(foo));
+    `,
+    `
+      declare const foo: Error[];
+      new Promise((resolve, reject) => reject(foo[5]));
+    `,
+    `
+      declare const foo: ReadonlyArray<Error>;
+      new Promise((resolve, reject) => reject(foo[5]));
+    `,
+    `
+      declare const foo: [Error];
+      new Promise((resolve, reject) => reject(foo[0]));
+    `,
+    `
+      class Foo extends Promise<number> {}
+      Foo.reject(new Error());
+    `,
+    `
+      class Foo extends Promise<number> {}
+      new Foo((resolve, reject) => reject(new Error()));
+    `,
+    `
+      declare const someRandomCall: {
+        reject(arg: any): void;
+      };
+      someRandomCall.reject(5);
+    `,
+    `
+      declare const foo: PromiseConstructor;
+      foo.reject(new Error());
+    `,
+  ],
   invalid: [
     {
       code: 'Promise.reject(5);',
@@ -1183,256 +1435,4 @@ Bar.reject(5);
       ],
     },
   ],
-  valid: [
-    'Promise.resolve(5);',
-    {
-      code: 'Promise.reject();',
-      options: [
-        {
-          allowEmptyReject: true,
-        },
-      ],
-    },
-    'Promise.reject(new Error());',
-    'Promise.reject(new TypeError());',
-    "Promise.reject(new Error('foo'));",
-    `
-      class CustomError extends Error {}
-      Promise.reject(new CustomError());
-    `,
-    `
-      declare const foo: () => { err: SyntaxError };
-      Promise.reject(foo().err);
-    `,
-    `
-      declare const foo: () => Promise<Error>;
-      Promise.reject(await foo());
-    `,
-    'Promise.reject((foo = new Error()));',
-    `
-      const foo = Promise;
-      foo.reject(new Error());
-    `,
-    "Promise['reject'](new Error());",
-    'Promise.reject(true && new Error());',
-    `
-      const foo = false;
-      Promise.reject(false || new Error());
-    `,
-    `
-      declare const foo: Readonly<Error>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> | Readonly<TypeError>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> & Readonly<TypeError>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error> & { foo: 'bar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Readonly<Error>>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<Readonly<Readonly<Error>>>;
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Readonly<
-        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
-          fooBar: 'barFoo';
-        }
-      > & { barFoo: 'fooBar' };
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo:
-        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
-        | Readonly<Error>;
-      Promise.reject(foo);
-    `,
-    `
-      type Wrapper<T> = { foo: Readonly<T>[] };
-      declare const foo: Wrapper<Error>['foo'][5];
-      Promise.reject(foo);
-    `,
-    `
-      declare const foo: Error[];
-      Promise.reject(foo[5]);
-    `,
-    `
-      declare const foo: ReadonlyArray<Error>;
-      Promise.reject(foo[5]);
-    `,
-    `
-      declare const foo: [Error];
-      Promise.reject(foo[0]);
-    `,
-
-    `
-      new Promise(function (resolve, reject) {
-        resolve(5);
-      });
-    `,
-    `
-      new Promise(function (resolve, reject) {
-        reject(new Error());
-      });
-    `,
-    `
-      new Promise((resolve, reject) => {
-        reject(new Error());
-      });
-    `,
-    'new Promise((resolve, reject) => reject(new Error()));',
-    {
-      code: `
-        new Promise(function (resolve, reject) {
-          reject();
-        });
-      `,
-      options: [
-        {
-          allowEmptyReject: true,
-        },
-      ],
-    },
-    'new Promise((yes, no) => no(new Error()));',
-    'new Promise();',
-    'new Promise(5);',
-    'new Promise((resolve, { apply }) => {});',
-    'new Promise((resolve, reject) => {});',
-    'new Promise((resolve, reject) => reject);',
-    `
-      class CustomError extends Error {}
-      new Promise(function (resolve, reject) {
-        reject(new CustomError());
-      });
-    `,
-    `
-      declare const foo: () => { err: SyntaxError };
-      new Promise(function (resolve, reject) {
-        reject(foo().err);
-      });
-    `,
-    'new Promise((resolve, reject) => reject((foo = new Error())));',
-    `
-      new Foo((resolve, reject) => reject(5));
-    `,
-    `
-      class Foo {
-        constructor(
-          executor: (resolve: () => void, reject: (reason?: any) => void) => void,
-        ): Promise<any> {}
-      }
-      new Foo((resolve, reject) => reject(5));
-    `,
-    `
-      new Promise((resolve, reject) => {
-        return function (reject) {
-          reject(5);
-        };
-      });
-    `,
-    'new Promise((resolve, reject) => resolve(5, reject));',
-    `
-      class C {
-        #error: Error;
-        foo() {
-          Promise.reject(this.#error);
-        }
-      }
-    `,
-    `
-      const foo = Promise;
-      new foo((resolve, reject) => reject(new Error()));
-    `,
-    `
-      declare const foo: Readonly<Error>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> | Readonly<TypeError>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> & Readonly<TypeError>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error> & { foo: 'bar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Error & { bar: 'foo' }> & { foo: 'bar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Readonly<Error>>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<Readonly<Readonly<Error>>>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Readonly<
-        Readonly<Readonly<Error & { bar: 'foo' }> & { foo: 'bar' }> & {
-          fooBar: 'barFoo';
-        }
-      > & { barFoo: 'fooBar' };
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo:
-        | Readonly<Readonly<Error> | Readonly<TypeError & string>>
-        | Readonly<Error>;
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      type Wrapper<T> = { foo: Readonly<T>[] };
-      declare const foo: Wrapper<Error>['foo'][5];
-      new Promise((resolve, reject) => reject(foo));
-    `,
-    `
-      declare const foo: Error[];
-      new Promise((resolve, reject) => reject(foo[5]));
-    `,
-    `
-      declare const foo: ReadonlyArray<Error>;
-      new Promise((resolve, reject) => reject(foo[5]));
-    `,
-    `
-      declare const foo: [Error];
-      new Promise((resolve, reject) => reject(foo[0]));
-    `,
-    `
-      class Foo extends Promise<number> {}
-      Foo.reject(new Error());
-    `,
-    `
-      class Foo extends Promise<number> {}
-      new Foo((resolve, reject) => reject(new Error()));
-    `,
-    `
-      declare const someRandomCall: {
-        reject(arg: any): void;
-      };
-      someRandomCall.reject(5);
-    `,
-    `
-      declare const foo: PromiseConstructor;
-      foo.reject(new Error());
-    `,
-  ],
 });
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 75a53b1b94fe..032de8fd72d7 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
@@ -69,166 +69,199 @@ const weirdIntersections = [
 ];
 
 ruleTester.run('prefer-readonly-parameter-types', rule, {
-  invalid: [
+  valid: [
+    'function foo() {}',
+
+    // primitives
+    ...primitives.map(type => `function foo(arg: ${type}) {}`),
+    `
+      const symb = Symbol('a');
+      function foo(arg: typeof symb) {}
+    `,
+    `
+      enum Enum {
+        a,
+        b,
+      }
+      function foo(arg: Enum) {}
+    `,
+
     // arrays
-    // Removing readonly causes duplicates
-    ...dedupeTestCases(
-      arrays.map<InvalidTestCase<MessageIds, Options>>(baseType => {
-        const type = baseType
-          .replaceAll('readonly ', '')
-          .replaceAll(/Readonly<(.+?)>/g, '$1')
-          .replaceAll('ReadonlyArray', 'Array');
-        return {
-          code: `function foo(arg: ${type}) {}`,
-          errors: [
-            {
-              column: 14,
-              endColumn: 19 + type.length,
-              messageId: 'shouldBeReadonly',
-            },
-          ],
-        };
-      }),
-    ),
+    ...arrays.map(type => `function foo(arg: ${type}) {}`),
     // nested arrays
-    {
-      code: 'function foo(arg: readonly string[][]) {}',
-      errors: [
-        {
-          column: 14,
-          endColumn: 38,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
-    },
-    {
-      code: 'function foo(arg: Readonly<string[][]>) {}',
-      errors: [
-        {
-          column: 14,
-          endColumn: 39,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
-    },
-    {
-      code: 'function foo(arg: ReadonlyArray<Array<string>>) {}',
-      errors: [
-        {
-          column: 14,
-          endColumn: 47,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
-    },
+    'function foo(arg: readonly (readonly string[])[]) {}',
+    'function foo(arg: Readonly<Readonly<string[]>[]>) {}',
+    'function foo(arg: ReadonlyArray<ReadonlyArray<string>>) {}',
+
+    // functions
+    'function foo(arg: () => void) {}',
+
+    // unions
+    'function foo(arg: string | null) {}',
+    'function foo(arg: string | ReadonlyArray<string>) {}',
+    'function foo(arg: string | (() => void)) {}',
+    'function foo(arg: ReadonlyArray<string> | ReadonlyArray<number>) {}',
 
     // objects
-    ...objects.map<InvalidTestCase<MessageIds, Options>>(type => {
-      return {
-        code: `function foo(arg: ${type}) {}`,
-        errors: [
-          {
-            column: 14,
-            endColumn: 19 + type.length,
-            messageId: 'shouldBeReadonly',
-          },
-        ],
+    ...objects.map(type => `function foo(arg: Readonly<${type}>) {}`),
+    `
+      function foo(arg: {
+        readonly foo: {
+          readonly bar: string;
+        };
+      }) {}
+    `,
+    `
+      function foo(arg: { readonly [k: string]: string }) {}
+    `,
+    `
+      function foo(arg: { readonly [k: number]: string }) {}
+    `,
+    `
+      interface Empty {}
+      function foo(arg: Empty) {}
+    `,
+
+    // weird other cases
+    ...weirdIntersections.map(code => code),
+    `
+      interface Test extends ReadonlyArray<string> {
+        readonly property: boolean;
+      }
+      function foo(arg: Readonly<Test>) {}
+    `,
+    `
+      type Test = readonly string[] & {
+        readonly property: boolean;
       };
-    }),
+      function foo(arg: Readonly<Test>) {}
+    `,
+    `
+      type Test = string & number;
+      function foo(arg: Test) {}
+    `,
+
+    // declaration merging
+    `
+      class Foo {
+        readonly bang = 1;
+      }
+      interface Foo {
+        readonly prop: string;
+      }
+      interface Foo {
+        readonly prop2: string;
+      }
+      function foo(arg: Foo) {}
+    `,
+    // method made readonly via Readonly<T>
+    `
+      class Foo {
+        method() {}
+      }
+      function foo(arg: Readonly<Foo>) {}
+    `,
+    // immutable methods
+    `
+      type MyType = Readonly<{
+        prop: string;
+        method(): string;
+      }>;
+      function foo(arg: MyType) {}
+    `,
+    `
+      type MyType = {
+        readonly prop: string;
+        readonly method: () => string;
+      };
+      function bar(arg: MyType) {}
+    `,
+    // PrivateIdentifier is exempt from this rule
     {
       code: `
-        function foo(arg: {
-          readonly foo: {
-            bar: string;
-          };
-        }) {}
+        class Foo {
+          #privateField = 'foo';
+          #privateMember() {}
+        }
+        function foo(arg: Foo) {}
       `,
-      errors: [
-        {
-          column: 22,
-          endColumn: 10,
-          endLine: 6,
-          line: 2,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
     },
-    // object index signatures
     {
       code: `
-        function foo(arg: { [key: string]: string }) {}
+        class HasText {
+          readonly #text: string;
+        }
+
+        export function onDone(task: HasText): void {}
       `,
-      errors: [
+    },
+    // methods treated as readonly
+    {
+      code: `
+        type MyType = {
+          readonly prop: string;
+          method(): string;
+        };
+        function foo(arg: MyType) {}
+      `,
+      options: [
         {
-          column: 22,
-          endColumn: 52,
-          endLine: 2,
-          line: 2,
-          messageId: 'shouldBeReadonly',
+          treatMethodsAsReadonly: true,
         },
       ],
     },
     {
       code: `
-        function foo(arg: { [key: number]: string }) {}
+        class Foo {
+          method() {}
+        }
+        function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 52,
-          endLine: 2,
-          line: 2,
-          messageId: 'shouldBeReadonly',
+          treatMethodsAsReadonly: true,
         },
       ],
     },
-
-    // weird intersections
-    ...weirdIntersections.map<InvalidTestCase<MessageIds, Options>>(
-      baseCode => {
-        const code = baseCode.replaceAll('readonly ', '');
-        return {
-          code,
-          errors: [{ messageId: 'shouldBeReadonly' }],
-        };
-      },
-    ),
     {
       code: `
-        interface Test extends Array<string> {
-          readonly property: boolean;
+        interface Foo {
+          method(): void;
         }
-        function foo(arg: Test) {}
+        function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 31,
-          endLine: 5,
-          line: 5,
-          messageId: 'shouldBeReadonly',
+          treatMethodsAsReadonly: true,
         },
       ],
     },
+    // ReadonlySet and ReadonlyMap are seen as readonly when methods are treated as readonly
     {
       code: `
-        interface Test extends Array<string> {
-          property: boolean;
-        }
-        function foo(arg: Test) {}
+        function foo(arg: ReadonlySet<string>) {}
+        function bar(arg: ReadonlyMap<string, string>) {}
       `,
-      errors: [
+      options: [
         {
-          column: 22,
-          endColumn: 31,
-          endLine: 5,
-          line: 5,
-          messageId: 'shouldBeReadonly',
+          treatMethodsAsReadonly: true,
         },
       ],
     },
-
     // parameter properties should work fine
+    {
+      code: `
+        class Foo {
+          constructor(
+            private arg1: readonly string[],
+            public arg2: readonly string[],
+            protected arg3: readonly string[],
+            readonly arg4: readonly string[],
+          ) {}
+        }
+      `,
+      options: [{ checkParameterProperties: true }],
+    },
     {
       code: `
         class Foo {
@@ -240,708 +273,627 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
           ) {}
         }
       `,
-      errors: [
+      options: [{ checkParameterProperties: false }],
+    },
+
+    // type functions
+    `
+      interface Foo {
+        (arg: readonly string[]): void;
+      }
+    `, // TSCallSignatureDeclaration
+    `
+      interface Foo {
+        new (arg: readonly string[]): void;
+      }
+    `, // TSConstructSignatureDeclaration
+    noFormat`class Foo { 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
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
+    // directly recursive interface
+    `
+      interface Foo {
+        readonly prop: Foo;
+      }
+      function foo(arg: Foo) {}
+    `,
+
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3396
+    // directly recursive union type
+    `
+      type MyType = string | readonly MyType[];
+
+      function foo<A extends MyType[]>(a: A): MyType[] {
+        return [];
+      }
+    `,
+    // indirectly recursive
+    `
+      interface Foo {
+        readonly prop: Bar;
+      }
+      interface Bar {
+        readonly prop: Foo;
+      }
+      function foo(arg: Foo) {}
+    `,
+    `
+      interface Foo {
+        prop: Readonly<Bar>;
+      }
+      interface Bar {
+        prop: Readonly<Foo>;
+      }
+      function foo(arg: Readonly<Foo>) {}
+    `,
+    `
+      const sym = Symbol('sym');
+
+      interface WithSymbol {
+        [sym]: number;
+      }
+
+      const willNotCrash = (foo: Readonly<WithSymbol>) => {};
+    `,
+    {
+      code: `
+        type Callback<T> = (options: T) => void;
+
+        declare const acceptsCallback: <T>(callback: Callback<T>) => void;
+
+        interface CallbackOptions {
+          prop: string;
+        }
+
+        acceptsCallback<CallbackOptions>(options => {});
+      `,
+      options: [
         {
-          column: 21,
-          endColumn: 35,
-          endLine: 4,
-          line: 4,
-          messageId: 'shouldBeReadonly',
+          ignoreInferredTypes: true,
         },
+      ],
+    },
+    {
+      code: `
+        interface Obj {
+          readonly [K: string]: Obj;
+        }
+
+        function foo(event: Obj): void {}
+      `,
+      name: 'circular readonly types (Bug: #4476)',
+      options: [
         {
-          column: 20,
-          endColumn: 34,
-          endLine: 5,
-          line: 5,
-          messageId: 'shouldBeReadonly',
+          checkParameterProperties: true,
+          ignoreInferredTypes: false,
+          ...readonlynessOptionsDefaults,
         },
+      ],
+    },
+    {
+      code: `
+        interface Obj1 {
+          readonly [K: string]: Obj2;
+        }
+
+        interface Obj2 {
+          readonly [K: string]: Obj1;
+        }
+
+        function foo(event: Obj1): void {}
+      `,
+      name: 'circular readonly types (Bug: #5875)',
+      options: [
         {
-          column: 23,
-          endColumn: 37,
-          endLine: 6,
-          line: 6,
-          messageId: 'shouldBeReadonly',
+          checkParameterProperties: true,
+          ignoreInferredTypes: false,
+          ...readonlynessOptionsDefaults,
         },
+      ],
+    },
+    // Allowlist
+    {
+      code: `
+        interface Foo {
+          readonly prop: RegExp;
+        }
+
+        function foo(arg: Foo) {}
+      `,
+      options: [
         {
-          column: 22,
-          endColumn: 36,
-          endLine: 7,
-          line: 7,
-          messageId: 'shouldBeReadonly',
+          allow: [{ from: 'lib', name: 'RegExp' }],
         },
       ],
-      options: [{ checkParameterProperties: true }],
     },
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: readonly string[],
-            public arg2: readonly string[],
-            protected arg3: readonly string[],
-            readonly arg4: readonly string[],
-            arg5: string[],
-          ) {}
+        interface Foo {
+          prop: RegExp;
         }
+
+        function foo(arg: Readonly<Foo>) {}
       `,
-      errors: [
+      options: [
         {
-          column: 13,
-          endColumn: 27,
-          endLine: 8,
-          line: 8,
-          messageId: 'shouldBeReadonly',
+          allow: [{ from: 'lib', name: 'RegExp' }],
         },
       ],
-      options: [{ checkParameterProperties: false }],
     },
-
-    // type functions
     {
-      // TSCallSignatureDeclaration
       code: `
         interface Foo {
-          (arg: string[]): void;
+          prop: string;
         }
+
+        function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          column: 12,
-          endColumn: 25,
-          messageId: 'shouldBeReadonly',
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
     {
-      // TSConstructSignatureDeclaration
       code: `
+        interface Bar {
+          prop: string;
+        }
         interface Foo {
-          new (arg: string[]): void;
+          readonly prop: Bar;
         }
+
+        function foo(arg: Foo) {}
       `,
-      errors: [
+      options: [
         {
-          column: 16,
-          endColumn: 29,
-          messageId: 'shouldBeReadonly',
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
     {
-      // TSEmptyBodyFunctionExpression
-      code: noFormat`class Foo { foo(arg: string[]): void; };`,
-      errors: [
+      code: `
+        interface Bar {
+          prop: string;
+        }
+        interface Foo {
+          readonly prop: Bar;
+        }
+
+        function foo(arg: Foo) {}
+      `,
+      options: [
         {
-          column: 17,
-          endColumn: 30,
-          messageId: 'shouldBeReadonly',
+          allow: [{ from: 'file', name: 'Bar' }],
         },
       ],
     },
+  ],
+  invalid: [
+    // arrays
+    // Removing readonly causes duplicates
+    ...dedupeTestCases(
+      arrays.map<InvalidTestCase<MessageIds, Options>>(baseType => {
+        const type = baseType
+          .replaceAll('readonly ', '')
+          .replaceAll(/Readonly<(.+?)>/g, '$1')
+          .replaceAll('ReadonlyArray', 'Array');
+        return {
+          code: `function foo(arg: ${type}) {}`,
+          errors: [
+            {
+              column: 14,
+              endColumn: 19 + type.length,
+              messageId: 'shouldBeReadonly',
+            },
+          ],
+        };
+      }),
+    ),
+    // nested arrays
     {
-      // TSDeclareFunction
-      code: 'function foo(arg: string[]);',
+      code: 'function foo(arg: readonly string[][]) {}',
       errors: [
         {
           column: 14,
-          endColumn: 27,
+          endColumn: 38,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      // TSFunctionType
-      code: 'type Foo = (arg: string[]) => void;',
+      code: 'function foo(arg: Readonly<string[][]>) {}',
       errors: [
         {
-          column: 13,
-          endColumn: 26,
+          column: 14,
+          endColumn: 39,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      // TSMethodSignature
-      code: `
-        interface Foo {
-          foo(arg: string[]): void;
-        }
-      `,
+      code: 'function foo(arg: ReadonlyArray<Array<string>>) {}',
       errors: [
         {
-          column: 15,
-          endColumn: 28,
+          column: 14,
+          endColumn: 47,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
 
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
-    // directly recursive
+    // objects
+    ...objects.map<InvalidTestCase<MessageIds, Options>>(type => {
+      return {
+        code: `function foo(arg: ${type}) {}`,
+        errors: [
+          {
+            column: 14,
+            endColumn: 19 + type.length,
+            messageId: 'shouldBeReadonly',
+          },
+        ],
+      };
+    }),
     {
       code: `
-        interface Foo {
-          prop: Foo;
-        }
-        function foo(arg: Foo) {}
+        function foo(arg: {
+          readonly foo: {
+            bar: string;
+          };
+        }) {}
       `,
       errors: [
         {
           column: 22,
-          endColumn: 30,
-          line: 5,
+          endColumn: 10,
+          endLine: 6,
+          line: 2,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
+    // object index signatures
     {
       code: `
-        interface Foo {
-          prop: Foo;
-        }
-        function foo(arg: Readonly<Foo>) {}
+        function foo(arg: { [key: string]: string }) {}
       `,
       errors: [
         {
           column: 22,
-          endColumn: 40,
-          line: 5,
+          endColumn: 52,
+          endLine: 2,
+          line: 2,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // indirectly recursive
     {
       code: `
-        interface Foo {
-          prop: Bar;
-        }
-        interface Bar {
-          readonly prop: Foo;
-        }
-        function foo(arg: Foo) {}
+        function foo(arg: { [key: number]: string }) {}
       `,
       errors: [
         {
           column: 22,
-          endColumn: 30,
-          line: 8,
+          endColumn: 52,
+          endLine: 2,
+          line: 2,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
+
+    // weird intersections
+    ...weirdIntersections.map<InvalidTestCase<MessageIds, Options>>(
+      baseCode => {
+        const code = baseCode.replaceAll('readonly ', '');
+        return {
+          code,
+          errors: [{ messageId: 'shouldBeReadonly' }],
+        };
+      },
+    ),
     {
       code: `
-        interface Foo {
-          prop: Bar;
-        }
-        interface Bar {
-          readonly prop: Foo;
+        interface Test extends Array<string> {
+          readonly property: boolean;
         }
-        function foo(arg: Readonly<Foo>) {}
+        function foo(arg: Test) {}
       `,
       errors: [
         {
           column: 22,
-          endColumn: 40,
-          line: 8,
+          endColumn: 31,
+          endLine: 5,
+          line: 5,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
       code: `
-        interface Foo {
-          prop: Readonly<Bar>;
-        }
-        interface Bar {
-          prop: Readonly<Foo>;
+        interface Test extends Array<string> {
+          property: boolean;
         }
-        function foo(arg: Foo) {}
+        function foo(arg: Test) {}
       `,
       errors: [
         {
           column: 22,
-          endColumn: 30,
-          line: 8,
+          endColumn: 31,
+          endLine: 5,
+          line: 5,
           messageId: 'shouldBeReadonly',
         },
       ],
     },
-    {
-      code: `
-        const sym = Symbol('sym');
-
-        interface WithSymbol {
-          [sym]: number;
-        }
 
-        const willNot = (foo: WithSymbol) => {};
-      `,
-      errors: [
-        {
-          column: 26,
-          endColumn: 41,
-          line: 8,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
-    },
+    // parameter properties should work fine
     {
       code: `
-        type Callback<T> = (options: T) => void;
-
-        declare const acceptsCallback: <T>(callback: Callback<T>) => void;
-
-        interface CallbackOptions {
-          prop: string;
+        class Foo {
+          constructor(
+            private arg1: string[],
+            public arg2: string[],
+            protected arg3: string[],
+            readonly arg4: string[],
+          ) {}
         }
-
-        acceptsCallback<CallbackOptions>((options: CallbackOptions) => {});
       `,
       errors: [
         {
-          column: 43,
-          endColumn: 67,
-          line: 10,
+          column: 21,
+          endColumn: 35,
+          endLine: 4,
+          line: 4,
           messageId: 'shouldBeReadonly',
         },
-      ],
-      options: [
         {
-          ignoreInferredTypes: true,
+          column: 20,
+          endColumn: 34,
+          endLine: 5,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
-      ],
-    },
-    // Mutable methods.
-    {
-      code: `
-        type MyType = {
-          readonly prop: string;
-          method(): string;
-        };
-        function foo(arg: MyType) {}
-      `,
-      errors: [
         {
-          column: 22,
-          endColumn: 33,
+          column: 23,
+          endColumn: 37,
+          endLine: 6,
           line: 6,
           messageId: 'shouldBeReadonly',
         },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3405
-    {
-      code: `
-        type MyType<T> = {
-          [K in keyof T]: 'cat' | 'dog' | T[K];
-        };
-
-        function method<A extends any[] = string[]>(value: MyType<A>) {
-          return value;
-        }
-
-        method(['cat', 'dog']);
-        method<'mouse'[]>(['cat', 'mouse']);
-      `,
-      errors: [{ line: 6, messageId: 'shouldBeReadonly' }],
-    },
-    // Allowlist
-    {
-      code: `
-        function foo(arg: RegExp) {}
-      `,
-      errors: [
         {
           column: 22,
-          endColumn: 33,
-          line: 2,
+          endColumn: 36,
+          endLine: 7,
+          line: 7,
           messageId: 'shouldBeReadonly',
         },
       ],
-      options: [
-        {
-          allow: [{ from: 'file', name: 'Foo' }],
-        },
-      ],
+      options: [{ checkParameterProperties: true }],
     },
     {
       code: `
-        interface Foo {
-          readonly prop: RegExp;
+        class Foo {
+          constructor(
+            private arg1: readonly string[],
+            public arg2: readonly string[],
+            protected arg3: readonly string[],
+            readonly arg4: readonly string[],
+            arg5: string[],
+          ) {}
         }
-
-        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          column: 22,
-          endColumn: 30,
-          line: 6,
-          messageId: 'shouldBeReadonly',
-        },
-      ],
-      options: [
-        {
-          allow: [{ from: 'file', name: 'Bar' }],
+          column: 13,
+          endColumn: 27,
+          endLine: 8,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
+      options: [{ checkParameterProperties: false }],
     },
+
+    // type functions
     {
+      // TSCallSignatureDeclaration
       code: `
         interface Foo {
-          readonly prop: RegExp;
+          (arg: string[]): void;
         }
-
-        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          column: 22,
-          endColumn: 30,
-          line: 6,
+          column: 12,
+          endColumn: 25,
           messageId: 'shouldBeReadonly',
         },
       ],
-      options: [
-        {
-          allow: [{ from: 'lib', name: 'Foo' }],
-        },
-      ],
     },
     {
+      // TSConstructSignatureDeclaration
       code: `
         interface Foo {
-          readonly prop: RegExp;
+          new (arg: string[]): void;
         }
-
-        function foo(arg: Foo) {}
       `,
       errors: [
         {
-          column: 22,
-          endColumn: 30,
-          line: 6,
+          column: 16,
+          endColumn: 29,
           messageId: 'shouldBeReadonly',
         },
       ],
-      options: [
+    },
+    {
+      // TSEmptyBodyFunctionExpression
+      code: noFormat`class Foo { foo(arg: string[]): void; };`,
+      errors: [
         {
-          allow: [{ from: 'package', name: 'Foo', package: 'foo-lib' }],
+          column: 17,
+          endColumn: 30,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
-      code: `
-        function foo(arg: RegExp) {}
-      `,
+      // TSDeclareFunction
+      code: 'function foo(arg: string[]);',
       errors: [
         {
-          column: 22,
-          endColumn: 33,
-          line: 2,
+          column: 14,
+          endColumn: 27,
           messageId: 'shouldBeReadonly',
         },
       ],
-      options: [
+    },
+    {
+      // TSFunctionType
+      code: 'type Foo = (arg: string[]) => void;',
+      errors: [
         {
-          allow: [{ from: 'file', name: 'RegExp' }],
+          column: 13,
+          endColumn: 26,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
+      // TSMethodSignature
       code: `
-        function foo(arg: RegExp) {}
+        interface Foo {
+          foo(arg: string[]): void;
+        }
       `,
       errors: [
         {
-          column: 22,
-          endColumn: 33,
-          line: 2,
+          column: 15,
+          endColumn: 28,
           messageId: 'shouldBeReadonly',
         },
       ],
-      options: [
-        {
-          allow: [{ from: 'package', name: 'RegExp', package: 'regexp-lib' }],
-        },
-      ],
     },
-  ],
-  valid: [
-    'function foo() {}',
-
-    // primitives
-    ...primitives.map(type => `function foo(arg: ${type}) {}`),
-    `
-      const symb = Symbol('a');
-      function foo(arg: typeof symb) {}
-    `,
-    `
-      enum Enum {
-        a,
-        b,
-      }
-      function foo(arg: Enum) {}
-    `,
-
-    // arrays
-    ...arrays.map(type => `function foo(arg: ${type}) {}`),
-    // nested arrays
-    'function foo(arg: readonly (readonly string[])[]) {}',
-    'function foo(arg: Readonly<Readonly<string[]>[]>) {}',
-    'function foo(arg: ReadonlyArray<ReadonlyArray<string>>) {}',
-
-    // functions
-    'function foo(arg: () => void) {}',
-
-    // unions
-    'function foo(arg: string | null) {}',
-    'function foo(arg: string | ReadonlyArray<string>) {}',
-    'function foo(arg: string | (() => void)) {}',
-    'function foo(arg: ReadonlyArray<string> | ReadonlyArray<number>) {}',
-
-    // objects
-    ...objects.map(type => `function foo(arg: Readonly<${type}>) {}`),
-    `
-      function foo(arg: {
-        readonly foo: {
-          readonly bar: string;
-        };
-      }) {}
-    `,
-    `
-      function foo(arg: { readonly [k: string]: string }) {}
-    `,
-    `
-      function foo(arg: { readonly [k: number]: string }) {}
-    `,
-    `
-      interface Empty {}
-      function foo(arg: Empty) {}
-    `,
-
-    // weird other cases
-    ...weirdIntersections.map(code => code),
-    `
-      interface Test extends ReadonlyArray<string> {
-        readonly property: boolean;
-      }
-      function foo(arg: Readonly<Test>) {}
-    `,
-    `
-      type Test = readonly string[] & {
-        readonly property: boolean;
-      };
-      function foo(arg: Readonly<Test>) {}
-    `,
-    `
-      type Test = string & number;
-      function foo(arg: Test) {}
-    `,
 
-    // declaration merging
-    `
-      class Foo {
-        readonly bang = 1;
-      }
-      interface Foo {
-        readonly prop: string;
-      }
-      interface Foo {
-        readonly prop2: string;
-      }
-      function foo(arg: Foo) {}
-    `,
-    // method made readonly via Readonly<T>
-    `
-      class Foo {
-        method() {}
-      }
-      function foo(arg: Readonly<Foo>) {}
-    `,
-    // immutable methods
-    `
-      type MyType = Readonly<{
-        prop: string;
-        method(): string;
-      }>;
-      function foo(arg: MyType) {}
-    `,
-    `
-      type MyType = {
-        readonly prop: string;
-        readonly method: () => string;
-      };
-      function bar(arg: MyType) {}
-    `,
-    // PrivateIdentifier is exempt from this rule
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
+    // directly recursive
     {
       code: `
-        class Foo {
-          #privateField = 'foo';
-          #privateMember() {}
+        interface Foo {
+          prop: Foo;
         }
         function foo(arg: Foo) {}
       `,
-    },
-    {
-      code: `
-        class HasText {
-          readonly #text: string;
-        }
-
-        export function onDone(task: HasText): void {}
-      `,
-    },
-    // methods treated as readonly
-    {
-      code: `
-        type MyType = {
-          readonly prop: string;
-          method(): string;
-        };
-        function foo(arg: MyType) {}
-      `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 30,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
     {
       code: `
-        class Foo {
-          method() {}
+        interface Foo {
+          prop: Foo;
         }
-        function foo(arg: Foo) {}
+        function foo(arg: Readonly<Foo>) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 40,
+          line: 5,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+    // indirectly recursive
     {
       code: `
         interface Foo {
-          method(): void;
+          prop: Bar;
+        }
+        interface Bar {
+          readonly prop: Foo;
         }
         function foo(arg: Foo) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 30,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // ReadonlySet and ReadonlyMap are seen as readonly when methods are treated as readonly
     {
       code: `
-        function foo(arg: ReadonlySet<string>) {}
-        function bar(arg: ReadonlyMap<string, string>) {}
+        interface Foo {
+          prop: Bar;
+        }
+        interface Bar {
+          readonly prop: Foo;
+        }
+        function foo(arg: Readonly<Foo>) {}
       `,
-      options: [
+      errors: [
         {
-          treatMethodsAsReadonly: true,
+          column: 22,
+          endColumn: 40,
+          line: 8,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
-    // parameter properties should work fine
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: readonly string[],
-            public arg2: readonly string[],
-            protected arg3: readonly string[],
-            readonly arg4: readonly string[],
-          ) {}
+        interface Foo {
+          prop: Readonly<Bar>;
+        }
+        interface Bar {
+          prop: Readonly<Foo>;
         }
+        function foo(arg: Foo) {}
       `,
-      options: [{ checkParameterProperties: true }],
+      errors: [
+        {
+          column: 22,
+          endColumn: 30,
+          line: 8,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
     },
     {
       code: `
-        class Foo {
-          constructor(
-            private arg1: string[],
-            public arg2: string[],
-            protected arg3: string[],
-            readonly arg4: string[],
-          ) {}
+        const sym = Symbol('sym');
+
+        interface WithSymbol {
+          [sym]: number;
         }
+
+        const willNot = (foo: WithSymbol) => {};
       `,
-      options: [{ checkParameterProperties: false }],
+      errors: [
+        {
+          column: 26,
+          endColumn: 41,
+          line: 8,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
     },
-
-    // type functions
-    `
-      interface Foo {
-        (arg: readonly string[]): void;
-      }
-    `, // TSCallSignatureDeclaration
-    `
-      interface Foo {
-        new (arg: readonly string[]): void;
-      }
-    `, // TSConstructSignatureDeclaration
-    noFormat`class Foo { 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
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1665
-    // directly recursive interface
-    `
-      interface Foo {
-        readonly prop: Foo;
-      }
-      function foo(arg: Foo) {}
-    `,
-
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3396
-    // directly recursive union type
-    `
-      type MyType = string | readonly MyType[];
-
-      function foo<A extends MyType[]>(a: A): MyType[] {
-        return [];
-      }
-    `,
-    // indirectly recursive
-    `
-      interface Foo {
-        readonly prop: Bar;
-      }
-      interface Bar {
-        readonly prop: Foo;
-      }
-      function foo(arg: Foo) {}
-    `,
-    `
-      interface Foo {
-        prop: Readonly<Bar>;
-      }
-      interface Bar {
-        prop: Readonly<Foo>;
-      }
-      function foo(arg: Readonly<Foo>) {}
-    `,
-    `
-      const sym = Symbol('sym');
-
-      interface WithSymbol {
-        [sym]: number;
-      }
-
-      const willNotCrash = (foo: Readonly<WithSymbol>) => {};
-    `,
     {
       code: `
         type Callback<T> = (options: T) => void;
@@ -952,53 +904,75 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
           prop: string;
         }
 
-        acceptsCallback<CallbackOptions>(options => {});
+        acceptsCallback<CallbackOptions>((options: CallbackOptions) => {});
       `,
+      errors: [
+        {
+          column: 43,
+          endColumn: 67,
+          line: 10,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
           ignoreInferredTypes: true,
         },
       ],
     },
+    // Mutable methods.
     {
       code: `
-        interface Obj {
-          readonly [K: string]: Obj;
-        }
-
-        function foo(event: Obj): void {}
+        type MyType = {
+          readonly prop: string;
+          method(): string;
+        };
+        function foo(arg: MyType) {}
       `,
-      name: 'circular readonly types (Bug: #4476)',
-      options: [
+      errors: [
         {
-          checkParameterProperties: true,
-          ignoreInferredTypes: false,
-          ...readonlynessOptionsDefaults,
+          column: 22,
+          endColumn: 33,
+          line: 6,
+          messageId: 'shouldBeReadonly',
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3405
     {
       code: `
-        interface Obj1 {
-          readonly [K: string]: Obj2;
-        }
+        type MyType<T> = {
+          [K in keyof T]: 'cat' | 'dog' | T[K];
+        };
 
-        interface Obj2 {
-          readonly [K: string]: Obj1;
+        function method<A extends any[] = string[]>(value: MyType<A>) {
+          return value;
         }
 
-        function foo(event: Obj1): void {}
+        method(['cat', 'dog']);
+        method<'mouse'[]>(['cat', 'mouse']);
       `,
-      name: 'circular readonly types (Bug: #5875)',
+      errors: [{ line: 6, messageId: 'shouldBeReadonly' }],
+    },
+    // Allowlist
+    {
+      code: `
+        function foo(arg: RegExp) {}
+      `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 33,
+          line: 2,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          checkParameterProperties: true,
-          ignoreInferredTypes: false,
-          ...readonlynessOptionsDefaults,
+          allow: [{ from: 'file', name: 'Foo' }],
         },
       ],
     },
-    // Allowlist
     {
       code: `
         interface Foo {
@@ -1007,71 +981,97 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
 
         function foo(arg: Foo) {}
       `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 30,
+          line: 6,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          allow: [{ from: 'lib', name: 'RegExp' }],
+          allow: [{ from: 'file', name: 'Bar' }],
         },
       ],
     },
     {
       code: `
         interface Foo {
-          prop: RegExp;
+          readonly prop: RegExp;
         }
 
-        function foo(arg: Readonly<Foo>) {}
+        function foo(arg: Foo) {}
       `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 30,
+          line: 6,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          allow: [{ from: 'lib', name: 'RegExp' }],
+          allow: [{ from: 'lib', name: 'Foo' }],
         },
       ],
     },
     {
       code: `
         interface Foo {
-          prop: string;
+          readonly prop: RegExp;
         }
 
         function foo(arg: Foo) {}
       `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 30,
+          line: 6,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          allow: [{ from: 'file', name: 'Foo' }],
+          allow: [{ from: 'package', name: 'Foo', package: 'foo-lib' }],
         },
       ],
     },
     {
       code: `
-        interface Bar {
-          prop: string;
-        }
-        interface Foo {
-          readonly prop: Bar;
-        }
-
-        function foo(arg: Foo) {}
+        function foo(arg: RegExp) {}
       `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 33,
+          line: 2,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          allow: [{ from: 'file', name: 'Foo' }],
+          allow: [{ from: 'file', name: 'RegExp' }],
         },
       ],
     },
     {
       code: `
-        interface Bar {
-          prop: string;
-        }
-        interface Foo {
-          readonly prop: Bar;
-        }
-
-        function foo(arg: Foo) {}
+        function foo(arg: RegExp) {}
       `,
+      errors: [
+        {
+          column: 22,
+          endColumn: 33,
+          line: 2,
+          messageId: 'shouldBeReadonly',
+        },
+      ],
       options: [
         {
-          allow: [{ from: 'file', name: 'Bar' }],
+          allow: [{ from: 'package', name: 'RegExp', package: 'regexp-lib' }],
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
index f6f5881e19bb..1f0d7383c1db 100644
--- a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
@@ -14,732 +14,492 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-readonly', rule, {
-  invalid: [
-    {
-      code: `
-        class TestIncorrectlyModifiableStatic {
-          private static incorrectlyModifiableStatic = 7;
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiableStatic',
-          },
-          endColumn: 53,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableStatic {
-          private static readonly incorrectlyModifiableStatic = 7;
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableStatic {
-          static #incorrectlyModifiableStatic = 7;
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiableStatic',
-          },
-          endColumn: 46,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableStatic {
-          static readonly #incorrectlyModifiableStatic = 7;
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableStaticArrow {
-          private static incorrectlyModifiableStaticArrow = () => 7;
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiableStaticArrow',
-          },
-          endColumn: 58,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableStaticArrow {
-          private static readonly incorrectlyModifiableStaticArrow = () => 7;
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableStaticArrow {
-          static #incorrectlyModifiableStaticArrow = () => 7;
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiableStaticArrow',
-          },
-          endColumn: 51,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableStaticArrow {
-          static readonly #incorrectlyModifiableStaticArrow = () => 7;
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableInline {
-          private incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private incorrectlyModifiableInline = 7;
-            };
-          }
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiableInline',
-          },
-          endColumn: 46,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-        {
-          column: 15,
-          data: {
-            name: 'incorrectlyModifiableInline',
-          },
-          endColumn: 50,
-          endLine: 7,
-          line: 7,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableInline {
-          private readonly incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private readonly incorrectlyModifiableInline = 7;
-            };
-          }
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableInline {
-          #incorrectlyModifiableInline = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              #incorrectlyModifiableInline = 7;
-            };
-          }
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiableInline',
-          },
-          endColumn: 39,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-        {
-          column: 15,
-          data: {
-            name: '#incorrectlyModifiableInline',
-          },
-          endColumn: 43,
-          endLine: 7,
-          line: 7,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableInline {
-          readonly #incorrectlyModifiableInline = 7;
+  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 TestReadonlyStatic {
+        static readonly #correctlyReadonlyStatic = 7;
+      }
+    `,
+    `
+      class TestModifiableStatic {
+        private static correctlyModifiableStatic = 7;
 
-          public createConfusingChildClass() {
-            return class {
-              readonly #incorrectlyModifiableInline = 7;
-            };
-          }
+        public constructor() {
+          TestModifiableStatic.correctlyModifiableStatic += 1;
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableDelayed {
-          private incorrectlyModifiableDelayed = 7;
+      }
+    `,
+    `
+      class TestModifiableStatic {
+        static #correctlyModifiableStatic = 7;
 
-          public constructor() {
-            this.incorrectlyModifiableDelayed = 7;
-          }
+        public constructor() {
+          TestModifiableStatic.#correctlyModifiableStatic += 1;
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiableDelayed',
-          },
-          endColumn: 47,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableDelayed {
-          private readonly incorrectlyModifiableDelayed = 7;
+      }
+    `,
+    `
+      class TestModifiableByParameterProperty {
+        private static readonly correctlyModifiableByParameterProperty = 7;
 
-          public constructor() {
-            this.incorrectlyModifiableDelayed = 7;
-          }
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiableDelayed {
-          #incorrectlyModifiableDelayed = 7;
+        public constructor(
+          public correctlyModifiablePublicParameter: number = (() => {
+            return (TestModifiableStatic.correctlyModifiableByParameterProperty += 1);
+          })(),
+        ) {}
+      }
+    `,
+    `
+      class TestModifiableByParameterProperty {
+        static readonly #correctlyModifiableByParameterProperty = 7;
 
-          public constructor() {
-            this.#incorrectlyModifiableDelayed = 7;
-          }
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiableDelayed',
-          },
-          endColumn: 40,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiableDelayed {
-          readonly #incorrectlyModifiableDelayed = 7;
+        public constructor(
+          public correctlyModifiablePublicParameter: number = (() => {
+            return (TestModifiableStatic.#correctlyModifiableByParameterProperty += 1);
+          })(),
+        ) {}
+      }
+    `,
+    `
+      class TestReadonlyInline {
+        private readonly correctlyReadonlyInline = 7;
+      }
+    `,
+    `
+      class TestReadonlyInline {
+        readonly #correctlyReadonlyInline = 7;
+      }
+    `,
+    `
+      class TestReadonlyDelayed {
+        private readonly correctlyReadonlyDelayed = 7;
 
-          public constructor() {
-            this.#incorrectlyModifiableDelayed = 7;
-          }
+        public constructor() {
+          this.correctlyReadonlyDelayed += 1;
         }
-      `,
-    },
-    {
-      code: `
-        class TestChildClassExpressionModifiable {
-          private childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private childClassExpressionModifiable = 7;
+      }
+    `,
+    `
+      class TestReadonlyDelayed {
+        readonly #correctlyReadonlyDelayed = 7;
 
-              mutate() {
-                this.childClassExpressionModifiable += 1;
-              }
-            };
-          }
+        public constructor() {
+          this.#correctlyReadonlyDelayed += 1;
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'childClassExpressionModifiable',
-          },
-          endColumn: 49,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestChildClassExpressionModifiable {
-          private readonly childClassExpressionModifiable = 7;
-
-          public createConfusingChildClass() {
-            return class {
-              private childClassExpressionModifiable = 7;
+      }
+    `,
+    `
+      class TestModifiableInline {
+        private correctlyModifiableInline = 7;
 
-              mutate() {
-                this.childClassExpressionModifiable += 1;
-              }
-            };
-          }
-        }
-      `,
-    },
-    {
-      code: `
-        class TestChildClassExpressionModifiable {
-          #childClassExpressionModifiable = 7;
+        public mutate() {
+          this.correctlyModifiableInline += 1;
 
-          public createConfusingChildClass() {
-            return class {
-              #childClassExpressionModifiable = 7;
+          return class {
+            private correctlyModifiableInline = 7;
 
-              mutate() {
-                this.#childClassExpressionModifiable += 1;
-              }
-            };
-          }
+            mutate() {
+              this.correctlyModifiableInline += 1;
+            }
+          };
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#childClassExpressionModifiable',
-          },
-          endColumn: 42,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestChildClassExpressionModifiable {
-          readonly #childClassExpressionModifiable = 7;
+      }
+    `,
+    `
+      class TestModifiableInline {
+        #correctlyModifiableInline = 7;
 
-          public createConfusingChildClass() {
-            return class {
-              #childClassExpressionModifiable = 7;
+        public mutate() {
+          this.#correctlyModifiableInline += 1;
 
-              mutate() {
-                this.#childClassExpressionModifiable += 1;
-              }
-            };
-          }
-        }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePostMinus {
-          private incorrectlyModifiablePostMinus = 7;
+          return class {
+            #correctlyModifiableInline = 7;
 
-          public mutate() {
-            this.incorrectlyModifiablePostMinus - 1;
-          }
+            mutate() {
+              this.#correctlyModifiableInline += 1;
+            }
+          };
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiablePostMinus',
-          },
-          endColumn: 49,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiableDelayed {
+        private correctlyModifiableDelayed = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePostMinus {
-          private readonly incorrectlyModifiablePostMinus = 7;
+        public mutate() {
+          this.correctlyModifiableDelayed += 1;
+        }
+      }
+    `,
+    `
+      class TestModifiableDelayed {
+        #correctlyModifiableDelayed = 7;
 
-          public mutate() {
-            this.incorrectlyModifiablePostMinus - 1;
-          }
+        public mutate() {
+          this.#correctlyModifiableDelayed += 1;
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePostMinus {
-          #incorrectlyModifiablePostMinus = 7;
+      }
+    `,
+    `
+      class TestModifiableDeleted {
+        private correctlyModifiableDeleted = 7;
 
-          public mutate() {
-            this.#incorrectlyModifiablePostMinus - 1;
-          }
+        public mutate() {
+          delete this.correctlyModifiableDeleted;
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiablePostMinus',
-          },
-          endColumn: 42,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePostMinus {
-          readonly #incorrectlyModifiablePostMinus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructor {
+        private correctlyModifiableWithinConstructor = 7;
 
-          public mutate() {
-            this.#incorrectlyModifiablePostMinus - 1;
-          }
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructor += 1;
+          })();
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePostPlus {
-          private incorrectlyModifiablePostPlus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructor {
+        #correctlyModifiableWithinConstructor = 7;
 
-          public mutate() {
-            this.incorrectlyModifiablePostPlus + 1;
-          }
+        public constructor() {
+          (() => {
+            this.#correctlyModifiableWithinConstructor += 1;
+          })();
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiablePostPlus',
-          },
-          endColumn: 48,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorArrowFunction {
+        private correctlyModifiableWithinConstructorArrowFunction = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePostPlus {
-          private readonly incorrectlyModifiablePostPlus = 7;
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructorArrowFunction += 1;
+          })();
+        }
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorArrowFunction {
+        #correctlyModifiableWithinConstructorArrowFunction = 7;
 
-          public mutate() {
-            this.incorrectlyModifiablePostPlus + 1;
-          }
+        public constructor() {
+          (() => {
+            this.#correctlyModifiableWithinConstructorArrowFunction += 1;
+          })();
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePostPlus {
-          #incorrectlyModifiablePostPlus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInFunctionExpression {
+        private correctlyModifiableWithinConstructorInFunctionExpression = 7;
 
-          public mutate() {
-            this.#incorrectlyModifiablePostPlus + 1;
-          }
+        public constructor() {
+          const self = this;
+
+          (() => {
+            self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
+          })();
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiablePostPlus',
-          },
-          endColumn: 41,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInFunctionExpression {
+        #correctlyModifiableWithinConstructorInFunctionExpression = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePostPlus {
-          readonly #incorrectlyModifiablePostPlus = 7;
+        public constructor() {
+          const self = this;
 
-          public mutate() {
-            this.#incorrectlyModifiablePostPlus + 1;
-          }
+          (() => {
+            self.#correctlyModifiableWithinConstructorInFunctionExpression += 1;
+          })();
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePreMinus {
-          private incorrectlyModifiablePreMinus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInGetAccessor {
+        private correctlyModifiableWithinConstructorInGetAccessor = 7;
 
-          public mutate() {
-            -this.incorrectlyModifiablePreMinus;
-          }
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            get accessor() {
+              return (self.correctlyModifiableWithinConstructorInGetAccessor += 1);
+            },
+          };
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiablePreMinus',
-          },
-          endColumn: 48,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePreMinus {
-          private readonly incorrectlyModifiablePreMinus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInGetAccessor {
+        #correctlyModifiableWithinConstructorInGetAccessor = 7;
+
+        public constructor() {
+          const self = this;
 
-          public mutate() {
-            -this.incorrectlyModifiablePreMinus;
-          }
+          const confusingObject = {
+            get accessor() {
+              return (self.#correctlyModifiableWithinConstructorInGetAccessor += 1);
+            },
+          };
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePreMinus {
-          #incorrectlyModifiablePreMinus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInMethodDeclaration {
+        private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
 
-          public mutate() {
-            -this.#incorrectlyModifiablePreMinus;
-          }
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            methodDeclaration() {
+              self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+            },
+          };
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiablePreMinus',
-          },
-          endColumn: 41,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInMethodDeclaration {
+        #correctlyModifiableWithinConstructorInMethodDeclaration = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePreMinus {
-          readonly #incorrectlyModifiablePreMinus = 7;
+        public constructor() {
+          const self = this;
 
-          public mutate() {
-            -this.#incorrectlyModifiablePreMinus;
-          }
+          const confusingObject = {
+            methodDeclaration() {
+              self.#correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+            },
+          };
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePrePlus {
-          private incorrectlyModifiablePrePlus = 7;
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInSetAccessor {
+        private correctlyModifiableWithinConstructorInSetAccessor = 7;
 
-          public mutate() {
-            +this.incorrectlyModifiablePrePlus;
-          }
+        public constructor() {
+          const self = this;
+
+          const confusingObject = {
+            set accessor(value: number) {
+              self.correctlyModifiableWithinConstructorInSetAccessor += value;
+            },
+          };
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyModifiablePrePlus',
-          },
-          endColumn: 47,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiableWithinConstructorInSetAccessor {
+        #correctlyModifiableWithinConstructorInSetAccessor = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePrePlus {
-          private readonly incorrectlyModifiablePrePlus = 7;
+        public constructor() {
+          const self = this;
 
-          public mutate() {
-            +this.incorrectlyModifiablePrePlus;
-          }
+          const confusingObject = {
+            set accessor(value: number) {
+              self.#correctlyModifiableWithinConstructorInSetAccessor += value;
+            },
+          };
         }
-      `,
-    },
-    {
-      code: `
-        class TestIncorrectlyModifiablePrePlus {
-          #incorrectlyModifiablePrePlus = 7;
+      }
+    `,
+    `
+      class TestModifiablePostDecremented {
+        private correctlyModifiablePostDecremented = 7;
 
-          public mutate() {
-            +this.#incorrectlyModifiablePrePlus;
-          }
+        public mutate() {
+          this.correctlyModifiablePostDecremented -= 1;
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: '#incorrectlyModifiablePrePlus',
-          },
-          endColumn: 40,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiablePostDecremented {
+        #correctlyModifiablePostDecremented = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestIncorrectlyModifiablePrePlus {
-          readonly #incorrectlyModifiablePrePlus = 7;
+        public mutate() {
+          this.#correctlyModifiablePostDecremented -= 1;
+        }
+      }
+    `,
+    `
+      class TestyModifiablePostIncremented {
+        private correctlyModifiablePostIncremented = 7;
 
-          public mutate() {
-            +this.#incorrectlyModifiablePrePlus;
-          }
+        public mutate() {
+          this.correctlyModifiablePostIncremented += 1;
         }
-      `,
-    },
-    {
-      code: `
-        class TestOverlappingClassVariable {
-          private overlappingClassVariable = 7;
+      }
+    `,
+    `
+      class TestyModifiablePostIncremented {
+        #correctlyModifiablePostIncremented = 7;
 
-          public workWithSimilarClass(other: SimilarClass) {
-            other.overlappingClassVariable = 7;
-          }
+        public mutate() {
+          this.#correctlyModifiablePostIncremented += 1;
         }
+      }
+    `,
+    `
+      class TestModifiablePreDecremented {
+        private correctlyModifiablePreDecremented = 7;
 
-        class SimilarClass {
-          public overlappingClassVariable = 7;
+        public mutate() {
+          --this.correctlyModifiablePreDecremented;
         }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'overlappingClassVariable',
-          },
-          endColumn: 43,
-          endLine: 3,
+      }
+    `,
+    `
+      class TestModifiablePreDecremented {
+        #correctlyModifiablePreDecremented = 7;
 
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-        class TestOverlappingClassVariable {
-          private readonly overlappingClassVariable = 7;
+        public mutate() {
+          --this.#correctlyModifiablePreDecremented;
+        }
+      }
+    `,
+    `
+      class TestModifiablePreIncremented {
+        private correctlyModifiablePreIncremented = 7;
 
-          public workWithSimilarClass(other: SimilarClass) {
-            other.overlappingClassVariable = 7;
-          }
+        public mutate() {
+          ++this.correctlyModifiablePreIncremented;
+        }
+      }
+    `,
+    `
+      class TestModifiablePreIncremented {
+        #correctlyModifiablePreIncremented = 7;
+
+        public mutate() {
+          ++this.#correctlyModifiablePreIncremented;
         }
+      }
+    `,
+    `
+      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) {}
 
-        class SimilarClass {
-          public overlappingClassVariable = 7;
+        public mutate() {
+          this.correctlyModifiableParameter += 1;
         }
-      `,
-    },
+      }
+    `,
     {
       code: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(private incorrectlyModifiableParameter = 7) {}
+        class TestCorrectlyNonInlineLambdas {
+          private correctlyNonInlineLambda = 7;
         }
       `,
-      errors: [
+      options: [
         {
-          column: 30,
-          data: {
-            name: 'incorrectlyModifiableParameter',
-          },
-          endColumn: 68,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
+          onlyInlineLambdas: true,
         },
       ],
-      output: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(private readonly incorrectlyModifiableParameter = 7) {}
-        }
-      `,
     },
     {
       code: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(
-            public ignore: boolean,
-            private incorrectlyModifiableParameter = 7,
-          ) {}
+        class TestCorrectlyNonInlineLambdas {
+          #correctlyNonInlineLambda = 7;
         }
       `,
-      errors: [
+      options: [
         {
-          column: 13,
-          data: {
-            name: 'incorrectlyModifiableParameter',
-          },
-          endColumn: 51,
-          endLine: 5,
-
-          line: 5,
-          messageId: 'preferReadonly',
+          onlyInlineLambdas: true,
         },
       ],
-      output: `
-        class TestIncorrectlyModifiableParameter {
-          public constructor(
-            public ignore: boolean,
-            private readonly incorrectlyModifiableParameter = 7,
-          ) {}
+    },
+    `
+      class TestComputedParameter {
+        public mutate() {
+          this['computed'] = 1;
         }
+      }
+    `,
+    `
+      class TestComputedParameter {
+        private ['computed-ignored-by-rule'] = 1;
+      }
+    `,
+    {
+      code: `
+class Foo {
+  private value: number = 0;
+
+  bar(newValue: { value: number }) {
+    ({ value: this.value } = newValue);
+    return this.value;
+  }
+}
       `,
     },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          private incorrectlyInlineLambda = () => 7;
-        }
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            name: 'incorrectlyInlineLambda',
-          },
-          endColumn: 42,
-          endLine: 3,
-          line: 3,
-          messageId: 'preferReadonly',
-        },
-      ],
-      options: [
-        {
-          onlyInlineLambdas: true,
-        },
-      ],
-      output: `
-        class TestCorrectlyNonInlineLambdas {
-          private readonly incorrectlyInlineLambda = () => 7;
-        }
+class Foo {
+  #value: number = 0;
+
+  bar(newValue: { value: number }) {
+    ({ value: this.#value } = newValue);
+    return this.#value;
+  }
+}
       `,
     },
     {
@@ -747,218 +507,348 @@ ruleTester.run('prefer-readonly', rule, {
 function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
   return class extends Base {
     private _name: string;
+
+    public test(value: string) {
+      this._name = value;
+    }
   };
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            name: '_name',
-          },
-          endColumn: 18,
-          endLine: 4,
-          line: 4,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
+    },
+    {
+      code: `
 function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
   return class extends Base {
-    private readonly _name: string;
+    #name: string;
+
+    public test(value: string) {
+      this.#name = value;
+    }
   };
 }
       `,
     },
     {
       code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    #name: string;
-  };
+class Foo {
+  private value: Record<string, number> = {};
+
+  bar(newValue: Record<string, number>) {
+    ({ ...this.value } = newValue);
+    return this.value;
+  }
 }
       `,
-      errors: [
-        {
-          column: 5,
-          data: {
-            name: '#name',
-          },
-          endColumn: 10,
-          endLine: 4,
-          line: 4,
-          messageId: 'preferReadonly',
-        },
-      ],
-      output: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    readonly #name: string;
-  };
+    },
+    {
+      code: `
+class Foo {
+  #value: Record<string, number> = {};
+
+  bar(newValue: Record<string, number>) {
+    ({ ...this.#value } = newValue);
+    return this.#value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  private value: number[] = [];
+
+  bar(newValue: number[]) {
+    [...this.value] = newValue;
+    return this.value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  #value: number[] = [];
+
+  bar(newValue: number[]) {
+    [...this.#value] = newValue;
+    return this.#value;
+  }
 }
       `,
     },
     {
       code: `
+class Foo {
+  private value: number = 0;
+
+  bar(newValue: number[]) {
+    [this.value] = newValue;
+    return this.value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+class Foo {
+  #value: number = 0;
+
+  bar(newValue: number[]) {
+    [this.#value] = newValue;
+    return this.#value;
+  }
+}
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {
+            prop: '',
+          };
+
+          public test(): void {
+            this.testObj = '';
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class Test {
+          #testObj = {
+            prop: '',
+          };
+
+          public test(): void {
+            this.#testObj = '';
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class TestObject {
+          public prop: number;
+        }
+
+        class Test {
+          private testObj = new TestObject();
+
+          public test(): void {
+            this.testObj = new TestObject();
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class TestObject {
+          public prop: number;
+        }
+
         class Test {
-          private testObj = {
-            prop: '',
-          };
+          #testObj = new TestObject();
 
           public test(): void {
-            this.testObj.prop = '';
+            this.#testObj = new TestObject();
           }
         }
       `,
+    },
+    `
+      class TestIntersection {
+        private prop: number = 3;
+
+        test() {
+          const that = {} as this & { _foo: 'bar' };
+          that.prop = 1;
+        }
+      }
+    `,
+    `
+      class TestUnion {
+        private prop: number = 3;
+
+        test() {
+          const that = {} as this | (this & { _foo: 'bar' });
+          that.prop = 1;
+        }
+      }
+    `,
+    `
+      class TestStaticIntersection {
+        private static prop: number;
+
+        test() {
+          const that = {} as typeof TestStaticIntersection & { _foo: 'bar' };
+          that.prop = 1;
+        }
+      }
+    `,
+    `
+      class TestStaticUnion {
+        private static prop: number = 1;
+
+        test() {
+          const that = {} as
+            | typeof TestStaticUnion
+            | (typeof TestStaticUnion & { _foo: 'bar' });
+          that.prop = 1;
+        }
+      }
+    `,
+    `
+      class TestBothIntersection {
+        private prop1: number = 1;
+        private static prop2: number;
+
+        test() {
+          const that = {} as typeof TestBothIntersection & this;
+          that.prop1 = 1;
+          that.prop2 = 1;
+        }
+      }
+    `,
+    `
+      class TestBothIntersection {
+        private prop1: number = 1;
+        private static prop2: number;
+
+        test() {
+          const that = {} as this & typeof TestBothIntersection;
+          that.prop1 = 1;
+          that.prop2 = 1;
+        }
+      }
+    `,
+    `
+      class TestStaticPrivateAccessor {
+        private static accessor staticAcc = 1;
+      }
+    `,
+    `
+      class TestStaticPrivateFieldAccessor {
+        static accessor #staticAcc = 1;
+      }
+    `,
+    `
+      class TestPrivateAccessor {
+        private accessor acc = 3;
+      }
+    `,
+    `
+      class TestPrivateFieldAccessor {
+        accessor #acc = 3;
+      }
+    `,
+  ],
+  invalid: [
+    {
+      code: `
+        class TestIncorrectlyModifiableStatic {
+          private static incorrectlyModifiableStatic = 7;
+        }
+      `,
       errors: [
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiableStatic',
           },
-          endColumn: 26,
+          endColumn: 53,
           endLine: 3,
-
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {
-            prop: '',
-          };
-
-          public test(): void {
-            this.testObj.prop = '';
-          }
+        class TestIncorrectlyModifiableStatic {
+          private static readonly incorrectlyModifiableStatic = 7;
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {
-            prop: '',
-          };
-
-          public test(): void {
-            this.#testObj.prop = '';
-          }
+        class TestIncorrectlyModifiableStatic {
+          static #incorrectlyModifiableStatic = 7;
         }
       `,
       errors: [
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiableStatic',
           },
-          endColumn: 19,
+          endColumn: 46,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {
-            prop: '',
-          };
-
-          public test(): void {
-            this.#testObj.prop = '';
-          }
+        class TestIncorrectlyModifiableStatic {
+          static readonly #incorrectlyModifiableStatic = 7;
         }
       `,
     },
     {
       code: `
-        class TestObject {
-          public prop: number;
-        }
-
-        class Test {
-          private testObj = new TestObject();
-
-          public test(): void {
-            this.testObj.prop = 10;
-          }
+        class TestIncorrectlyModifiableStaticArrow {
+          private static incorrectlyModifiableStaticArrow = () => 7;
         }
       `,
       errors: [
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiableStaticArrow',
           },
-          endColumn: 26,
-          endLine: 7,
-          line: 7,
+          endColumn: 58,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestObject {
-          public prop: number;
-        }
-
-        class Test {
-          private readonly testObj = new TestObject();
-
-          public test(): void {
-            this.testObj.prop = 10;
-          }
+        class TestIncorrectlyModifiableStaticArrow {
+          private static readonly incorrectlyModifiableStaticArrow = () => 7;
         }
       `,
     },
     {
       code: `
-        class TestObject {
-          public prop: number;
-        }
-
-        class Test {
-          #testObj = new TestObject();
-
-          public test(): void {
-            this.#testObj.prop = 10;
-          }
+        class TestIncorrectlyModifiableStaticArrow {
+          static #incorrectlyModifiableStaticArrow = () => 7;
         }
       `,
       errors: [
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiableStaticArrow',
           },
-          endColumn: 19,
-          endLine: 7,
-          line: 7,
+          endColumn: 51,
+          endLine: 3,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class TestObject {
-          public prop: number;
-        }
-
-        class Test {
-          readonly #testObj = new TestObject();
-
-          public test(): void {
-            this.#testObj.prop = 10;
-          }
+        class TestIncorrectlyModifiableStaticArrow {
+          static readonly #incorrectlyModifiableStaticArrow = () => 7;
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {
-            prop: '',
-          };
-          public test(): void {
-            this.testObj.prop;
+        class TestIncorrectlyModifiableInline {
+          private incorrectlyModifiableInline = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              private incorrectlyModifiableInline = 7;
+            };
           }
         }
       `,
@@ -966,34 +856,45 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiableInline',
           },
-          endColumn: 26,
+          endColumn: 46,
           endLine: 3,
-
           line: 3,
           messageId: 'preferReadonly',
         },
+        {
+          column: 15,
+          data: {
+            name: 'incorrectlyModifiableInline',
+          },
+          endColumn: 50,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
       ],
       output: `
-        class Test {
-          private readonly testObj = {
-            prop: '',
-          };
-          public test(): void {
-            this.testObj.prop;
+        class TestIncorrectlyModifiableInline {
+          private readonly incorrectlyModifiableInline = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              private readonly incorrectlyModifiableInline = 7;
+            };
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {
-            prop: '',
-          };
-          public test(): void {
-            this.#testObj.prop;
+        class TestIncorrectlyModifiableInline {
+          #incorrectlyModifiableInline = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              #incorrectlyModifiableInline = 7;
+            };
           }
         }
       `,
@@ -1001,31 +902,43 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiableInline',
           },
-          endColumn: 19,
+          endColumn: 39,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
+        {
+          column: 15,
+          data: {
+            name: '#incorrectlyModifiableInline',
+          },
+          endColumn: 43,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
       ],
       output: `
-        class Test {
-          readonly #testObj = {
-            prop: '',
-          };
-          public test(): void {
-            this.#testObj.prop;
+        class TestIncorrectlyModifiableInline {
+          readonly #incorrectlyModifiableInline = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              readonly #incorrectlyModifiableInline = 7;
+            };
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop;
+        class TestIncorrectlyModifiableDelayed {
+          private incorrectlyModifiableDelayed = 7;
+
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
           }
         }
       `,
@@ -1033,29 +946,31 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiableDelayed',
           },
-          endColumn: 26,
+          endColumn: 47,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop;
+        class TestIncorrectlyModifiableDelayed {
+          private readonly incorrectlyModifiableDelayed = 7;
+
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop;
+        class TestIncorrectlyModifiableDelayed {
+          #incorrectlyModifiableDelayed = 7;
+
+          public constructor() {
+            this.#incorrectlyModifiableDelayed = 7;
           }
         }
       `,
@@ -1063,30 +978,37 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiableDelayed',
           },
-          endColumn: 19,
+          endColumn: 40,
           endLine: 3,
-
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop;
+        class TestIncorrectlyModifiableDelayed {
+          readonly #incorrectlyModifiableDelayed = 7;
+
+          public constructor() {
+            this.#incorrectlyModifiableDelayed = 7;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj!.prop;
+        class TestChildClassExpressionModifiable {
+          private childClassExpressionModifiable = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
+
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
       `,
@@ -1094,29 +1016,43 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'childClassExpressionModifiable',
           },
-          endColumn: 26,
+          endColumn: 49,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj!.prop;
+        class TestChildClassExpressionModifiable {
+          private readonly childClassExpressionModifiable = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
+
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj!.prop;
+        class TestChildClassExpressionModifiable {
+          #childClassExpressionModifiable = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              #childClassExpressionModifiable = 7;
+
+              mutate() {
+                this.#childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
       `,
@@ -1124,29 +1060,37 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#childClassExpressionModifiable',
           },
-          endColumn: 19,
+          endColumn: 42,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj!.prop;
+        class TestChildClassExpressionModifiable {
+          readonly #childClassExpressionModifiable = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              #childClassExpressionModifiable = 7;
+
+              mutate() {
+                this.#childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop.prop = '';
+        class TestIncorrectlyModifiablePostMinus {
+          private incorrectlyModifiablePostMinus = 7;
+
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
           }
         }
       `,
@@ -1154,9 +1098,9 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiablePostMinus',
           },
-          endColumn: 26,
+          endColumn: 49,
           endLine: 3,
 
           line: 3,
@@ -1164,20 +1108,22 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop.prop = '';
+        class TestIncorrectlyModifiablePostMinus {
+          private readonly incorrectlyModifiablePostMinus = 7;
+
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj.prop.prop = '';
+        class TestIncorrectlyModifiablePostMinus {
+          #incorrectlyModifiablePostMinus = 7;
+
+          public mutate() {
+            this.#incorrectlyModifiablePostMinus - 1;
           }
         }
       `,
@@ -1185,29 +1131,31 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiablePostMinus',
           },
-          endColumn: 19,
+          endColumn: 42,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj.prop.prop = '';
+        class TestIncorrectlyModifiablePostMinus {
+          readonly #incorrectlyModifiablePostMinus = 7;
+
+          public mutate() {
+            this.#incorrectlyModifiablePostMinus - 1;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop.doesSomething();
+        class TestIncorrectlyModifiablePostPlus {
+          private incorrectlyModifiablePostPlus = 7;
+
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
           }
         }
       `,
@@ -1215,29 +1163,32 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiablePostPlus',
           },
-          endColumn: 26,
+          endColumn: 48,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop.doesSomething();
+        class TestIncorrectlyModifiablePostPlus {
+          private readonly incorrectlyModifiablePostPlus = 7;
+
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj.prop.doesSomething();
+        class TestIncorrectlyModifiablePostPlus {
+          #incorrectlyModifiablePostPlus = 7;
+
+          public mutate() {
+            this.#incorrectlyModifiablePostPlus + 1;
           }
         }
       `,
@@ -1245,29 +1196,32 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiablePostPlus',
           },
-          endColumn: 19,
+          endColumn: 41,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj.prop.doesSomething();
+        class TestIncorrectlyModifiablePostPlus {
+          readonly #incorrectlyModifiablePostPlus = 7;
+
+          public mutate() {
+            this.#incorrectlyModifiablePostPlus + 1;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop.prop;
+        class TestIncorrectlyModifiablePreMinus {
+          private incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
           }
         }
       `,
@@ -1275,29 +1229,31 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiablePreMinus',
           },
-          endColumn: 26,
+          endColumn: 48,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop.prop;
+        class TestIncorrectlyModifiablePreMinus {
+          private readonly incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop.prop;
+        class TestIncorrectlyModifiablePreMinus {
+          #incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.#incorrectlyModifiablePreMinus;
           }
         }
       `,
@@ -1305,29 +1261,32 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiablePreMinus',
           },
-          endColumn: 19,
+          endColumn: 41,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop.prop;
+        class TestIncorrectlyModifiablePreMinus {
+          readonly #incorrectlyModifiablePreMinus = 7;
+
+          public mutate() {
+            -this.#incorrectlyModifiablePreMinus;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj?.prop?.prop;
+        class TestIncorrectlyModifiablePrePlus {
+          private incorrectlyModifiablePrePlus = 7;
+
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
           }
         }
       `,
@@ -1335,29 +1294,32 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiablePrePlus',
           },
-          endColumn: 26,
+          endColumn: 47,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj?.prop?.prop;
+        class TestIncorrectlyModifiablePrePlus {
+          private readonly incorrectlyModifiablePrePlus = 7;
+
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj?.prop?.prop;
+        class TestIncorrectlyModifiablePrePlus {
+          #incorrectlyModifiablePrePlus = 7;
+
+          public mutate() {
+            +this.#incorrectlyModifiablePrePlus;
           }
         }
       `,
@@ -1365,219 +1327,215 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: '#incorrectlyModifiablePrePlus',
           },
-          endColumn: 19,
+          endColumn: 40,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj?.prop?.prop;
+        class TestIncorrectlyModifiablePrePlus {
+          readonly #incorrectlyModifiablePrePlus = 7;
+
+          public mutate() {
+            +this.#incorrectlyModifiablePrePlus;
           }
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj.prop?.prop;
+        class TestOverlappingClassVariable {
+          private overlappingClassVariable = 7;
+
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
           }
         }
+
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
       `,
       errors: [
         {
           column: 11,
           data: {
-            name: 'testObj',
+            name: 'overlappingClassVariable',
           },
-          endColumn: 26,
+          endColumn: 43,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj.prop?.prop;
+        class TestOverlappingClassVariable {
+          private readonly overlappingClassVariable = 7;
+
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
           }
         }
+
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj.prop?.prop;
-          }
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private incorrectlyModifiableParameter = 7) {}
         }
       `,
       errors: [
         {
-          column: 11,
+          column: 30,
           data: {
-            name: '#testObj',
+            name: 'incorrectlyModifiableParameter',
           },
-          endColumn: 19,
+          endColumn: 68,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj.prop?.prop;
-          }
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private readonly incorrectlyModifiableParameter = 7) {}
         }
       `,
     },
     {
       code: `
-        class Test {
-          private testObj = {};
-          public test(): void {
-            this.testObj!.prop?.prop;
-          }
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private incorrectlyModifiableParameter = 7,
+          ) {}
         }
       `,
       errors: [
         {
-          column: 11,
+          column: 13,
           data: {
-            name: 'testObj',
+            name: 'incorrectlyModifiableParameter',
           },
-          endColumn: 26,
-          endLine: 3,
-          line: 3,
+          endColumn: 51,
+          endLine: 5,
+
+          line: 5,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly testObj = {};
-          public test(): void {
-            this.testObj!.prop?.prop;
-          }
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private readonly incorrectlyModifiableParameter = 7,
+          ) {}
         }
       `,
     },
     {
       code: `
-        class Test {
-          #testObj = {};
-          public test(): void {
-            this.#testObj!.prop?.prop;
-          }
+        class TestCorrectlyNonInlineLambdas {
+          private incorrectlyInlineLambda = () => 7;
         }
       `,
       errors: [
         {
           column: 11,
           data: {
-            name: '#testObj',
+            name: 'incorrectlyInlineLambda',
           },
-          endColumn: 19,
+          endColumn: 42,
           endLine: 3,
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
+      options: [
+        {
+          onlyInlineLambdas: true,
+        },
+      ],
       output: `
-        class Test {
-          readonly #testObj = {};
-          public test(): void {
-            this.#testObj!.prop?.prop;
-          }
+        class TestCorrectlyNonInlineLambdas {
+          private readonly incorrectlyInlineLambda = () => 7;
         }
       `,
     },
     {
       code: `
-        class Test {
-          private prop: number = 3;
-
-          test() {
-            const that = {} as this & { _foo: 'bar' };
-            that._foo = 1;
-          }
-        }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    private _name: string;
+  };
+}
       `,
       errors: [
         {
-          column: 11,
+          column: 5,
           data: {
-            name: 'prop',
+            name: '_name',
           },
-          endColumn: 23,
-          endLine: 3,
-          line: 3,
+          endColumn: 18,
+          endLine: 4,
+          line: 4,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly prop: number = 3;
-
-          test() {
-            const that = {} as this & { _foo: 'bar' };
-            that._foo = 1;
-          }
-        }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    private readonly _name: string;
+  };
+}
       `,
     },
     {
       code: `
-        class Test {
-          private prop: number = 3;
-
-          test() {
-            const that = {} as this | (this & { _foo: 'bar' });
-            that.prop;
-          }
-        }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    #name: string;
+  };
+}
       `,
       errors: [
         {
-          column: 11,
+          column: 5,
           data: {
-            name: 'prop',
+            name: '#name',
           },
-          endColumn: 23,
-          endLine: 3,
-          line: 3,
+          endColumn: 10,
+          endLine: 4,
+          line: 4,
           messageId: 'preferReadonly',
         },
       ],
       output: `
-        class Test {
-          private readonly prop: number = 3;
-
-          test() {
-            const that = {} as this | (this & { _foo: 'bar' });
-            that.prop;
-          }
-        }
+function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
+  return class extends Base {
+    readonly #name: string;
+  };
+}
       `,
     },
     {
       code: `
         class Test {
-          private prop: number;
+          private testObj = {
+            prop: '',
+          };
 
-          constructor() {
-            const that = {} as this & { _foo: 'bar' };
-            that.prop = 1;
+          public test(): void {
+            this.testObj.prop = '';
           }
         }
       `,
@@ -1585,753 +1543,795 @@ function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
         {
           column: 11,
           data: {
-            name: 'prop',
+            name: 'testObj',
           },
-          endColumn: 23,
+          endColumn: 26,
           endLine: 3,
+
           line: 3,
           messageId: 'preferReadonly',
         },
       ],
       output: `
         class Test {
-          private readonly prop: number;
+          private readonly testObj = {
+            prop: '',
+          };
 
-          constructor() {
-            const that = {} as this & { _foo: 'bar' };
-            that.prop = 1;
+          public test(): void {
+            this.testObj.prop = '';
           }
         }
       `,
     },
-  ],
-  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 TestReadonlyStatic {
-        static readonly #correctlyReadonlyStatic = 7;
-      }
-    `,
-    `
-      class TestModifiableStatic {
-        private static correctlyModifiableStatic = 7;
-
-        public constructor() {
-          TestModifiableStatic.correctlyModifiableStatic += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiableStatic {
-        static #correctlyModifiableStatic = 7;
-
-        public constructor() {
-          TestModifiableStatic.#correctlyModifiableStatic += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiableByParameterProperty {
-        private static readonly correctlyModifiableByParameterProperty = 7;
-
-        public constructor(
-          public correctlyModifiablePublicParameter: number = (() => {
-            return (TestModifiableStatic.correctlyModifiableByParameterProperty += 1);
-          })(),
-        ) {}
-      }
-    `,
-    `
-      class TestModifiableByParameterProperty {
-        static readonly #correctlyModifiableByParameterProperty = 7;
-
-        public constructor(
-          public correctlyModifiablePublicParameter: number = (() => {
-            return (TestModifiableStatic.#correctlyModifiableByParameterProperty += 1);
-          })(),
-        ) {}
-      }
-    `,
-    `
-      class TestReadonlyInline {
-        private readonly correctlyReadonlyInline = 7;
-      }
-    `,
-    `
-      class TestReadonlyInline {
-        readonly #correctlyReadonlyInline = 7;
-      }
-    `,
-    `
-      class TestReadonlyDelayed {
-        private readonly correctlyReadonlyDelayed = 7;
-
-        public constructor() {
-          this.correctlyReadonlyDelayed += 1;
-        }
-      }
-    `,
-    `
-      class TestReadonlyDelayed {
-        readonly #correctlyReadonlyDelayed = 7;
-
-        public constructor() {
-          this.#correctlyReadonlyDelayed += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiableInline {
-        private correctlyModifiableInline = 7;
-
-        public mutate() {
-          this.correctlyModifiableInline += 1;
-
-          return class {
-            private correctlyModifiableInline = 7;
-
-            mutate() {
-              this.correctlyModifiableInline += 1;
-            }
-          };
-        }
-      }
-    `,
-    `
-      class TestModifiableInline {
-        #correctlyModifiableInline = 7;
-
-        public mutate() {
-          this.#correctlyModifiableInline += 1;
-
-          return class {
-            #correctlyModifiableInline = 7;
-
-            mutate() {
-              this.#correctlyModifiableInline += 1;
-            }
+    {
+      code: `
+        class Test {
+          #testObj = {
+            prop: '',
           };
-        }
-      }
-    `,
-    `
-      class TestModifiableDelayed {
-        private correctlyModifiableDelayed = 7;
-
-        public mutate() {
-          this.correctlyModifiableDelayed += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiableDelayed {
-        #correctlyModifiableDelayed = 7;
-
-        public mutate() {
-          this.#correctlyModifiableDelayed += 1;
-        }
-      }
-    `,
-    `
-      class TestModifiableDeleted {
-        private correctlyModifiableDeleted = 7;
-
-        public mutate() {
-          delete this.correctlyModifiableDeleted;
-        }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructor {
-        private correctlyModifiableWithinConstructor = 7;
-
-        public constructor() {
-          (() => {
-            this.correctlyModifiableWithinConstructor += 1;
-          })();
-        }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructor {
-        #correctlyModifiableWithinConstructor = 7;
-
-        public constructor() {
-          (() => {
-            this.#correctlyModifiableWithinConstructor += 1;
-          })();
-        }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorArrowFunction {
-        private correctlyModifiableWithinConstructorArrowFunction = 7;
-
-        public constructor() {
-          (() => {
-            this.correctlyModifiableWithinConstructorArrowFunction += 1;
-          })();
-        }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorArrowFunction {
-        #correctlyModifiableWithinConstructorArrowFunction = 7;
 
-        public constructor() {
-          (() => {
-            this.#correctlyModifiableWithinConstructorArrowFunction += 1;
-          })();
+          public test(): void {
+            this.#testObj.prop = '';
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInFunctionExpression {
-        private correctlyModifiableWithinConstructorInFunctionExpression = 7;
-
-        public constructor() {
-          const self = this;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {
+            prop: '',
+          };
 
-          (() => {
-            self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
-          })();
+          public test(): void {
+            this.#testObj.prop = '';
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class TestObject {
+          public prop: number;
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInFunctionExpression {
-        #correctlyModifiableWithinConstructorInFunctionExpression = 7;
 
-        public constructor() {
-          const self = this;
+        class Test {
+          private testObj = new TestObject();
 
-          (() => {
-            self.#correctlyModifiableWithinConstructorInFunctionExpression += 1;
-          })();
+          public test(): void {
+            this.testObj.prop = 10;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestObject {
+          public prop: number;
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInGetAccessor {
-        private correctlyModifiableWithinConstructorInGetAccessor = 7;
 
-        public constructor() {
-          const self = this;
+        class Test {
+          private readonly testObj = new TestObject();
 
-          const confusingObject = {
-            get accessor() {
-              return (self.correctlyModifiableWithinConstructorInGetAccessor += 1);
-            },
-          };
+          public test(): void {
+            this.testObj.prop = 10;
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class TestObject {
+          public prop: number;
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInGetAccessor {
-        #correctlyModifiableWithinConstructorInGetAccessor = 7;
 
-        public constructor() {
-          const self = this;
+        class Test {
+          #testObj = new TestObject();
 
-          const confusingObject = {
-            get accessor() {
-              return (self.#correctlyModifiableWithinConstructorInGetAccessor += 1);
-            },
-          };
+          public test(): void {
+            this.#testObj.prop = 10;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 7,
+          line: 7,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class TestObject {
+          public prop: number;
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInMethodDeclaration {
-        private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
 
-        public constructor() {
-          const self = this;
+        class Test {
+          readonly #testObj = new TestObject();
 
-          const confusingObject = {
-            methodDeclaration() {
-              self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-            },
+          public test(): void {
+            this.#testObj.prop = 10;
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {
+            prop: '',
           };
+          public test(): void {
+            this.testObj.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInMethodDeclaration {
-        #correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-
-        public constructor() {
-          const self = this;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
 
-          const confusingObject = {
-            methodDeclaration() {
-              self.#correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-            },
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {
+            prop: '',
           };
+          public test(): void {
+            this.testObj.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInSetAccessor {
-        private correctlyModifiableWithinConstructorInSetAccessor = 7;
-
-        public constructor() {
-          const self = this;
-
-          const confusingObject = {
-            set accessor(value: number) {
-              self.correctlyModifiableWithinConstructorInSetAccessor += value;
-            },
+      `,
+    },
+    {
+      code: `
+        class Test {
+          #testObj = {
+            prop: '',
           };
+          public test(): void {
+            this.#testObj.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiableWithinConstructorInSetAccessor {
-        #correctlyModifiableWithinConstructorInSetAccessor = 7;
-
-        public constructor() {
-          const self = this;
-
-          const confusingObject = {
-            set accessor(value: number) {
-              self.#correctlyModifiableWithinConstructorInSetAccessor += value;
-            },
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {
+            prop: '',
           };
+          public test(): void {
+            this.#testObj.prop;
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop;
+          }
+        }
+      `,
+    },
+    {
+      code: `
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePostDecremented {
-        private correctlyModifiablePostDecremented = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
 
-        public mutate() {
-          this.correctlyModifiablePostDecremented -= 1;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePostDecremented {
-        #correctlyModifiablePostDecremented = 7;
-
-        public mutate() {
-          this.#correctlyModifiablePostDecremented -= 1;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj!.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestyModifiablePostIncremented {
-        private correctlyModifiablePostIncremented = 7;
-
-        public mutate() {
-          this.correctlyModifiablePostIncremented += 1;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj!.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestyModifiablePostIncremented {
-        #correctlyModifiablePostIncremented = 7;
-
-        public mutate() {
-          this.#correctlyModifiablePostIncremented += 1;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj!.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreDecremented {
-        private correctlyModifiablePreDecremented = 7;
-
-        public mutate() {
-          --this.correctlyModifiablePreDecremented;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj!.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreDecremented {
-        #correctlyModifiablePreDecremented = 7;
-
-        public mutate() {
-          --this.#correctlyModifiablePreDecremented;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop.prop = '';
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreIncremented {
-        private correctlyModifiablePreIncremented = 7;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
 
-        public mutate() {
-          ++this.correctlyModifiablePreIncremented;
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop.prop = '';
+          }
         }
-      }
-    `,
-    `
-      class TestModifiablePreIncremented {
-        #correctlyModifiablePreIncremented = 7;
-
-        public mutate() {
-          ++this.#correctlyModifiablePreIncremented;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj.prop.prop = '';
+          }
         }
-      }
-    `,
-    `
-      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;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj.prop.prop = '';
+          }
         }
-      }
-    `,
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop.doesSomething();
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop.doesSomething();
+          }
+        }
+      `,
+    },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          private correctlyNonInlineLambda = 7;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj.prop.doesSomething();
+          }
         }
       `,
-      options: [
+      errors: [
         {
-          onlyInlineLambdas: true,
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
         },
       ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj.prop.doesSomething();
+          }
+        }
+      `,
     },
     {
       code: `
-        class TestCorrectlyNonInlineLambdas {
-          #correctlyNonInlineLambda = 7;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop.prop;
+          }
         }
       `,
-      options: [
+      errors: [
         {
-          onlyInlineLambdas: true,
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
         },
       ],
-    },
-    `
-      class TestComputedParameter {
-        public mutate() {
-          this['computed'] = 1;
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestComputedParameter {
-        private ['computed-ignored-by-rule'] = 1;
-      }
-    `,
-    {
-      code: `
-class Foo {
-  private value: number = 0;
-
-  bar(newValue: { value: number }) {
-    ({ value: this.value } = newValue);
-    return this.value;
-  }
-}
-      `,
-    },
-    {
-      code: `
-class Foo {
-  #value: number = 0;
-
-  bar(newValue: { value: number }) {
-    ({ value: this.#value } = newValue);
-    return this.#value;
-  }
-}
       `,
     },
     {
       code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    private _name: string;
-
-    public test(value: string) {
-      this._name = value;
-    }
-  };
-}
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop.prop;
+          }
+        }
       `,
-    },
-    {
-      code: `
-function ClassWithName<TBase extends new (...args: any[]) => {}>(Base: TBase) {
-  return class extends Base {
-    #name: string;
-
-    public test(value: string) {
-      this.#name = value;
-    }
-  };
-}
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop.prop;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: Record<string, number> = {};
-
-  bar(newValue: Record<string, number>) {
-    ({ ...this.value } = newValue);
-    return this.value;
-  }
-}
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj?.prop?.prop;
+          }
+        }
       `,
-    },
-    {
-      code: `
-class Foo {
-  #value: Record<string, number> = {};
-
-  bar(newValue: Record<string, number>) {
-    ({ ...this.#value } = newValue);
-    return this.#value;
-  }
-}
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj?.prop?.prop;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: number[] = [];
-
-  bar(newValue: number[]) {
-    [...this.value] = newValue;
-    return this.value;
-  }
-}
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj?.prop?.prop;
+          }
+        }
       `,
-    },
-    {
-      code: `
-class Foo {
-  #value: number[] = [];
-
-  bar(newValue: number[]) {
-    [...this.#value] = newValue;
-    return this.#value;
-  }
-}
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          readonly #testObj = {};
+          public test(): void {
+            this.#testObj?.prop?.prop;
+          }
+        }
       `,
     },
     {
       code: `
-class Foo {
-  private value: number = 0;
-
-  bar(newValue: number[]) {
-    [this.value] = newValue;
-    return this.value;
-  }
-}
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj.prop?.prop;
+          }
+        }
       `,
-    },
-    {
-      code: `
-class Foo {
-  #value: number = 0;
-
-  bar(newValue: number[]) {
-    [this.#value] = newValue;
-    return this.#value;
-  }
-}
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly testObj = {};
+          public test(): void {
+            this.testObj.prop?.prop;
+          }
+        }
       `,
     },
     {
       code: `
         class Test {
-          private testObj = {
-            prop: '',
-          };
-
+          #testObj = {};
           public test(): void {
-            this.testObj = '';
+            this.#testObj.prop?.prop;
           }
         }
       `,
-    },
-    {
-      code: `
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
         class Test {
-          #testObj = {
-            prop: '',
-          };
-
+          readonly #testObj = {};
           public test(): void {
-            this.#testObj = '';
+            this.#testObj.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestObject {
-          public prop: number;
+        class Test {
+          private testObj = {};
+          public test(): void {
+            this.testObj!.prop?.prop;
+          }
         }
-
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'testObj',
+          },
+          endColumn: 26,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
         class Test {
-          private testObj = new TestObject();
-
+          private readonly testObj = {};
           public test(): void {
-            this.testObj = new TestObject();
+            this.testObj!.prop?.prop;
           }
         }
       `,
     },
     {
       code: `
-        class TestObject {
-          public prop: number;
+        class Test {
+          #testObj = {};
+          public test(): void {
+            this.#testObj!.prop?.prop;
+          }
         }
-
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: '#testObj',
+          },
+          endColumn: 19,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
         class Test {
-          #testObj = new TestObject();
-
+          readonly #testObj = {};
           public test(): void {
-            this.#testObj = new TestObject();
+            this.#testObj!.prop?.prop;
           }
         }
       `,
     },
-    `
-      class TestIntersection {
-        private prop: number = 3;
+    {
+      code: `
+        class Test {
+          private prop: number = 3;
 
-        test() {
-          const that = {} as this & { _foo: 'bar' };
-          that.prop = 1;
+          test() {
+            const that = {} as this & { _foo: 'bar' };
+            that._foo = 1;
+          }
         }
-      }
-    `,
-    `
-      class TestUnion {
-        private prop: number = 3;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'prop',
+          },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly prop: number = 3;
 
-        test() {
-          const that = {} as this | (this & { _foo: 'bar' });
-          that.prop = 1;
+          test() {
+            const that = {} as this & { _foo: 'bar' };
+            that._foo = 1;
+          }
         }
-      }
-    `,
-    `
-      class TestStaticIntersection {
-        private static prop: number;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private prop: number = 3;
 
-        test() {
-          const that = {} as typeof TestStaticIntersection & { _foo: 'bar' };
-          that.prop = 1;
+          test() {
+            const that = {} as this | (this & { _foo: 'bar' });
+            that.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestStaticUnion {
-        private static prop: number = 1;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'prop',
+          },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly prop: number = 3;
 
-        test() {
-          const that = {} as
-            | typeof TestStaticUnion
-            | (typeof TestStaticUnion & { _foo: 'bar' });
-          that.prop = 1;
+          test() {
+            const that = {} as this | (this & { _foo: 'bar' });
+            that.prop;
+          }
         }
-      }
-    `,
-    `
-      class TestBothIntersection {
-        private prop1: number = 1;
-        private static prop2: number;
+      `,
+    },
+    {
+      code: `
+        class Test {
+          private prop: number;
 
-        test() {
-          const that = {} as typeof TestBothIntersection & this;
-          that.prop1 = 1;
-          that.prop2 = 1;
+          constructor() {
+            const that = {} as this & { _foo: 'bar' };
+            that.prop = 1;
+          }
         }
-      }
-    `,
-    `
-      class TestBothIntersection {
-        private prop1: number = 1;
-        private static prop2: number;
+      `,
+      errors: [
+        {
+          column: 11,
+          data: {
+            name: 'prop',
+          },
+          endColumn: 23,
+          endLine: 3,
+          line: 3,
+          messageId: 'preferReadonly',
+        },
+      ],
+      output: `
+        class Test {
+          private readonly prop: number;
 
-        test() {
-          const that = {} as this & typeof TestBothIntersection;
-          that.prop1 = 1;
-          that.prop2 = 1;
+          constructor() {
+            const that = {} as this & { _foo: 'bar' };
+            that.prop = 1;
+          }
         }
-      }
-    `,
-    `
-      class TestStaticPrivateAccessor {
-        private static accessor staticAcc = 1;
-      }
-    `,
-    `
-      class TestStaticPrivateFieldAccessor {
-        static accessor #staticAcc = 1;
-      }
-    `,
-    `
-      class TestPrivateAccessor {
-        private accessor acc = 3;
-      }
-    `,
-    `
-      class TestPrivateFieldAccessor {
-        accessor #acc = 3;
-      }
-    `,
+      `,
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
index b6fbfe94456b..170622d6f599 100644
--- a/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts
@@ -15,6 +15,49 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-reduce-type-parameter', rule, {
+  valid: [
+    `
+      new (class Mine {
+        reduce() {}
+      })().reduce(() => {}, 1 as any);
+    `,
+    `
+      class Mine {
+        reduce() {}
+      }
+
+      new Mine().reduce(() => {}, 1 as any);
+    `,
+    `
+      import { Reducable } from './class';
+
+      new Reducable().reduce(() => {}, 1 as any);
+    `,
+    "[1, 2, 3]['reduce']((sum, num) => sum + num, 0);",
+    '[1, 2, 3][null]((sum, num) => sum + num, 0);',
+    '[1, 2, 3]?.[null]((sum, num) => sum + num, 0);',
+    '[1, 2, 3].reduce((sum, num) => sum + num, 0);',
+    '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
+    '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
+    `
+      declare const tuple: [number, number, number];
+      tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
+    `,
+    `
+      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
+      declare const tuple: [number, number, number] | Reducer;
+      tuple.reduce(a => {
+        return a.concat(1);
+      }, [] as number[]);
+    `,
+    `
+      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
+      declare const arrayOrReducer: number[] & Reducer;
+      arrayOrReducer.reduce(a => {
+        return a.concat(1);
+      }, [] as number[]);
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -233,47 +276,4 @@ tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
       `,
     },
   ],
-  valid: [
-    `
-      new (class Mine {
-        reduce() {}
-      })().reduce(() => {}, 1 as any);
-    `,
-    `
-      class Mine {
-        reduce() {}
-      }
-
-      new Mine().reduce(() => {}, 1 as any);
-    `,
-    `
-      import { Reducable } from './class';
-
-      new Reducable().reduce(() => {}, 1 as any);
-    `,
-    "[1, 2, 3]['reduce']((sum, num) => sum + num, 0);",
-    '[1, 2, 3][null]((sum, num) => sum + num, 0);',
-    '[1, 2, 3]?.[null]((sum, num) => sum + num, 0);',
-    '[1, 2, 3].reduce((sum, num) => sum + num, 0);',
-    '[1, 2, 3].reduce<number[]>((a, s) => a.concat(s * 2), []);',
-    '[1, 2, 3]?.reduce<number[]>((a, s) => a.concat(s * 2), []);',
-    `
-      declare const tuple: [number, number, number];
-      tuple.reduce<number[]>((a, s) => a.concat(s * 2), []);
-    `,
-    `
-      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
-      declare const tuple: [number, number, number] | Reducer;
-      tuple.reduce(a => {
-        return a.concat(1);
-      }, [] as number[]);
-    `,
-    `
-      type Reducer = { reduce: (callback: (arg: any) => any, arg: any) => any };
-      declare const arrayOrReducer: number[] & Reducer;
-      arrayOrReducer.reduce(a => {
-        return a.concat(1);
-      }, [] as number[]);
-    `,
-  ],
 });
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 012364ca9f02..e107208a9a3d 100644
--- a/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
@@ -15,6 +15,97 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-regexp-exec', rule, {
+  valid: [
+    "'something'.match();",
+    "'something'.match(/thing/g);",
+    `
+const text = 'something';
+const search = /thing/g;
+text.match(search);
+    `,
+    `
+const match = (s: RegExp) => 'something';
+match(/thing/);
+    `,
+    `
+const a = { match: (s: RegExp) => 'something' };
+a.match(/thing/);
+    `,
+    `
+function f(s: string | string[]) {
+  s.match(/e/);
+}
+    `,
+    "(Math.random() > 0.5 ? 'abc' : 123).match(2);",
+    "'212'.match(2);",
+    "'212'.match(+2);",
+    "'oNaNo'.match(NaN);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(Infinity);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(+Infinity);",
+    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(-Infinity);",
+    "'void and null'.match(null);",
+    `
+const matchers = ['package-lock.json', /regexp/];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    `
+const matchers = [/regexp/, 'package-lock.json'];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    `
+const matchers = [{ match: (s: RegExp) => false }];
+const file = '';
+matchers.some(matcher => !!file.match(matcher));
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+function test(pattern: string) {
+  'hello hello'.match(RegExp(pattern, 'g'))?.reduce(() => []);
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+function test(pattern: string) {
+  'hello hello'.match(new RegExp(pattern, 'gi'))?.reduce(() => []);
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
+    `
+const matchCount = (str: string, re: RegExp) => {
+  return (str.match(re) || []).length;
+};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6928
+    `
+function test(str: string) {
+  str.match('[a-z');
+}
+    `,
+    {
+      code: `
+const text = 'something';
+declare const search: RegExp;
+text.match(search);
+      `,
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8614
+    {
+      code: `
+const text = 'something';
+declare const obj: { search: RegExp };
+text.match(obj.search);
+      `,
+    },
+    {
+      code: `
+const text = 'something';
+declare function returnsRegexp(): RegExp;
+text.match(returnsRegexp());
+      `,
+    },
+  ],
   invalid: [
     {
       code: "'something'.match(/thing/);",
@@ -201,95 +292,4 @@ function temp(text: string): void {
       `,
     },
   ],
-  valid: [
-    "'something'.match();",
-    "'something'.match(/thing/g);",
-    `
-const text = 'something';
-const search = /thing/g;
-text.match(search);
-    `,
-    `
-const match = (s: RegExp) => 'something';
-match(/thing/);
-    `,
-    `
-const a = { match: (s: RegExp) => 'something' };
-a.match(/thing/);
-    `,
-    `
-function f(s: string | string[]) {
-  s.match(/e/);
-}
-    `,
-    "(Math.random() > 0.5 ? 'abc' : 123).match(2);",
-    "'212'.match(2);",
-    "'212'.match(+2);",
-    "'oNaNo'.match(NaN);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(Infinity);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(+Infinity);",
-    "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(-Infinity);",
-    "'void and null'.match(null);",
-    `
-const matchers = ['package-lock.json', /regexp/];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    `
-const matchers = [/regexp/, 'package-lock.json'];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    `
-const matchers = [{ match: (s: RegExp) => false }];
-const file = '';
-matchers.some(matcher => !!file.match(matcher));
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-function test(pattern: string) {
-  'hello hello'.match(RegExp(pattern, 'g'))?.reduce(() => []);
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-function test(pattern: string) {
-  'hello hello'.match(new RegExp(pattern, 'gi'))?.reduce(() => []);
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/3477
-    `
-const matchCount = (str: string, re: RegExp) => {
-  return (str.match(re) || []).length;
-};
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/6928
-    `
-function test(str: string) {
-  str.match('[a-z');
-}
-    `,
-    {
-      code: `
-const text = 'something';
-declare const search: RegExp;
-text.match(search);
-      `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8614
-    {
-      code: `
-const text = 'something';
-declare const obj: { search: RegExp };
-text.match(obj.search);
-      `,
-    },
-    {
-      code: `
-const text = 'something';
-declare function returnsRegexp(): RegExp;
-text.match(returnsRegexp());
-      `,
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts b/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
index 8f7fb17bfc67..4a9262e92ce9 100644
--- a/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-return-this-type.test.ts
@@ -15,6 +15,73 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-return-this-type', rule, {
+  valid: [
+    `
+class Foo {
+  f1() {}
+  f2(): Foo {
+    return new Foo();
+  }
+  f3() {
+    return this;
+  }
+  f4(): this {
+    return this;
+  }
+  f5(): any {
+    return this;
+  }
+  f6(): unknown {
+    return this;
+  }
+  f7(foo: Foo): Foo {
+    return Math.random() > 0.5 ? foo : this;
+  }
+  f10(this: Foo, that: Foo): Foo;
+  f11(): Foo {
+    return;
+  }
+  f13(this: Foo): Foo {
+    return this;
+  }
+  f14(): { f14: Function } {
+    return this;
+  }
+  f15(): Foo | this {
+    return Math.random() > 0.5 ? new Foo() : this;
+  }
+}
+    `,
+    `
+class Foo {
+  f1 = () => {};
+  f2 = (): Foo => {
+    return new Foo();
+  };
+  f3 = () => this;
+  f4 = (): this => {
+    return this;
+  };
+  f5 = (): Foo => new Foo();
+  f6 = '';
+}
+    `,
+    `
+const Foo = class {
+  bar() {
+    return this;
+  }
+};
+    `,
+    `
+class Base {}
+class Derived extends Base {
+  f(): Base {
+    return this;
+  }
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -248,71 +315,4 @@ class Animal<T> {
       `,
     },
   ],
-  valid: [
-    `
-class Foo {
-  f1() {}
-  f2(): Foo {
-    return new Foo();
-  }
-  f3() {
-    return this;
-  }
-  f4(): this {
-    return this;
-  }
-  f5(): any {
-    return this;
-  }
-  f6(): unknown {
-    return this;
-  }
-  f7(foo: Foo): Foo {
-    return Math.random() > 0.5 ? foo : this;
-  }
-  f10(this: Foo, that: Foo): Foo;
-  f11(): Foo {
-    return;
-  }
-  f13(this: Foo): Foo {
-    return this;
-  }
-  f14(): { f14: Function } {
-    return this;
-  }
-  f15(): Foo | this {
-    return Math.random() > 0.5 ? new Foo() : this;
-  }
-}
-    `,
-    `
-class Foo {
-  f1 = () => {};
-  f2 = (): Foo => {
-    return new Foo();
-  };
-  f3 = () => this;
-  f4 = (): this => {
-    return this;
-  };
-  f5 = (): Foo => new Foo();
-  f6 = '';
-}
-    `,
-    `
-const Foo = class {
-  bar() {
-    return this;
-  }
-};
-    `,
-    `
-class Base {}
-class Derived extends Base {
-  f(): Base {
-    return this;
-  }
-}
-    `,
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
index 3c6eb5115a4e..798d26cb3916 100644
--- a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
@@ -15,884 +15,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('prefer-string-starts-ends-with', rule, {
-  invalid: [
-    // String indexing.
-    {
-      code: `
-        function f(s: string) {
-          s[0] === 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s?.[0] === 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s?.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[0] !== 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s?.[0] !== 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s?.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[0] == 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[0] != 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[0] === 'あ';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('あ');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[0] === '👍'; // the length is 2.
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string, t: string) {
-          s[0] === t; // the length of t is unknown.
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s[s.length - 1] === 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('a');
-        }
-      `,
-    },
-    {
-      code: noFormat`
-        function f(s: string) {
-          (s)[0] === ("a")
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          (s).startsWith("a")
-        }
-      `,
-    },
-
-    // String#charAt
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) === 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) !== 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) == 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) != 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('a');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) === 'あ';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('あ');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(0) === '👍'; // the length is 2.
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string, t: string) {
-          s.charAt(0) === t; // the length of t is unknown.
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.charAt(s.length - 1) === 'a';
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('a');
-        }
-      `,
-    },
-    {
-      code: noFormat`
-        function f(s: string) {
-          (s).charAt(0) === "a";
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          (s).startsWith("a");
-        }
-      `,
-    },
-
-    // String#indexOf
-    {
-      code: `
-        function f(s: string) {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s?.indexOf(needle) === 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s?.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.indexOf(needle) !== 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.indexOf(needle) == 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.indexOf(needle) != 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith(needle);
-        }
-      `,
-    },
-
-    // String#lastIndexOf
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf('bar') === s.length - 3;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf('bar') !== s.length - 3;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          !s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf('bar') == s.length - 3;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf('bar') != s.length - 3;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          !s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf('bar') === s.length - 'bar'.length;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.lastIndexOf(needle) === s.length - needle.length;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith(needle);
-        }
-      `,
-    },
-
-    // String#match
-    {
-      code: `
-        function f(s: string) {
-          s.match(/^bar/) !== null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s?.match(/^bar/) !== null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s?.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/^bar/) != null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/bar$/) !== null;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/bar$/) != null;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/^bar/) === null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/^bar/) == null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/bar$/) === null;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          !s.endsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.match(/bar$/) == null;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          !s.endsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = /^bar/;
-        function f(s: string) {
-          s.match(pattern) != null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = /^bar/;
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = new RegExp('^bar');
-        function f(s: string) {
-          s.match(pattern) != null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = new RegExp('^bar');
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = /^"quoted"/;
-        function f(s: string) {
-          s.match(pattern) != null;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = /^"quoted"/;
-        function f(s: string) {
-          s.startsWith("\\"quoted\\"");
-        }
-      `,
-    },
-
-    // String#slice
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, 3) === 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s?.slice(0, 3) === 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s?.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, 3) !== 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, 3) == 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, 3) != 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          !s.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, needle.length) === needle;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(0, needle.length) == needle; // hating implicit type conversion
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(-3) === 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(-3) !== 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          !s.endsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(-needle.length) === needle;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.slice(s.length - needle.length) === needle;
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.substring(0, 3) === 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith('bar');
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.substring(-3) === 'bar'; // the code is probably mistake.
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: null,
-    },
-    {
-      code: `
-        function f(s: string) {
-          s.substring(s.length - 3, s.length) === 'bar';
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith('bar');
-        }
-      `,
-    },
-
-    // RegExp#test
-    {
-      code: `
-        function f(s: string) {
-          /^bar/.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          /^bar/?.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          s?.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          /bar$/.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferEndsWith' }],
-      output: `
-        function f(s: string) {
-          s.endsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = /^bar/;
-        function f(s: string) {
-          pattern.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = /^bar/;
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = new RegExp('^bar');
-        function f(s: string) {
-          pattern.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = new RegExp('^bar');
-        function f(s: string) {
-          s.startsWith("bar");
-        }
-      `,
-    },
-    {
-      code: `
-        const pattern = /^"quoted"/;
-        function f(s: string) {
-          pattern.test(s);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        const pattern = /^"quoted"/;
-        function f(s: string) {
-          s.startsWith("\\"quoted\\"");
-        }
-      `,
-    },
-    {
-      code: `
-        function f(s: string) {
-          /^bar/.test(a + b);
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: string) {
-          (a + b).startsWith("bar");
-        }
-      `,
-    },
-
-    // Test for variation of string types.
-    {
-      code: `
-        function f(s: 'a' | 'b') {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f(s: 'a' | 'b') {
-          s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        function f<T extends 'a' | 'b'>(s: T) {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        function f<T extends 'a' | 'b'>(s: T) {
-          s.startsWith(needle);
-        }
-      `,
-    },
-    {
-      code: `
-        type SafeString = string & { __HTML_ESCAPED__: void };
-        function f(s: SafeString) {
-          s.indexOf(needle) === 0;
-        }
-      `,
-      errors: [{ messageId: 'preferStartsWith' }],
-      output: `
-        type SafeString = string & { __HTML_ESCAPED__: void };
-        function f(s: SafeString) {
-          s.startsWith(needle);
-        }
-      `,
-    },
-  ],
   valid: [
     `
       function f(s: string[]) {
@@ -1177,17 +299,895 @@ ruleTester.run('prefer-string-starts-ends-with', rule, {
     `,
     {
       code: `
-        declare const s: string;
-        s[0] === 'a';
+        declare const s: string;
+        s[0] === 'a';
+      `,
+      options: [{ allowSingleElementEquality: 'always' }],
+    },
+    {
+      code: `
+        declare const s: string;
+        s[s.length - 1] === 'a';
+      `,
+      options: [{ allowSingleElementEquality: 'always' }],
+    },
+  ],
+  invalid: [
+    // String indexing.
+    {
+      code: `
+        function f(s: string) {
+          s[0] === 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s?.[0] === 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s?.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] !== 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s?.[0] !== 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s?.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] == 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] != 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] === 'あ';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('あ');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] === '👍'; // the length is 2.
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string, t: string) {
+          s[0] === t; // the length of t is unknown.
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[s.length - 1] === 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('a');
+        }
+      `,
+    },
+    {
+      code: noFormat`
+        function f(s: string) {
+          (s)[0] === ("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          (s).startsWith("a")
+        }
+      `,
+    },
+
+    // String#charAt
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) !== 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) == 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) != 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('a');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === 'あ';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('あ');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === '👍'; // the length is 2.
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string, t: string) {
+          s.charAt(0) === t; // the length of t is unknown.
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(s.length - 1) === 'a';
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('a');
+        }
+      `,
+    },
+    {
+      code: noFormat`
+        function f(s: string) {
+          (s).charAt(0) === "a";
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          (s).startsWith("a");
+        }
+      `,
+    },
+
+    // String#indexOf
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s?.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s?.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) !== 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) == 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) != 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith(needle);
+        }
+      `,
+    },
+
+    // String#lastIndexOf
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf('bar') === s.length - 3;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf('bar') !== s.length - 3;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          !s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf('bar') == s.length - 3;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf('bar') != s.length - 3;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          !s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf('bar') === s.length - 'bar'.length;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf(needle) === s.length - needle.length;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith(needle);
+        }
+      `,
+    },
+
+    // String#match
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) !== null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s?.match(/^bar/) !== null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s?.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) != null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) !== null;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) != null;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) === null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) == null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) === null;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) == null;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = /^bar/;
+        function f(s: string) {
+          s.match(pattern) != null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = /^bar/;
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = new RegExp('^bar');
+        function f(s: string) {
+          s.match(pattern) != null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = new RegExp('^bar');
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = /^"quoted"/;
+        function f(s: string) {
+          s.match(pattern) != null;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = /^"quoted"/;
+        function f(s: string) {
+          s.startsWith("\\"quoted\\"");
+        }
+      `,
+    },
+
+    // String#slice
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) === 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s?.slice(0, 3) === 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s?.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) !== 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) == 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) != 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          !s.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, needle.length) === needle;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith(needle);
+        }
       `,
-      options: [{ allowSingleElementEquality: 'always' }],
     },
     {
       code: `
-        declare const s: string;
-        s[s.length - 1] === 'a';
+        function f(s: string) {
+          s.slice(0, needle.length) == needle; // hating implicit type conversion
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-3) === 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-3) !== 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          !s.endsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-needle.length) === needle;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(s.length - needle.length) === needle;
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(0, 3) === 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith('bar');
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(-3) === 'bar'; // the code is probably mistake.
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: null,
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(s.length - 3, s.length) === 'bar';
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith('bar');
+        }
+      `,
+    },
+
+    // RegExp#test
+    {
+      code: `
+        function f(s: string) {
+          /^bar/.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          /^bar/?.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          s?.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          /bar$/.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+      output: `
+        function f(s: string) {
+          s.endsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = /^bar/;
+        function f(s: string) {
+          pattern.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = /^bar/;
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = new RegExp('^bar');
+        function f(s: string) {
+          pattern.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = new RegExp('^bar');
+        function f(s: string) {
+          s.startsWith("bar");
+        }
+      `,
+    },
+    {
+      code: `
+        const pattern = /^"quoted"/;
+        function f(s: string) {
+          pattern.test(s);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        const pattern = /^"quoted"/;
+        function f(s: string) {
+          s.startsWith("\\"quoted\\"");
+        }
+      `,
+    },
+    {
+      code: `
+        function f(s: string) {
+          /^bar/.test(a + b);
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: string) {
+          (a + b).startsWith("bar");
+        }
+      `,
+    },
+
+    // Test for variation of string types.
+    {
+      code: `
+        function f(s: 'a' | 'b') {
+          s.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f(s: 'a' | 'b') {
+          s.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        function f<T extends 'a' | 'b'>(s: T) {
+          s.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        function f<T extends 'a' | 'b'>(s: T) {
+          s.startsWith(needle);
+        }
+      `,
+    },
+    {
+      code: `
+        type SafeString = string & { __HTML_ESCAPED__: void };
+        function f(s: SafeString) {
+          s.indexOf(needle) === 0;
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+      output: `
+        type SafeString = string & { __HTML_ESCAPED__: void };
+        function f(s: SafeString) {
+          s.startsWith(needle);
+        }
       `,
-      options: [{ allowSingleElementEquality: 'always' }],
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
index 1c83d14b4ce8..d36766b60a81 100644
--- a/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts
@@ -5,6 +5,34 @@ import rule from '../../src/rules/prefer-ts-expect-error';
 const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-ts-expect-error', rule, {
+  valid: [
+    '// @ts-nocheck',
+    '// @ts-check',
+    '// just a comment containing @ts-ignore somewhere',
+    `
+{
+  /*
+        just a comment containing @ts-ignore somewhere in a block
+      */
+}
+    `,
+    '// @ts-expect-error',
+    `
+if (false) {
+  // @ts-expect-error: Unreachable code error
+  console.log('hello');
+}
+    `,
+    `
+/**
+ * Explaining comment
+ *
+ * @ts-expect-error
+ *
+ * Not last line
+ * */
+    `,
+  ],
   invalid: [
     {
       code: '// @ts-ignore',
@@ -122,32 +150,4 @@ if (false) {
       `,
     },
   ],
-  valid: [
-    '// @ts-nocheck',
-    '// @ts-check',
-    '// just a comment containing @ts-ignore somewhere',
-    `
-{
-  /*
-        just a comment containing @ts-ignore somewhere in a block
-      */
-}
-    `,
-    '// @ts-expect-error',
-    `
-if (false) {
-  // @ts-expect-error: Unreachable code error
-  console.log('hello');
-}
-    `,
-    `
-/**
- * Explaining comment
- *
- * @ts-expect-error
- *
- * Not last line
- * */
-    `,
-  ],
 });
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 f6f3cb307e07..51473ffaea00 100644
--- a/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
+++ b/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
@@ -16,6 +16,173 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('promise-function-async', rule, {
+  valid: [
+    `
+const nonAsyncNonPromiseArrowFunction = (n: number) => n;
+    `,
+    `
+function nonAsyncNonPromiseFunctionDeclaration(n: number) {
+  return n;
+}
+    `,
+    `
+const asyncPromiseFunctionExpressionA = async function (p: Promise<void>) {
+  return p;
+};
+    `,
+    `
+const asyncPromiseFunctionExpressionB = async function () {
+  return new Promise<void>();
+};
+    `,
+    `
+class Test {
+  public nonAsyncNonPromiseArrowFunction = (n: number) => n;
+  public nonAsyncNonPromiseMethod() {
+    return 0;
+  }
+
+  public async asyncPromiseMethodA(p: Promise<void>) {
+    return p;
+  }
+
+  public async asyncPromiseMethodB() {
+    return new Promise<void>();
+  }
+}
+    `,
+    `
+class InvalidAsyncModifiers {
+  public constructor() {
+    return new Promise<void>();
+  }
+  public get asyncGetter() {
+    return new Promise<void>();
+  }
+  public set asyncGetter(p: Promise<void>) {
+    return p;
+  }
+  public get asyncGetterFunc() {
+    return async () => new Promise<void>();
+  }
+  public set asyncGetterFunc(p: () => Promise<void>) {
+    return p;
+  }
+}
+    `,
+    `
+const invalidAsyncModifiers = {
+  get asyncGetter() {
+    return new Promise<void>();
+  },
+  set asyncGetter(p: Promise<void>) {
+    return p;
+  },
+  get asyncGetterFunc() {
+    return async () => new Promise<void>();
+  },
+  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() {}
+      }
+    `,
+    `
+class Foo {
+  async catch<T>(arg: Promise<T>) {
+    return arg;
+  }
+}
+    `,
+    {
+      code: `
+function returnsAny(): any {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
+    {
+      code: `
+function returnsUnknown(): unknown {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
+    {
+      code: `
+interface ReadableStream {}
+interface Options {
+  stream: ReadableStream;
+}
+
+type Return = ReadableStream | Promise<void>;
+const foo = (options: Options): Return => {
+  return options.stream ? asStream(options) : asPromise(options);
+};
+      `,
+    },
+    {
+      code: `
+function foo(): Promise<string> | boolean {
+  return Math.random() > 0.5 ? Promise.resolve('value') : false;
+}
+      `,
+    },
+    {
+      code: `
+abstract class Test {
+  abstract test1(): Promise<number>;
+
+  // abstract method with body is always an error but it still parses into valid AST
+  abstract test2(): Promise<number> {
+    return Promise.resolve(1);
+  }
+}
+      `,
+    },
+    `
+function promiseInUnionWithExplicitReturnType(
+  p: boolean,
+): Promise<number> | number {
+  return p ? Promise.resolve(5) : 5;
+}
+    `,
+    `
+function explicitReturnWithPromiseInUnion(): Promise<number> | number {
+  return 5;
+}
+    `,
+    `
+async function asyncFunctionReturningUnion(p: boolean) {
+  return p ? Promise.resolve(5) : 5;
+}
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -622,171 +789,4 @@ async function promiseInUnionWithoutExplicitReturnType(p: boolean) {
       `,
     },
   ],
-  valid: [
-    `
-const nonAsyncNonPromiseArrowFunction = (n: number) => n;
-    `,
-    `
-function nonAsyncNonPromiseFunctionDeclaration(n: number) {
-  return n;
-}
-    `,
-    `
-const asyncPromiseFunctionExpressionA = async function (p: Promise<void>) {
-  return p;
-};
-    `,
-    `
-const asyncPromiseFunctionExpressionB = async function () {
-  return new Promise<void>();
-};
-    `,
-    `
-class Test {
-  public nonAsyncNonPromiseArrowFunction = (n: number) => n;
-  public nonAsyncNonPromiseMethod() {
-    return 0;
-  }
-
-  public async asyncPromiseMethodA(p: Promise<void>) {
-    return p;
-  }
-
-  public async asyncPromiseMethodB() {
-    return new Promise<void>();
-  }
-}
-    `,
-    `
-class InvalidAsyncModifiers {
-  public constructor() {
-    return new Promise<void>();
-  }
-  public get asyncGetter() {
-    return new Promise<void>();
-  }
-  public set asyncGetter(p: Promise<void>) {
-    return p;
-  }
-  public get asyncGetterFunc() {
-    return async () => new Promise<void>();
-  }
-  public set asyncGetterFunc(p: () => Promise<void>) {
-    return p;
-  }
-}
-    `,
-    `
-const invalidAsyncModifiers = {
-  get asyncGetter() {
-    return new Promise<void>();
-  },
-  set asyncGetter(p: Promise<void>) {
-    return p;
-  },
-  get asyncGetterFunc() {
-    return async () => new Promise<void>();
-  },
-  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() {}
-      }
-    `,
-    `
-class Foo {
-  async catch<T>(arg: Promise<T>) {
-    return arg;
-  }
-}
-    `,
-    {
-      code: `
-function returnsAny(): any {
-  return 0;
-}
-      `,
-      options: [
-        {
-          allowAny: true,
-        },
-      ],
-    },
-    {
-      code: `
-function returnsUnknown(): unknown {
-  return 0;
-}
-      `,
-      options: [
-        {
-          allowAny: true,
-        },
-      ],
-    },
-    {
-      code: `
-interface ReadableStream {}
-interface Options {
-  stream: ReadableStream;
-}
-
-type Return = ReadableStream | Promise<void>;
-const foo = (options: Options): Return => {
-  return options.stream ? asStream(options) : asPromise(options);
-};
-      `,
-    },
-    {
-      code: `
-function foo(): Promise<string> | boolean {
-  return Math.random() > 0.5 ? Promise.resolve('value') : false;
-}
-      `,
-    },
-    {
-      code: `
-abstract class Test {
-  abstract test1(): Promise<number>;
-
-  // abstract method with body is always an error but it still parses into valid AST
-  abstract test2(): Promise<number> {
-    return Promise.resolve(1);
-  }
-}
-      `,
-    },
-    `
-function promiseInUnionWithExplicitReturnType(
-  p: boolean,
-): Promise<number> | number {
-  return p ? Promise.resolve(5) : 5;
-}
-    `,
-    `
-function explicitReturnWithPromiseInUnion(): Promise<number> | number {
-  return 5;
-}
-    `,
-    `
-async function asyncFunctionReturningUnion(p: boolean) {
-  return p ? Promise.resolve(5) : 5;
-}
-    `,
-  ],
 });
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 e144819fa1dc..d4735efe231d 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,6 +15,126 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('require-array-sort-compare', rule, {
+  valid: [
+    `
+      function f(a: any[]) {
+        a.sort(undefined);
+      }
+    `,
+    `
+      function f(a: any[]) {
+        a.sort((a, b) => a - b);
+      }
+    `,
+    `
+      function f(a: Array<string>) {
+        a.sort(undefined);
+      }
+    `,
+    `
+      function f(a: Array<number>) {
+        a.sort((a, b) => a - b);
+      }
+    `,
+    `
+      function f(a: { sort(): void }) {
+        a.sort();
+      }
+    `,
+    `
+      class A {
+        sort(): void {}
+      }
+      function f(a: A) {
+        a.sort();
+      }
+    `,
+    `
+      interface A {
+        sort(): void;
+      }
+      function f(a: A) {
+        a.sort();
+      }
+    `,
+    `
+      interface A {
+        sort(): void;
+      }
+      function f<T extends A>(a: T) {
+        a.sort();
+      }
+    `,
+    `
+      function f(a: any) {
+        a.sort();
+      }
+    `,
+    `
+      namespace UserDefined {
+        interface Array {
+          sort(): void;
+        }
+        function f(a: Array) {
+          a.sort();
+        }
+      }
+    `,
+    // optional chain
+    `
+      function f(a: any[]) {
+        a?.sort((a, b) => a - b);
+      }
+    `,
+    `
+      namespace UserDefined {
+        interface Array {
+          sort(): void;
+        }
+        function f(a: Array) {
+          a?.sort();
+        }
+      }
+    `,
+    {
+      code: `
+        ['foo', 'bar', 'baz'].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        function getString() {
+          return 'foo';
+        }
+        [getString(), getString()].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        const foo = 'foo';
+        const bar = 'bar';
+        const baz = 'baz';
+        [foo, bar, baz].sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        declare const x: string[];
+        x.sort();
+      `,
+      options: [{ ignoreStringArrays: true }],
+    },
+    {
+      code: `
+        function f(a: number[]) {
+          a.toSorted((a, b) => a - b);
+        }
+      `,
+    },
+  ],
   invalid: [
     {
       code: `
@@ -151,124 +271,4 @@ ruleTester.run('require-array-sort-compare', rule, {
       errors: [{ messageId: 'requireCompare' }],
     },
   ],
-  valid: [
-    `
-      function f(a: any[]) {
-        a.sort(undefined);
-      }
-    `,
-    `
-      function f(a: any[]) {
-        a.sort((a, b) => a - b);
-      }
-    `,
-    `
-      function f(a: Array<string>) {
-        a.sort(undefined);
-      }
-    `,
-    `
-      function f(a: Array<number>) {
-        a.sort((a, b) => a - b);
-      }
-    `,
-    `
-      function f(a: { sort(): void }) {
-        a.sort();
-      }
-    `,
-    `
-      class A {
-        sort(): void {}
-      }
-      function f(a: A) {
-        a.sort();
-      }
-    `,
-    `
-      interface A {
-        sort(): void;
-      }
-      function f(a: A) {
-        a.sort();
-      }
-    `,
-    `
-      interface A {
-        sort(): void;
-      }
-      function f<T extends A>(a: T) {
-        a.sort();
-      }
-    `,
-    `
-      function f(a: any) {
-        a.sort();
-      }
-    `,
-    `
-      namespace UserDefined {
-        interface Array {
-          sort(): void;
-        }
-        function f(a: Array) {
-          a.sort();
-        }
-      }
-    `,
-    // optional chain
-    `
-      function f(a: any[]) {
-        a?.sort((a, b) => a - b);
-      }
-    `,
-    `
-      namespace UserDefined {
-        interface Array {
-          sort(): void;
-        }
-        function f(a: Array) {
-          a?.sort();
-        }
-      }
-    `,
-    {
-      code: `
-        ['foo', 'bar', 'baz'].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        function getString() {
-          return 'foo';
-        }
-        [getString(), getString()].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        const foo = 'foo';
-        const bar = 'bar';
-        const baz = 'baz';
-        [foo, bar, baz].sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        declare const x: string[];
-        x.sort();
-      `,
-      options: [{ ignoreStringArrays: true }],
-    },
-    {
-      code: `
-        function f(a: number[]) {
-          a.toSorted((a, b) => a - b);
-        }
-      `,
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/require-await.test.ts b/packages/eslint-plugin/tests/rules/require-await.test.ts
index bc51d73c73d4..9f3a4620694d 100644
--- a/packages/eslint-plugin/tests/rules/require-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-await.test.ts
@@ -15,6 +15,244 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('require-await', rule, {
+  valid: [
+    // Non-async function declaration
+    `
+function numberOne(): number {
+  return 1;
+}
+    `,
+    // Non-async function expression
+    `
+const numberOne = function (): number {
+  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;
+};
+    `,
+    // Non-async function that returns a promise
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1226
+    `
+function 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;
+}
+    `,
+    // Async function expression with await
+    `
+const numberOne = async function (): Promise<number> {
+  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;
+};
+    `,
+    // Async function declaration with promise return
+    `
+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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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 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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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);
+};
+    `,
+    // 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),
+    ),
+  );
+}
+    `,
+    `
+function* test6() {
+  yield* syncGenerator();
+}
+    `,
+    `
+function* syncGenerator() {
+  yield 1;
+}
+    `,
+    `
+async function* asyncGenerator() {
+  await Promise.resolve();
+  yield 1;
+}
+async function* test1() {
+  yield* asyncGenerator();
+}
+    `,
+    `
+async function* asyncGenerator() {
+  await Promise.resolve();
+  yield 1;
+}
+async function* test1() {
+  yield* asyncGenerator();
+  yield* 2;
+}
+    `,
+    `
+async function* test(source: AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+async function* test(source: Iterable<any> & AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+async function* test(source: Iterable<any> | AsyncIterable<any>) {
+  yield* source;
+}
+    `,
+    `
+type MyType = {
+  [Symbol.iterator](): Iterator<any>;
+  [Symbol.asyncIterator](): AsyncIterator<any>;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+type MyType = {
+  [Symbol.asyncIterator]: () => AsyncIterator<any>;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+type MyFunctionType = () => AsyncIterator<any>;
+type MyType = {
+  [Symbol.asyncIterator]: MyFunctionType;
+};
+async function* test(source: MyType) {
+  yield* source;
+}
+    `,
+    `
+async function* foo(): Promise<string> {
+  return new Promise(res => res(\`hello\`));
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/5458
+    `
+      async function* f() {
+        let x!: Omit<
+          {
+            [Symbol.asyncIterator](): AsyncIterator<any>;
+          },
+          'z'
+        >;
+        yield* x;
+      }
+    `,
+    `
+      const fn = async () => {
+        await using foo = new Bar();
+      };
+    `,
+    `
+      async function* test1() {
+        yield Promise.resolve(1);
+      }
+    `,
+    `
+      function asyncFunction() {
+        return Promise.resolve(1);
+      }
+      async function* test1() {
+        yield asyncFunction();
+      }
+    `,
+    `
+      declare const asyncFunction: () => Promise<void>;
+      async function* test1() {
+        yield asyncFunction();
+      }
+    `,
+    `
+      async function* test1() {
+        yield new Promise(() => {});
+      }
+    `,
+  ],
   invalid: [
     {
       // Async function declaration with no await
@@ -467,249 +705,120 @@ function* asyncGenerator() {
       ],
     },
   ],
-
+});
+// base eslint tests
+// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/tests/lib/rules/require-await.js#L25-L274
+ruleTester.run('require-await', rule, {
   valid: [
-    // Non-async function declaration
     `
-function numberOne(): number {
-  return 1;
+async function foo() {
+  await doSomething();
 }
     `,
-    // Non-async function expression
     `
-const numberOne = function (): number {
-  return 1;
-};
+(async function () {
+  await doSomething();
+});
     `,
-    // Non-async arrow function expression (concise-body)
     `
-      const numberOne = (): number => 1;
-    `,
-    // Non-async arrow function expression (block-body)
-    `
-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();
-}
-    `,
-    `
-const delay = () => {
-  return Promise.resolve();
-};
-    `,
-    'const delay = () => Promise.resolve();',
-    // Async function declaration with await
-    `
-async function numberOne(): Promise<number> {
-  return await 1;
-}
-    `,
-    // Async function expression with await
-    `
-const numberOne = async function (): Promise<number> {
-  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;
-};
-    `,
-    // Async function declaration with promise return
-    `
-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);
-};
-    `,
-    // 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);
-};
-    `,
-    // 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 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);
-};
-    `,
-    // 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);
-};
-    `,
-    // 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);
+async () => {
+  await doSomething();
 };
     `,
-    // 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),
-    ),
-  );
-}
-    `,
-    `
-function* test6() {
-  yield* syncGenerator();
-}
-    `,
-    `
-function* syncGenerator() {
-  yield 1;
-}
-    `,
-    `
-async function* asyncGenerator() {
-  await Promise.resolve();
-  yield 1;
-}
-async function* test1() {
-  yield* asyncGenerator();
-}
-    `,
-    `
-async function* asyncGenerator() {
-  await Promise.resolve();
-  yield 1;
-}
-async function* test1() {
-  yield* asyncGenerator();
-  yield* 2;
-}
-    `,
+    'async () => await doSomething();',
     `
-async function* test(source: AsyncIterable<any>) {
-  yield* source;
-}
+({
+  async foo() {
+    await doSomething();
+  },
+});
     `,
     `
-async function* test(source: Iterable<any> & AsyncIterable<any>) {
-  yield* source;
+class A {
+  async foo() {
+    await doSomething();
+  }
 }
     `,
     `
-async function* test(source: Iterable<any> | AsyncIterable<any>) {
-  yield* source;
-}
+(class {
+  async foo() {
+    await doSomething();
+  }
+});
     `,
     `
-type MyType = {
-  [Symbol.iterator](): Iterator<any>;
-  [Symbol.asyncIterator](): AsyncIterator<any>;
-};
-async function* test(source: MyType) {
-  yield* source;
+async function foo() {
+  await (async () => {
+    await doSomething();
+  });
 }
     `,
+    // empty functions are ok.
+    'async function foo() {}',
+    'async () => {};',
+    // normal functions are ok.
     `
-type MyType = {
-  [Symbol.asyncIterator]: () => AsyncIterator<any>;
-};
-async function* test(source: MyType) {
-  yield* source;
+function foo() {
+  doSomething();
 }
     `,
+    // for-await-of
     `
-type MyFunctionType = () => AsyncIterator<any>;
-type MyType = {
-  [Symbol.asyncIterator]: MyFunctionType;
-};
-async function* test(source: MyType) {
-  yield* source;
+async function foo() {
+  for await (x of xs);
 }
     `,
-    `
-async function* foo(): Promise<string> {
-  return new Promise(res => res(\`hello\`));
+    // -- global await
+    {
+      code: 'await foo();',
+    },
+    {
+      code: `
+for await (let num of asyncIterable) {
+  console.log(num);
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/5458
-    `
-      async function* f() {
-        let x!: Omit<
-          {
-            [Symbol.asyncIterator](): AsyncIterator<any>;
-          },
-          'z'
-        >;
-        yield* x;
-      }
-    `,
-    `
-      const fn = async () => {
-        await using foo = new Bar();
-      };
-    `,
-    `
-      async function* test1() {
-        yield Promise.resolve(1);
-      }
-    `,
-    `
-      function asyncFunction() {
-        return Promise.resolve(1);
-      }
-      async function* test1() {
-        yield asyncFunction();
-      }
-    `,
-    `
-      declare const asyncFunction: () => Promise<void>;
-      async function* test1() {
-        yield asyncFunction();
-      }
-    `,
-    `
-      async function* test1() {
-        yield new Promise(() => {});
-      }
-    `,
+      `,
+    },
+    {
+      code: `
+        async function* run() {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          yield 'Hello';
+          console.log('World');
+        }
+      `,
+    },
+    {
+      code: 'async function* run() {}',
+    },
+    {
+      code: 'const foo = async function* () {};',
+    },
+    // Note: There are three test cases for async generators in the
+    // ESLint repository that are considered valid. Because we have
+    // type information, we can consider those cases to be invalid.
+    // There are test cases in here to confirm that they are invalid.
+    //
+    // See https://github.com/typescript-eslint/typescript-eslint/pull/1782
+    //
+    // The cases are:
+    //
+    //  1.
+    //  async function* run() {
+    //    yield* anotherAsyncGenerator();
+    //  }
+    //
+    //  2.
+    //  const foo = async function* () {
+    //   console.log('bar');
+    //  };
+    //
+    //  3.
+    //  async function* run() {
+    //    console.log('bar');
+    //  }
   ],
-});
-// base eslint tests
-// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/tests/lib/rules/require-await.js#L25-L274
-ruleTester.run('require-await', rule, {
   invalid: [
     {
       code: `
@@ -1119,114 +1228,4 @@ 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();
-  });
-}
-    `,
-    // 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);
-}
-      `,
-    },
-    {
-      code: `
-        async function* run() {
-          await new Promise(resolve => setTimeout(resolve, 100));
-          yield 'Hello';
-          console.log('World');
-        }
-      `,
-    },
-    {
-      code: 'async function* run() {}',
-    },
-    {
-      code: 'const foo = async function* () {};',
-    },
-    // Note: There are three test cases for async generators in the
-    // ESLint repository that are considered valid. Because we have
-    // type information, we can consider those cases to be invalid.
-    // There are test cases in here to confirm that they are invalid.
-    //
-    // See https://github.com/typescript-eslint/typescript-eslint/pull/1782
-    //
-    // The cases are:
-    //
-    //  1.
-    //  async function* run() {
-    //    yield* anotherAsyncGenerator();
-    //  }
-    //
-    //  2.
-    //  const foo = async function* () {
-    //   console.log('bar');
-    //  };
-    //
-    //  3.
-    //  async function* run() {
-    //    console.log('bar');
-    //  }
-  ],
 });
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 0a46ed700ea4..8ef2e7353277 100644
--- a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
@@ -15,89 +15,242 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('restrict-plus-operands', rule, {
-  invalid: [
+  valid: [
+    'let x = 5;',
+    "let y = '10';",
+    'let z = 8.2;',
+    "let w = '6.5';",
+    'let foo = 5 + 10;',
+    "let foo = '5.5' + '10';",
+    "let foo = parseInt('5.5', 10) + 10;",
+    "let foo = parseFloat('5.5', 10) + 10;",
+    'let foo = 1n + 1n;',
+    'let foo = BigInt(1) + 1n;',
+    `
+      let foo = 1n;
+      foo + 2n;
+    `,
+    `
+function test(s: string, n: number): number {
+  return 2;
+}
+let foo = test('5.5', 10) + 10;
+    `,
+    `
+let x = 5;
+let z = 8.2;
+let foo = x + z;
+    `,
+    `
+let w = '6.5';
+let y = '10';
+let foo = y + w;
+    `,
+    'let foo = 1 + 1;',
+    "let foo = '1' + '1';",
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = pair.first + 10;
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = pair.first + (10 as number);
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = '5.5' + pair.second;
+    `,
+    `
+let pair: { first: number; second: string } = { first: 5, second: '10' };
+let foo = ('5.5' as string) + pair.second;
+    `,
+    `
+      const foo =
+        'hello' +
+        (someBoolean ? 'a' : 'b') +
+        (() => (someBoolean ? 'c' : 'd'))() +
+        'e';
+    `,
+    'const balls = true;',
+    'balls === true;',
+    // https://github.com/typescript-eslint/typescript-eslint/issues/230
+    `
+function foo<T extends string>(a: T) {
+  return a + '';
+}
+    `,
+    `
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + '';
+}
+    `,
+    `
+function foo<T extends number>(a: T) {
+  return a + 1;
+}
+    `,
+    `
+function foo<T extends 1>(a: T) {
+  return a + 1;
+}
+    `,
+    `
+declare const a: {} & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: string & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: 'string literal' & string;
+declare const b: string;
+const x = a + b;
+    `,
+    `
+declare const a: {} & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: number & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: 42 & number;
+declare const b: number;
+const x = a + b;
+    `,
+    `
+declare const a: {} & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: unknown & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: bigint & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+declare const a: 42n & bigint;
+declare const b: bigint;
+const x = a + b;
+    `,
+    `
+function A(s: string) {
+  return \`a\${s}b\` as const;
+}
+const b = A('') + '!';
+    `,
+    `
+declare const a: \`template\${string}\`;
+declare const b: '';
+const x = a + b;
+    `,
+    `
+const a: \`template\${0}\`;
+declare const b: '';
+const x = a + b;
+    `,
     {
-      code: "let foo = '1' + 1;",
-      errors: [
+      code: `
+        declare const a: RegExp;
+        declare const b: string;
+        const x = a + b;
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            left: 'string',
-            right: 'number',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-          },
-          line: 1,
-          messageId: 'mismatched',
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: true,
         },
       ],
-      options: [{ allowNumberAndString: false }],
     },
     {
-      code: "let foo = '1' + 1;",
-      errors: [
-        {
-          column: 11,
-          data: {
-            left: 'string',
-            right: 'number',
-            stringLike: 'string',
-          },
-          line: 1,
-          messageId: 'mismatched',
-        },
-      ],
+      code: `
+        const a = /regexp/;
+        declare const b: string;
+        const x = a + b;
+      `,
       options: [
         {
           allowAny: false,
           allowBoolean: false,
           allowNullish: false,
           allowNumberAndString: false,
-          allowRegExp: false,
+          allowRegExp: true,
         },
       ],
     },
+    // TypeScript handles this case, so we don't have to
     {
-      code: 'let foo = [] + {};',
-      errors: [
+      code: `
+const f = (a: RegExp, b: RegExp) => a + b;
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
-          },
-          endColumn: 13,
-          line: 1,
-          messageId: 'invalid',
+          allowRegExp: true,
         },
+      ],
+    },
+    {
+      code: `
+let foo: string | undefined;
+foo = foo + 'some data';
+      `,
+      options: [
         {
-          column: 16,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
-          },
-          endColumn: 18,
-          line: 1,
-          messageId: 'invalid',
+          allowNullish: true,
         },
       ],
     },
     {
-      code: "let foo = 5 + '10';",
-      errors: [
+      code: `
+let foo: string | null;
+foo = foo + 'some data';
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            left: 'number',
-            right: 'string',
-            stringLike: 'string',
-          },
-          line: 1,
-          messageId: 'mismatched',
+          allowNullish: true,
         },
       ],
+    },
+    {
+      code: `
+let foo: string | null | undefined;
+foo = foo + 'some data';
+      `,
+      options: [
+        {
+          allowNullish: true,
+        },
+      ],
+    },
+    {
+      code: `
+let foo = '';
+foo += 0;
+      `,
       options: [
         {
           allowAny: false,
@@ -105,183 +258,164 @@ ruleTester.run('restrict-plus-operands', rule, {
           allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
+          skipCompoundAssignments: true,
         },
       ],
     },
     {
-      code: 'let foo = [] + 5;',
-      errors: [
+      code: `
+let foo = 0;
+foo += '';
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
-          },
-          endColumn: 13,
-          line: 1,
-          messageId: 'invalid',
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
+          skipCompoundAssignments: true,
         },
       ],
     },
     {
-      code: 'let foo = [] + [];',
-      errors: [
+      code: `
+const f = (a: any, b: any) => a + b;
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
-          },
-          endColumn: 13,
-          line: 1,
-          messageId: 'invalid',
+          allowAny: true,
         },
+      ],
+    },
+    {
+      code: `
+const f = (a: any, b: string) => a + b;
+      `,
+      options: [
         {
-          column: 16,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'never[]',
-          },
-          endColumn: 18,
-          line: 1,
-          messageId: 'invalid',
+          allowAny: true,
         },
       ],
     },
     {
-      code: 'let foo = 5 + [3];',
-      errors: [
+      code: `
+const f = (a: any, b: bigint) => a + b;
+      `,
+      options: [
         {
-          column: 15,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'number[]',
-          },
-          endColumn: 18,
-          line: 1,
-          messageId: 'invalid',
+          allowAny: true,
         },
       ],
     },
     {
-      code: "let foo = '5' + {};",
-      errors: [
+      code: `
+const f = (a: any, b: number) => a + b;
+      `,
+      options: [
         {
-          column: 17,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
-          },
-          endColumn: 19,
-          line: 1,
-          messageId: 'invalid',
+          allowAny: true,
         },
       ],
     },
     {
-      code: "let foo = 5.5 + '5';",
-      errors: [
+      code: `
+const f = (a: any, b: boolean) => a + b;
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            left: 'number',
-            right: 'string',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-          },
-          line: 1,
-          messageId: 'mismatched',
+          allowAny: true,
+          allowBoolean: true,
         },
       ],
-      options: [{ allowNumberAndString: false }],
     },
     {
-      code: "let foo = '5.5' + 5;",
-      errors: [
+      code: `
+const f = (a: string, b: string | number) => a + b;
+      `,
+      options: [
         {
-          column: 11,
-          data: {
-            left: 'string',
-            right: 'number',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-          },
-          line: 1,
-          messageId: 'mismatched',
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumberAndString: true,
+          allowRegExp: true,
+        },
+      ],
+    },
+    {
+      code: `
+const f = (a: string | number, b: number) => a + b;
+      `,
+      options: [
+        {
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumberAndString: true,
+          allowRegExp: true,
+        },
+      ],
+    },
+    {
+      code: `
+const f = (a: string | number, b: string | number) => a + b;
+      `,
+      options: [
+        {
+          allowAny: true,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumberAndString: true,
+          allowRegExp: true,
         },
       ],
-      options: [{ allowNumberAndString: false }],
     },
+  ],
+  invalid: [
     {
-      code: `
-let x = 5;
-let y = '10';
-let foo = x + y;
-      `,
+      code: "let foo = '1' + 1;",
       errors: [
         {
           column: 11,
           data: {
-            left: 'number',
-            right: 'string',
+            left: 'string',
+            right: 'number',
             stringLike:
               'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
           },
-          line: 4,
+          line: 1,
           messageId: 'mismatched',
         },
       ],
       options: [{ allowNumberAndString: false }],
     },
     {
-      code: `
-let x = 5;
-let y = '10';
-let foo = y + x;
-      `,
+      code: "let foo = '1' + 1;",
       errors: [
         {
           column: 11,
           data: {
             left: 'string',
             right: 'number',
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            stringLike: 'string',
           },
-          line: 4,
+          line: 1,
           messageId: 'mismatched',
         },
       ],
-      options: [{ allowNumberAndString: false }],
-    },
-    {
-      code: `
-let x = 5;
-let foo = x + {};
-      `,
-      errors: [
+      options: [
         {
-          column: 15,
-          data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '{}',
-          },
-          line: 3,
-          messageId: 'invalid',
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
-      code: `
-let y = '10';
-let foo = [] + y;
-      `,
+      code: 'let foo = [] + {};',
       errors: [
         {
           column: 11,
@@ -290,64 +424,35 @@ let foo = [] + y;
               'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
             type: 'never[]',
           },
-          line: 3,
-          messageId: 'invalid',
-        },
-      ],
-    },
-    {
-      code: `
-let pair = { first: 5, second: '10' };
-let foo = pair + pair;
-      `,
-      errors: [
-        {
-          column: 11,
-          data: {
-            stringLike: 'string',
-            type: '{ first: number; second: string; }',
-          },
-          endColumn: 15,
-          line: 3,
+          endColumn: 13,
+          line: 1,
           messageId: 'invalid',
         },
         {
-          column: 18,
+          column: 16,
           data: {
-            stringLike: 'string',
-            type: '{ first: number; second: string; }',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
           },
-          endColumn: 22,
-          line: 3,
+          endColumn: 18,
+          line: 1,
           messageId: 'invalid',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
     },
     {
-      code: `
-type Valued = { value: number };
-let value: Valued = { value: 0 };
-let combined = value + 0;
-      `,
+      code: "let foo = 5 + '10';",
       errors: [
         {
-          column: 16,
+          column: 11,
           data: {
+            left: 'number',
+            right: 'string',
             stringLike: 'string',
-            type: 'Valued',
           },
-          endColumn: 21,
-          line: 4,
-          messageId: 'invalid',
+          line: 1,
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -361,303 +466,216 @@ let combined = value + 0;
       ],
     },
     {
-      code: 'let foo = 1n + 1;',
+      code: 'let foo = [] + 5;',
       errors: [
         {
           column: 11,
           data: {
-            left: 'bigint',
-            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
           },
+          endColumn: 13,
           line: 1,
-          messageId: 'bigintAndNumber',
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: 'let foo = 1 + 1n;',
+      code: 'let foo = [] + [];',
       errors: [
         {
           column: 11,
           data: {
-            left: 'number',
-            right: 'bigint',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
           },
+          endColumn: 13,
           line: 1,
-          messageId: 'bigintAndNumber',
+          messageId: 'invalid',
         },
-      ],
-    },
-    {
-      code: `
-        let foo = 1n;
-        foo + 1;
-      `,
-      errors: [
         {
-          column: 9,
+          column: 16,
           data: {
-            left: 'bigint',
-            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
           },
-          line: 3,
-          messageId: 'bigintAndNumber',
+          endColumn: 18,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-        let foo = 1;
-        foo + 1n;
-      `,
+      code: 'let foo = 5 + [3];',
       errors: [
         {
-          column: 9,
+          column: 15,
           data: {
-            left: 'number',
-            right: 'bigint',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'number[]',
           },
-          line: 3,
-          messageId: 'bigintAndNumber',
+          endColumn: 18,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/230
     {
-      code: `
-function foo<T extends string>(a: T) {
-  return a + 1;
-}
-      `,
+      code: "let foo = '5' + {};",
       errors: [
         {
-          column: 10,
+          column: 17,
           data: {
-            left: 'string',
-            right: 'number',
-            stringLike: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
           },
-          line: 3,
-          messageId: 'mismatched',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
+          endColumn: 19,
+          line: 1,
+          messageId: 'invalid',
         },
       ],
     },
     {
-      code: `
-function foo<T extends 'a' | 'b'>(a: T) {
-  return a + 1;
-}
-      `,
+      code: "let foo = 5.5 + '5';",
       errors: [
         {
-          column: 10,
+          column: 11,
           data: {
-            left: 'string',
-            right: 'number',
-            stringLike: 'string',
+            left: 'number',
+            right: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
           },
-          line: 3,
+          line: 1,
           messageId: 'mismatched',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
+      options: [{ allowNumberAndString: false }],
     },
     {
-      code: `
-function foo<T extends number>(a: T) {
-  return a + '';
-}
-      `,
+      code: "let foo = '5.5' + 5;",
       errors: [
         {
-          column: 10,
+          column: 11,
           data: {
-            left: 'number',
-            right: 'string',
-            stringLike: 'string',
+            left: 'string',
+            right: 'number',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
           },
-          line: 3,
+          line: 1,
           messageId: 'mismatched',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-function foo<T extends 1>(a: T) {
-  return a + '';
-}
+let x = 5;
+let y = '10';
+let foo = x + y;
       `,
       errors: [
         {
-          column: 10,
+          column: 11,
           data: {
             left: 'number',
             right: 'string',
-            stringLike: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
           },
-          line: 3,
+          line: 4,
           messageId: 'mismatched',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-        declare const a: \`template\${number}\`;
-        declare const b: number;
-        const x = a + b;
+let x = 5;
+let y = '10';
+let foo = y + x;
       `,
       errors: [
         {
-          column: 19,
+          column: 11,
           data: {
             left: 'string',
             right: 'number',
-            stringLike: 'string',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
           },
           line: 4,
           messageId: 'mismatched',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
+      options: [{ allowNumberAndString: false }],
     },
     {
       code: `
-        declare const a: never;
-        declare const b: string;
-        const x = a + b;
+let x = 5;
+let foo = x + {};
       `,
       errors: [
         {
-          column: 19,
+          column: 15,
           data: {
-            stringLike: 'string',
-            type: 'never',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '{}',
           },
-          line: 4,
+          line: 3,
           messageId: 'invalid',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
     },
     {
       code: `
-        declare const a: never & string;
-        declare const b: string;
-        const x = a + b;
+let y = '10';
+let foo = [] + y;
       `,
       errors: [
         {
-          column: 19,
+          column: 11,
           data: {
-            stringLike: 'string',
-            type: 'never',
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'never[]',
           },
-          line: 4,
+          line: 3,
           messageId: 'invalid',
         },
       ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
     },
     {
       code: `
-        declare const a: boolean & string;
-        declare const b: string;
-        const x = a + b;
+let pair = { first: 5, second: '10' };
+let foo = pair + pair;
       `,
       errors: [
         {
-          column: 19,
+          column: 11,
           data: {
             stringLike: 'string',
-            type: 'never',
+            type: '{ first: number; second: string; }',
           },
-          line: 4,
+          endColumn: 15,
+          line: 3,
           messageId: 'invalid',
         },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-        },
-      ],
-    },
-    {
-      code: `
-        declare const a: any & string;
-        declare const b: string;
-        const x = a + b;
-      `,
-      errors: [
         {
-          column: 19,
+          column: 18,
           data: {
             stringLike: 'string',
-            type: 'any',
+            type: '{ first: number; second: string; }',
           },
-          line: 4,
+          endColumn: 22,
+          line: 3,
           messageId: 'invalid',
         },
       ],
@@ -673,17 +691,18 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: string;
-        const x = a + b;
+type Valued = { value: number };
+let value: Valued = { value: 0 };
+let combined = value + 0;
       `,
       errors: [
         {
-          column: 19,
+          column: 16,
           data: {
             stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
+            type: 'Valued',
           },
+          endColumn: 21,
           line: 4,
           messageId: 'invalid',
         },
@@ -699,111 +718,84 @@ function foo<T extends 1>(a: T) {
       ],
     },
     {
-      code: `
-        interface A {
-          a: 1;
-        }
-        declare const a: A;
-        declare const b: string;
-        const x = a + b;
-      `,
+      code: 'let foo = 1n + 1;',
       errors: [
         {
-          column: 19,
+          column: 11,
           data: {
-            stringLike: 'string',
-            type: 'A',
+            left: 'bigint',
+            right: 'number',
           },
-          line: 7,
-          messageId: 'invalid',
+          line: 1,
+          messageId: 'bigintAndNumber',
         },
       ],
-      options: [
+    },
+    {
+      code: 'let foo = 1 + 1n;',
+      errors: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
+          column: 11,
+          data: {
+            left: 'number',
+            right: 'bigint',
+          },
+          line: 1,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
     {
       code: `
-        interface A {
-          a: 1;
-        }
-        interface A2 extends A {
-          b: 2;
-        }
-        declare const a: A2;
-        declare const b: string;
-        const x = a + b;
+        let foo = 1n;
+        foo + 1;
       `,
       errors: [
         {
-          column: 19,
+          column: 9,
           data: {
-            stringLike: 'string',
-            type: 'A2',
+            left: 'bigint',
+            right: 'number',
           },
-          line: 10,
-          messageId: 'invalid',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
+          line: 3,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
     {
       code: `
-        type A = { a: 1 } & { b: 2 };
-        declare const a: A;
-        declare const b: string;
-        const x = a + b;
+        let foo = 1;
+        foo + 1n;
       `,
       errors: [
         {
-          column: 19,
+          column: 9,
           data: {
-            stringLike: 'string',
-            type: 'A',
+            left: 'number',
+            right: 'bigint',
           },
-          line: 5,
-          messageId: 'invalid',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
+          line: 3,
+          messageId: 'bigintAndNumber',
         },
       ],
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/230
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: number;
-        const x = a + b;
+function foo<T extends string>(a: T) {
+  return a + 1;
+}
       `,
       errors: [
         {
-          column: 19,
+          column: 10,
           data: {
+            left: 'string',
+            right: 'number',
             stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
           },
-          line: 4,
-          messageId: 'invalid',
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -818,19 +810,20 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: never;
-        declare const b: bigint;
-        const x = a + b;
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + 1;
+}
       `,
       errors: [
         {
-          column: 19,
+          column: 10,
           data: {
+            left: 'string',
+            right: 'number',
             stringLike: 'string',
-            type: 'never',
           },
-          line: 4,
-          messageId: 'invalid',
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -845,19 +838,20 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: any;
-        declare const b: bigint;
-        const x = a + b;
+function foo<T extends number>(a: T) {
+  return a + '';
+}
       `,
       errors: [
         {
-          column: 19,
+          column: 10,
           data: {
+            left: 'number',
+            right: 'string',
             stringLike: 'string',
-            type: 'any',
           },
-          line: 4,
-          messageId: 'invalid',
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -872,19 +866,20 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: { a: 1 } & { b: 2 };
-        declare const b: bigint;
-        const x = a + b;
+function foo<T extends 1>(a: T) {
+  return a + '';
+}
       `,
       errors: [
         {
-          column: 19,
+          column: 10,
           data: {
+            left: 'number',
+            right: 'string',
             stringLike: 'string',
-            type: '{ a: 1; } & { b: 2; }',
           },
-          line: 4,
-          messageId: 'invalid',
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -899,19 +894,20 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: RegExp;
-        declare const b: string;
+        declare const a: \`template\${number}\`;
+        declare const b: number;
         const x = a + b;
       `,
       errors: [
         {
           column: 19,
           data: {
+            left: 'string',
+            right: 'number',
             stringLike: 'string',
-            type: 'RegExp',
           },
           line: 4,
-          messageId: 'invalid',
+          messageId: 'mismatched',
         },
       ],
       options: [
@@ -926,7 +922,7 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        const a = /regexp/;
+        declare const a: never;
         declare const b: string;
         const x = a + b;
       `,
@@ -935,7 +931,7 @@ function foo<T extends 1>(a: T) {
           column: 19,
           data: {
             stringLike: 'string',
-            type: 'RegExp',
+            type: 'never',
           },
           line: 4,
           messageId: 'invalid',
@@ -953,7 +949,7 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: Symbol;
+        declare const a: never & string;
         declare const b: string;
         const x = a + b;
       `,
@@ -962,7 +958,7 @@ function foo<T extends 1>(a: T) {
           column: 19,
           data: {
             stringLike: 'string',
-            type: 'Symbol',
+            type: 'never',
           },
           line: 4,
           messageId: 'invalid',
@@ -980,7 +976,7 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: symbol;
+        declare const a: boolean & string;
         declare const b: string;
         const x = a + b;
       `,
@@ -989,7 +985,7 @@ function foo<T extends 1>(a: T) {
           column: 19,
           data: {
             stringLike: 'string',
-            type: 'symbol',
+            type: 'never',
           },
           line: 4,
           messageId: 'invalid',
@@ -1007,7 +1003,7 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        declare const a: unique symbol;
+        declare const a: any & string;
         declare const b: string;
         const x = a + b;
       `,
@@ -1016,7 +1012,7 @@ function foo<T extends 1>(a: T) {
           column: 19,
           data: {
             stringLike: 'string',
-            type: 'unique symbol',
+            type: 'any',
           },
           line: 4,
           messageId: 'invalid',
@@ -1034,7 +1030,7 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-        const a = Symbol('');
+        declare const a: { a: 1 } & { b: 2 };
         declare const b: string;
         const x = a + b;
       `,
@@ -1043,7 +1039,7 @@ function foo<T extends 1>(a: T) {
           column: 19,
           data: {
             stringLike: 'string',
-            type: 'unique symbol',
+            type: '{ a: 1; } & { b: 2; }',
           },
           line: 4,
           messageId: 'invalid',
@@ -1061,17 +1057,21 @@ function foo<T extends 1>(a: T) {
     },
     {
       code: `
-let foo: string | undefined;
-foo += 'some data';
+        interface A {
+          a: 1;
+        }
+        declare const a: A;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 1,
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'string | undefined',
+            type: 'A',
           },
-          line: 3,
+          line: 7,
           messageId: 'invalid',
         },
       ],
@@ -1082,23 +1082,29 @@ foo += 'some data';
           allowNullish: false,
           allowNumberAndString: false,
           allowRegExp: false,
-          skipCompoundAssignments: false,
         },
       ],
     },
     {
       code: `
-let foo: string | null;
-foo += 'some data';
+        interface A {
+          a: 1;
+        }
+        interface A2 extends A {
+          b: 2;
+        }
+        declare const a: A2;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 1,
+          column: 19,
           data: {
             stringLike: 'string',
-            type: 'string | null',
+            type: 'A2',
           },
-          line: 3,
+          line: 10,
           messageId: 'invalid',
         },
       ],
@@ -1114,19 +1120,20 @@ foo += 'some data';
     },
     {
       code: `
-let foo: string = '';
-foo += 1;
+        type A = { a: 1 } & { b: 2 };
+        declare const a: A;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 1,
+          column: 19,
           data: {
-            left: 'string',
-            right: 'number',
             stringLike: 'string',
+            type: 'A',
           },
-          line: 3,
-          messageId: 'mismatched',
+          line: 5,
+          messageId: 'invalid',
         },
       ],
       options: [
@@ -1141,19 +1148,19 @@ foo += 1;
     },
     {
       code: `
-let foo = 0;
-foo += '';
+        declare const a: { a: 1 } & { b: 2 };
+        declare const b: number;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 1,
+          column: 19,
           data: {
-            left: 'number',
-            right: 'string',
             stringLike: 'string',
+            type: '{ a: 1; } & { b: 2; }',
           },
-          line: 3,
-          messageId: 'mismatched',
+          line: 4,
+          messageId: 'invalid',
         },
       ],
       options: [
@@ -1168,153 +1175,126 @@ foo += '';
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
-      `,
-      errors: [
-        {
-          column: 39,
-          line: 2,
-          messageId: 'invalid',
-        },
-      ],
-      options: [
-        {
-          allowAny: true,
-          allowBoolean: false,
-        },
-      ],
-    },
-    {
-      code: `
-const f = (a: any, b: []) => a + b;
+        declare const a: never;
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 34,
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: '[]',
+            stringLike: 'string',
+            type: 'never',
           },
-          line: 2,
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
-          allowAny: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
+        declare const a: any;
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 35,
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `boolean`, `null`, `RegExp`, `undefined`',
+            stringLike: 'string',
             type: 'any',
           },
-          line: 2,
-          messageId: 'invalid',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: true,
-        },
-      ],
-    },
-    {
-      code: `
-const f = (a: any, b: any) => a + b;
-      `,
-      errors: [
-        {
-          column: 31,
-          line: 2,
-          messageId: 'invalid',
-        },
-        {
-          column: 35,
-          line: 2,
-          messageId: 'invalid',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-        },
-      ],
-    },
-    {
-      code: `
-const f = (a: any, b: string) => a + b;
-      `,
-      errors: [
-        {
-          column: 34,
-          line: 2,
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: bigint) => a + b;
+        declare const a: { a: 1 } & { b: 2 };
+        declare const b: bigint;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 34,
-          line: 2,
+          column: 19,
+          data: {
+            stringLike: 'string',
+            type: '{ a: 1; } & { b: 2; }',
+          },
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: number) => a + b;
+        declare const a: RegExp;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 34,
-          line: 2,
+          column: 19,
+          data: {
+            stringLike: 'string',
+            type: 'RegExp',
+          },
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
           allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: boolean) => a + b;
+        const a = /regexp/;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 35,
-          line: 2,
-          messageId: 'invalid',
-        },
-        {
-          column: 39,
-          line: 2,
+          column: 19,
+          data: {
+            stringLike: 'string',
+            type: 'RegExp',
+          },
+          line: 4,
           messageId: 'invalid',
         },
       ],
@@ -1322,358 +1302,287 @@ const f = (a: any, b: boolean) => a + b;
         {
           allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: number, b: RegExp) => a + b;
+        declare const a: Symbol;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 41,
-          line: 2,
+          column: 19,
+          data: {
+            stringLike: 'string',
+            type: 'Symbol',
+          },
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
-          allowRegExp: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let foo: string | boolean;
-foo = foo + 'some data';
+        declare const a: symbol;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 7,
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
-            type: 'string | boolean',
+            stringLike: 'string',
+            type: 'symbol',
           },
-          line: 3,
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
+          allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let foo: boolean;
-foo = foo + 'some data';
+        declare const a: unique symbol;
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 7,
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
-            type: 'boolean',
+            stringLike: 'string',
+            type: 'unique symbol',
           },
-          line: 3,
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
+          allowAny: false,
           allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-const f = (a: any, b: unknown) => a + b;
+        const a = Symbol('');
+        declare const b: string;
+        const x = a + b;
       `,
       errors: [
         {
-          column: 39,
+          column: 19,
           data: {
-            stringLike:
-              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
-            type: 'unknown',
+            stringLike: 'string',
+            type: 'unique symbol',
           },
-          line: 2,
+          line: 4,
           messageId: 'invalid',
         },
       ],
       options: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowRegExp: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
-  ],
-  valid: [
-    'let x = 5;',
-    "let y = '10';",
-    'let z = 8.2;',
-    "let w = '6.5';",
-    'let foo = 5 + 10;',
-    "let foo = '5.5' + '10';",
-    "let foo = parseInt('5.5', 10) + 10;",
-    "let foo = parseFloat('5.5', 10) + 10;",
-    'let foo = 1n + 1n;',
-    'let foo = BigInt(1) + 1n;',
-    `
-      let foo = 1n;
-      foo + 2n;
-    `,
-    `
-function test(s: string, n: number): number {
-  return 2;
-}
-let foo = test('5.5', 10) + 10;
-    `,
-    `
-let x = 5;
-let z = 8.2;
-let foo = x + z;
-    `,
-    `
-let w = '6.5';
-let y = '10';
-let foo = y + w;
-    `,
-    'let foo = 1 + 1;',
-    "let foo = '1' + '1';",
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = pair.first + 10;
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = pair.first + (10 as number);
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = '5.5' + pair.second;
-    `,
-    `
-let pair: { first: number; second: string } = { first: 5, second: '10' };
-let foo = ('5.5' as string) + pair.second;
-    `,
-    `
-      const foo =
-        'hello' +
-        (someBoolean ? 'a' : 'b') +
-        (() => (someBoolean ? 'c' : 'd'))() +
-        'e';
-    `,
-    'const balls = true;',
-    'balls === true;',
-    // https://github.com/typescript-eslint/typescript-eslint/issues/230
-    `
-function foo<T extends string>(a: T) {
-  return a + '';
-}
-    `,
-    `
-function foo<T extends 'a' | 'b'>(a: T) {
-  return a + '';
-}
-    `,
-    `
-function foo<T extends number>(a: T) {
-  return a + 1;
-}
-    `,
-    `
-function foo<T extends 1>(a: T) {
-  return a + 1;
-}
-    `,
-    `
-declare const a: {} & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: string & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: 'string literal' & string;
-declare const b: string;
-const x = a + b;
-    `,
-    `
-declare const a: {} & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: number & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: 42 & number;
-declare const b: number;
-const x = a + b;
-    `,
-    `
-declare const a: {} & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: unknown & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: bigint & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-declare const a: 42n & bigint;
-declare const b: bigint;
-const x = a + b;
-    `,
-    `
-function A(s: string) {
-  return \`a\${s}b\` as const;
-}
-const b = A('') + '!';
-    `,
-    `
-declare const a: \`template\${string}\`;
-declare const b: '';
-const x = a + b;
-    `,
-    `
-const a: \`template\${0}\`;
-declare const b: '';
-const x = a + b;
-    `,
     {
       code: `
-        declare const a: RegExp;
-        declare const b: string;
-        const x = a + b;
+let foo: string | undefined;
+foo += 'some data';
       `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            stringLike: 'string',
+            type: 'string | undefined',
+          },
+          line: 3,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
           allowNullish: false,
           allowNumberAndString: false,
-          allowRegExp: true,
+          allowRegExp: false,
+          skipCompoundAssignments: false,
         },
       ],
     },
     {
       code: `
-        const a = /regexp/;
-        declare const b: string;
-        const x = a + b;
+let foo: string | null;
+foo += 'some data';
       `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            stringLike: 'string',
+            type: 'string | null',
+          },
+          line: 3,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
           allowAny: false,
           allowBoolean: false,
           allowNullish: false,
           allowNumberAndString: false,
-          allowRegExp: true,
+          allowRegExp: false,
         },
       ],
     },
-    // TypeScript handles this case, so we don't have to
     {
       code: `
-const f = (a: RegExp, b: RegExp) => a + b;
+let foo: string = '';
+foo += 1;
       `,
-      options: [
+      errors: [
         {
-          allowRegExp: true,
+          column: 1,
+          data: {
+            left: 'string',
+            right: 'number',
+            stringLike: 'string',
+          },
+          line: 3,
+          messageId: 'mismatched',
         },
       ],
-    },
-    {
-      code: `
-let foo: string | undefined;
-foo = foo + 'some data';
-      `,
       options: [
         {
-          allowNullish: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let foo: string | null;
-foo = foo + 'some data';
+let foo = 0;
+foo += '';
       `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            left: 'number',
+            right: 'string',
+            stringLike: 'string',
+          },
+          line: 3,
+          messageId: 'mismatched',
+        },
+      ],
       options: [
         {
-          allowNullish: true,
+          allowAny: false,
+          allowBoolean: false,
+          allowNullish: false,
+          allowNumberAndString: false,
+          allowRegExp: false,
         },
       ],
     },
     {
       code: `
-let foo: string | null | undefined;
-foo = foo + 'some data';
+const f = (a: any, b: boolean) => a + b;
       `,
+      errors: [
+        {
+          column: 39,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowNullish: true,
+          allowAny: true,
+          allowBoolean: false,
         },
       ],
     },
     {
       code: `
-let foo = '';
-foo += 0;
+const f = (a: any, b: []) => a + b;
       `,
+      errors: [
+        {
+          column: 34,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: '[]',
+          },
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          skipCompoundAssignments: true,
+          allowAny: true,
         },
       ],
     },
     {
       code: `
-let foo = 0;
-foo += '';
+const f = (a: any, b: boolean) => a + b;
       `,
+      errors: [
+        {
+          column: 35,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'any',
+          },
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
           allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          skipCompoundAssignments: true,
+          allowBoolean: true,
         },
       ],
     },
@@ -1681,9 +1590,21 @@ foo += '';
       code: `
 const f = (a: any, b: any) => a + b;
       `,
+      errors: [
+        {
+          column: 31,
+          line: 2,
+          messageId: 'invalid',
+        },
+        {
+          column: 35,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
+          allowAny: false,
         },
       ],
     },
@@ -1691,9 +1612,16 @@ const f = (a: any, b: any) => a + b;
       code: `
 const f = (a: any, b: string) => a + b;
       `,
+      errors: [
+        {
+          column: 34,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
+          allowAny: false,
         },
       ],
     },
@@ -1701,9 +1629,16 @@ const f = (a: any, b: string) => a + b;
       code: `
 const f = (a: any, b: bigint) => a + b;
       `,
+      errors: [
+        {
+          column: 34,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
+          allowAny: false,
         },
       ],
     },
@@ -1711,9 +1646,16 @@ const f = (a: any, b: bigint) => a + b;
       code: `
 const f = (a: any, b: number) => a + b;
       `,
+      errors: [
+        {
+          column: 34,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
+          allowAny: false,
         },
       ],
     },
@@ -1721,51 +1663,109 @@ const f = (a: any, b: number) => a + b;
       code: `
 const f = (a: any, b: boolean) => a + b;
       `,
+      errors: [
+        {
+          column: 35,
+          line: 2,
+          messageId: 'invalid',
+        },
+        {
+          column: 39,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
-          allowBoolean: true,
+          allowAny: false,
+          allowBoolean: false,
         },
       ],
     },
     {
       code: `
-const f = (a: string, b: string | number) => a + b;
+const f = (a: number, b: RegExp) => a + b;
       `,
+      errors: [
+        {
+          column: 41,
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumberAndString: true,
           allowRegExp: true,
         },
       ],
     },
     {
       code: `
-const f = (a: string | number, b: number) => a + b;
+let foo: string | boolean;
+foo = foo + 'some data';
       `,
+      errors: [
+        {
+          column: 7,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
+            type: 'string | boolean',
+          },
+          line: 3,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
-          allowAny: true,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumberAndString: true,
-          allowRegExp: true,
+          allowBoolean: false,
         },
       ],
     },
     {
       code: `
-const f = (a: string | number, b: string | number) => a + b;
+let foo: boolean;
+foo = foo + 'some data';
+      `,
+      errors: [
+        {
+          column: 7,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `null`, `RegExp`, `undefined`',
+            type: 'boolean',
+          },
+          line: 3,
+          messageId: 'invalid',
+        },
+      ],
+      options: [
+        {
+          allowBoolean: false,
+        },
+      ],
+    },
+    {
+      code: `
+const f = (a: any, b: unknown) => a + b;
       `,
+      errors: [
+        {
+          column: 39,
+          data: {
+            stringLike:
+              'string, allowing a string + any of: `any`, `boolean`, `null`, `RegExp`, `undefined`',
+            type: 'unknown',
+          },
+          line: 2,
+          messageId: 'invalid',
+        },
+      ],
       options: [
         {
           allowAny: true,
           allowBoolean: true,
           allowNullish: true,
-          allowNumberAndString: true,
           allowRegExp: true,
         },
       ],
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 41c6e460ff4e..e6896d05b08f 100644
--- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -15,267 +15,6 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('restrict-template-expressions', rule, {
-  invalid: [
-    {
-      code: `
-        const msg = \`arg = \${123}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: '123' },
-          line: 2,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowNumber: false }],
-    },
-    {
-      code: `
-        const msg = \`arg = \${false}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'false' },
-          line: 2,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowBoolean: false }],
-    },
-    {
-      code: `
-        const msg = \`arg = \${null}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'null' },
-          line: 2,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowNullish: false }],
-    },
-    {
-      code: `
-        declare const arg: number[];
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'number[]' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-    },
-    {
-      code: `
-        const msg = \`arg = \${[, 2]}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: '(number | undefined)[]' },
-          line: 2,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowArray: true, allowNullish: false }],
-    },
-    {
-      code: `
-        declare const arg: [number | undefined, string];
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: '[number | undefined, string]' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowArray: true, allowNullish: false }],
-    },
-    {
-      code: `
-        declare const arg: number;
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'number' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowNumber: false }],
-    },
-    {
-      code: `
-        declare const arg: boolean;
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'boolean' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowBoolean: false }],
-    },
-    {
-      code: `
-        const arg = {};
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        { column: 30, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
-      ],
-      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
-    },
-    {
-      code: `
-        declare const arg: { a: string } & { b: string };
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: '{ a: string; } & { b: string; }' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-    },
-    {
-      code: `
-        function test<T extends {}>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-      errors: [
-        { column: 27, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
-      ],
-      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
-    },
-    {
-      code: `
-        function test<TWithNoConstraint>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-      errors: [
-        {
-          column: 27,
-          data: { type: 'T' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumber: true,
-        },
-      ],
-    },
-    {
-      code: `
-        function test(arg: any) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-      errors: [
-        {
-          column: 27,
-          data: { type: 'any' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [
-        {
-          allowAny: false,
-          allowBoolean: true,
-          allowNullish: true,
-          allowNumber: true,
-        },
-      ],
-    },
-    {
-      code: `
-        const arg = new RegExp('foo');
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'RegExp' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowRegExp: false }],
-    },
-    {
-      code: `
-        const arg = /foo/;
-        const msg = \`arg = \${arg}\`;
-      `,
-      errors: [
-        {
-          column: 30,
-          data: { type: 'RegExp' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowRegExp: false }],
-    },
-    {
-      code: `
-        declare const value: never;
-        const stringy = \`\${value}\`;
-      `,
-      errors: [
-        {
-          column: 28,
-          data: { type: 'never' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowNever: false }],
-    },
-    // TS 3.9 change
-    {
-      code: `
-        function test<T extends any>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
-      `,
-      errors: [
-        {
-          column: 27,
-          data: { type: 'unknown' },
-          line: 3,
-          messageId: 'invalidType',
-        },
-      ],
-      options: [{ allowAny: true }],
-    },
-  ],
-
   valid: [
     // Base case
     `
@@ -455,160 +194,420 @@ ruleTester.run('restrict-template-expressions', rule, {
     },
     {
       code: `
-        const arg: any = undefined;
-        const msg = \`arg = \${arg || 'some-default'}\`;
+        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 }],
+    },
+    // allowNullish
+    {
+      code: `
+        const arg = null;
+        const msg = \`arg = \${arg}\`;
+      `,
+      options: [{ allowNullish: true }],
+    },
+    {
+      code: `
+        declare const arg: string | null | undefined;
+        const msg = \`arg = \${arg}\`;
+      `,
+      options: [{ allowNullish: true }],
+    },
+    {
+      code: `
+        function test<T extends null | undefined>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      options: [{ allowNullish: true }],
+    },
+    {
+      code: `
+        function test<T extends string | null>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      options: [{ allowNullish: true }],
+    },
+    // allowRegExp
+    {
+      code: `
+        const arg = new RegExp('foo');
+        const msg = \`arg = \${arg}\`;
+      `,
+      options: [{ allowRegExp: true }],
+    },
+    {
+      code: `
+        const arg = /foo/;
+        const msg = \`arg = \${arg}\`;
+      `,
+      options: [{ allowRegExp: true }],
+    },
+    {
+      code: `
+        declare const arg: string | RegExp;
+        const msg = \`arg = \${arg}\`;
+      `,
+      options: [{ allowRegExp: true }],
+    },
+    {
+      code: `
+        function test<T extends RegExp>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      options: [{ allowRegExp: true }],
+    },
+    {
+      code: `
+        function test<T extends string | RegExp>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      options: [{ allowRegExp: true }],
+    },
+    // allowNever
+    {
+      code: `
+        declare const value: never;
+        const stringy = \`\${value}\`;
+      `,
+      options: [{ allowNever: true }],
+    },
+    {
+      code: `
+        const arg = 'hello';
+        const msg = typeof arg === 'string' ? arg : \`arg = \${arg}\`;
+      `,
+      options: [{ allowNever: true }],
+    },
+    {
+      code: `
+        function test(arg: 'one' | 'two') {
+          switch (arg) {
+            case 'one':
+              return 1;
+            case 'two':
+              return 2;
+            default:
+              throw new Error(\`Unrecognised arg: \${arg}\`);
+          }
+        }
+      `,
+      options: [{ allowNever: true }],
+    },
+    {
+      code: `
+        // more variants may be added to Foo in the future
+        type Foo = { type: 'a'; value: number };
+
+        function checkFoosAreMatching(foo1: Foo, foo2: Foo) {
+          if (foo1.type !== foo2.type) {
+            // since Foo currently only has one variant, this code is never run, and \`foo1.type\` has type \`never\`.
+            throw new Error(\`expected \${foo1.type}, found \${foo2.type}\`);
+          }
+        }
+      `,
+      options: [{ allowNever: true }],
+    },
+    // allow ALL
+    {
+      code: `
+        type All = string | number | boolean | null | undefined | RegExp | never;
+        function test<T extends All>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      options: [
+        {
+          allowBoolean: true,
+          allowNever: true,
+          allowNullish: true,
+          allowNumber: true,
+          allowRegExp: true,
+        },
+      ],
+    },
+    'const msg = `arg = ${false}`;',
+    'const msg = `arg = ${null}`;',
+    'const msg = `arg = ${undefined}`;',
+    'const msg = `arg = ${123}`;',
+    "const msg = `arg = ${'abc'}`;",
+  ],
+  invalid: [
+    {
+      code: `
+        const msg = \`arg = \${123}\`;
       `,
-      options: [{ allowAny: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: '123' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNumber: false }],
     },
     {
       code: `
-        const user = JSON.parse('{ "name": "foo" }');
-        const msg = \`arg = \${user.name}\`;
+        const msg = \`arg = \${false}\`;
       `,
-      options: [{ allowAny: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'false' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowBoolean: false }],
     },
     {
       code: `
-        const user = JSON.parse('{ "name": "foo" }');
-        const msg = \`arg = \${user.name || 'the user with no name'}\`;
+        const msg = \`arg = \${null}\`;
       `,
-      options: [{ allowAny: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'null' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNullish: false }],
     },
-    // allowNullish
     {
       code: `
-        const arg = null;
+        declare const arg: number[];
         const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNullish: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'number[]' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
     },
     {
       code: `
-        declare const arg: string | null | undefined;
-        const msg = \`arg = \${arg}\`;
+        const msg = \`arg = \${[, 2]}\`;
       `,
-      options: [{ allowNullish: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: '(number | undefined)[]' },
+          line: 2,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowArray: true, allowNullish: false }],
     },
     {
       code: `
-        function test<T extends null | undefined>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
+        declare const arg: [number | undefined, string];
+        const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNullish: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: '[number | undefined, string]' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowArray: true, allowNullish: false }],
     },
     {
       code: `
-        function test<T extends string | null>(arg: T) {
-          return \`arg = \${arg}\`;
-        }
+        declare const arg: number;
+        const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNullish: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'number' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNumber: false }],
     },
-    // allowRegExp
     {
       code: `
-        const arg = new RegExp('foo');
+        declare const arg: boolean;
         const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowRegExp: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'boolean' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowBoolean: false }],
     },
     {
       code: `
-        const arg = /foo/;
+        const arg = {};
         const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowRegExp: true }],
+      errors: [
+        { column: 30, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
+      ],
+      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
     },
     {
       code: `
-        declare const arg: string | RegExp;
+        declare const arg: { a: string } & { b: string };
         const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowRegExp: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: '{ a: string; } & { b: string; }' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
     },
     {
       code: `
-        function test<T extends RegExp>(arg: T) {
+        function test<T extends {}>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      options: [{ allowRegExp: true }],
+      errors: [
+        { column: 27, data: { type: '{}' }, line: 3, messageId: 'invalidType' },
+      ],
+      options: [{ allowBoolean: true, allowNullish: true, allowNumber: true }],
     },
     {
       code: `
-        function test<T extends string | RegExp>(arg: T) {
+        function test<TWithNoConstraint>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      options: [{ allowRegExp: true }],
+      errors: [
+        {
+          column: 27,
+          data: { type: 'T' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumber: true,
+        },
+      ],
     },
-    // allowNever
     {
       code: `
-        declare const value: never;
-        const stringy = \`\${value}\`;
+        function test(arg: any) {
+          return \`arg = \${arg}\`;
+        }
       `,
-      options: [{ allowNever: true }],
+      errors: [
+        {
+          column: 27,
+          data: { type: 'any' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [
+        {
+          allowAny: false,
+          allowBoolean: true,
+          allowNullish: true,
+          allowNumber: true,
+        },
+      ],
     },
     {
       code: `
-        const arg = 'hello';
-        const msg = typeof arg === 'string' ? arg : \`arg = \${arg}\`;
+        const arg = new RegExp('foo');
+        const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNever: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'RegExp' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowRegExp: false }],
     },
     {
       code: `
-        function test(arg: 'one' | 'two') {
-          switch (arg) {
-            case 'one':
-              return 1;
-            case 'two':
-              return 2;
-            default:
-              throw new Error(\`Unrecognised arg: \${arg}\`);
-          }
-        }
+        const arg = /foo/;
+        const msg = \`arg = \${arg}\`;
       `,
-      options: [{ allowNever: true }],
+      errors: [
+        {
+          column: 30,
+          data: { type: 'RegExp' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowRegExp: false }],
     },
     {
       code: `
-        // more variants may be added to Foo in the future
-        type Foo = { type: 'a'; value: number };
-
-        function checkFoosAreMatching(foo1: Foo, foo2: Foo) {
-          if (foo1.type !== foo2.type) {
-            // since Foo currently only has one variant, this code is never run, and \`foo1.type\` has type \`never\`.
-            throw new Error(\`expected \${foo1.type}, found \${foo2.type}\`);
-          }
-        }
+        declare const value: never;
+        const stringy = \`\${value}\`;
       `,
-      options: [{ allowNever: true }],
+      errors: [
+        {
+          column: 28,
+          data: { type: 'never' },
+          line: 3,
+          messageId: 'invalidType',
+        },
+      ],
+      options: [{ allowNever: false }],
     },
-    // allow ALL
+    // TS 3.9 change
     {
       code: `
-        type All = string | number | boolean | null | undefined | RegExp | never;
-        function test<T extends All>(arg: T) {
+        function test<T extends any>(arg: T) {
           return \`arg = \${arg}\`;
         }
       `,
-      options: [
+      errors: [
         {
-          allowBoolean: true,
-          allowNever: true,
-          allowNullish: true,
-          allowNumber: true,
-          allowRegExp: true,
+          column: 27,
+          data: { type: 'unknown' },
+          line: 3,
+          messageId: 'invalidType',
         },
       ],
+      options: [{ allowAny: true }],
     },
-    'const msg = `arg = ${false}`;',
-    'const msg = `arg = ${null}`;',
-    'const msg = `arg = ${undefined}`;',
-    'const msg = `arg = ${123}`;',
-    "const msg = `arg = ${'abc'}`;",
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/return-await.test.ts b/packages/eslint-plugin/tests/rules/return-await.test.ts
index 393288621640..7934e99740ad 100644
--- a/packages/eslint-plugin/tests/rules/return-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/return-await.test.ts
@@ -18,308 +18,203 @@ const ruleTester = new RuleTester({
 
 // default rule is in-try-catch
 ruleTester.run('return-await', rule, {
-  invalid: [
+  valid: [
+    'return;', // No function in scope, so behave like return in a commonjs module
+    `
+      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');
+        }
+      }
+    `,
     {
       code: `
         async function test() {
-          return await 1;
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      output: `
-        async function test() {
-          return 1;
+          if (Math.random() < 0.33) {
+            return await Promise.resolve(1);
+          } else if (Math.random() < 0.5) {
+            return Promise.resolve(2);
+          }
+
+          try {
+          } catch (e) {
+            return await Promise.resolve(3);
+          } finally {
+            console.log('cleanup');
+          }
         }
       `,
+      options: ['error-handling-correctness-only'],
     },
+    `
+      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() {
-          const foo = 1;
-          return await { foo };
-        }
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      output: `
-        async function test() {
-          const foo = 1;
-          return { foo };
+        function test() {
+          return 1;
         }
       `,
+      options: ['in-try-catch'],
     },
     {
       code: `
         async function test() {
-          const foo = 1;
-          return await foo;
-        }
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      output: `
-        async function test() {
-          const foo = 1;
-          return foo;
+          return 1;
         }
       `,
+      options: ['in-try-catch'],
     },
     {
-      code: 'const test = async () => await 1;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      output: 'const test = async () => 1;',
+      code: 'const test = () => 1;',
+      options: ['in-try-catch'],
     },
     {
-      code: 'const test = async () => await /* comment */ 1;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      output: 'const test = async () => /* comment */ 1;',
+      code: 'const test = async () => 1;',
+      options: ['in-try-catch'],
     },
     {
       code: `
-const fn = (): any => null;
-async function test() {
-  return await fn();
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'nonPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'nonPromiseAwait',
-              output: `
-const fn = (): any => null;
-async function test() {
-  return fn();
-}
+        async function test() {
+          return Promise.resolve(1);
+        }
       `,
-            },
-          ],
-        },
-      ],
-      output: null,
+      options: ['in-try-catch'],
     },
     {
       code: `
-const fn = (): unknown => null;
-async function test() {
-  return await fn();
-}
-      `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'nonPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'nonPromiseAwait',
-              output: `
-const fn = (): unknown => null;
-async function test() {
-  return fn();
-}
-      `,
-            },
-          ],
-        },
-      ],
-      output: null,
-    },
-    {
-      code: 'const test = async () => await Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      output: 'const test = async () => Promise.resolve(1);',
-    },
-
-    ...['error-handling-correctness-only', 'always', 'in-try-catch'].map(
-      option =>
-        ({
-          code: `
         async function test() {
           try {
-            return Promise.resolve(1);
+            return await Promise.resolve(1);
           } catch (e) {
-            return Promise.resolve(2);
+            return await Promise.resolve(2);
           } finally {
             console.log('cleanup');
           }
         }
       `,
-          errors: [
-            {
-              line: 4,
-              messageId: 'requiredPromiseAwait',
-              suggestions: [
-                {
-                  messageId: 'requiredPromiseAwaitSuggestion',
-                  output: `
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
         async function test() {
           try {
-            return await Promise.resolve(1);
+            throw 'foo';
           } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
+            return Promise.resolve(1);
           }
         }
       `,
-                },
-              ],
-            },
-            {
-              line: 6,
-              messageId: 'requiredPromiseAwait',
-              suggestions: [
-                {
-                  messageId: 'requiredPromiseAwaitSuggestion',
-                  output: `
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
         async function test() {
           try {
-            return Promise.resolve(1);
+            throw 'foo';
           } catch (e) {
-            return await Promise.resolve(2);
+            throw 'foo2';
           } finally {
-            console.log('cleanup');
+            return Promise.resolve(1);
           }
         }
       `,
-                },
-              ],
-            },
-          ],
-          options: [option],
-          output: null,
-        }) satisfies InvalidTestCase<
-          'requiredPromiseAwait' | 'requiredPromiseAwaitSuggestion',
-          [string]
-        >,
-    ),
-
+      options: ['in-try-catch'],
+    },
     {
       code: `
         async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      output: `
-        async function test() {
-          return Promise.resolve(1);
+          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: `
         async function test() {
-          return await 1;
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      options: ['in-try-catch'],
-      output: `
-        async function test() {
-          return 1;
+          return Promise.resolve(1);
         }
       `,
+      options: ['never'],
     },
     {
-      code: 'const test = async () => await 1;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      options: ['in-try-catch'],
-      output: 'const test = async () => 1;',
-    },
-    {
-      code: 'const test = async () => await Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      options: ['in-try-catch'],
-      output: 'const test = async () => Promise.resolve(1);',
+      code: 'const test = async () => Promise.resolve(1);',
+      options: ['never'],
     },
     {
       code: `
         async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      options: ['in-try-catch'],
-      output: `
-        async function test() {
-          return Promise.resolve(1);
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
       `,
+      options: ['never'],
     },
     {
       code: `
         async function test() {
-          return await 1;
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      options: ['never'],
-      output: `
-        async function test() {
-          return 1;
+          return await Promise.resolve(1);
         }
       `,
+      options: ['always'],
+    },
+    {
+      code: 'const test = async () => await Promise.resolve(1);',
+      options: ['always'],
     },
     {
       code: `
@@ -333,297 +228,303 @@ async function test() {
           }
         }
       `,
-      errors: [
-        {
-          line: 4,
-          messageId: 'disallowedPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'disallowedPromiseAwaitSuggestion',
-              output: `
-        async function test() {
-          try {
-            return Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
+      options: ['always'],
+    },
+    {
+      code: `
+        declare function foo(): Promise<boolean>;
+
+        function bar(baz: boolean): Promise<boolean> | boolean {
+          if (baz) {
+            return true;
+          } else {
+            return foo();
           }
         }
       `,
-            },
-          ],
-        },
-        {
-          line: 6,
-          messageId: 'disallowedPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'disallowedPromiseAwaitSuggestion',
-              output: `
-        async function test() {
+      options: ['always'],
+    },
+    {
+      code: `
+        async function test(): Promise<string> {
+          const res = await Promise.resolve('{}');
           try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
+            return JSON.parse(res);
+          } catch (error) {
+            return res;
           }
         }
       `,
-            },
-          ],
-        },
-      ],
-      options: ['never'],
-      output: null,
     },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8663
     {
       code: `
         async function test() {
-          return await Promise.resolve(1);
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'disallowedPromiseAwait',
-        },
-      ],
-      options: ['never'],
-      output: `
-        async function test() {
-          return Promise.resolve(1);
+          const res = await Promise.resolve('{}');
+          try {
+            async function nested() {
+              return Promise.resolve('ok');
+            }
+            return await nested();
+          } catch (error) {
+            return Promise.resolve('error');
+          }
         }
       `,
     },
     {
       code: `
-        async function test() {
-          return await 1;
-        }
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'nonPromiseAwait',
-        },
-      ],
-      options: ['always'],
-      output: `
-        async function test() {
-          return 1;
-        }
+async function f() {
+  try {
+  } catch {
+    try {
+    } catch {
+      return Promise.reject();
+    }
+  }
+}
       `,
     },
     {
       code: `
-        async function test() {
-          return Promise.resolve(1);
-        }
+async function f() {
+  try {
+  } finally {
+    try {
+    } catch {
+      return Promise.reject();
+    }
+  }
+}
       `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
-      options: ['always'],
-      output: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
+    },
+    {
+      code: `
+async function f() {
+  try {
+  } finally {
+    try {
+    } finally {
+      try {
+      } catch {
+        return Promise.reject();
+      }
+    }
+  }
+}
       `,
     },
     {
-      code: 'const test = async () => Promise.resolve(1);',
-      errors: [
-        {
-          line: 1,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
-      options: ['always'],
-      output: 'const test = async () => await Promise.resolve(1);',
+      code: `
+declare const bleh: any;
+async function f() {
+  using something = bleh;
+  return await Promise.resolve(2);
+}
+      `,
     },
     {
-      code: noFormat`
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo()) ? bar() : baz();
+      code: `
+declare const bleh: any;
+async function f() {
+  await using something = bleh;
+  return await Promise.resolve(2);
 }
       `,
-      errors: [
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
-      options: ['always'],
-      output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo()) ? await bar() : await baz();
+    },
+    {
+      code: `
+declare const bleh: any;
+async function f() {
+  using something = bleh;
+  {
+    return await Promise.resolve(2);
+  }
 }
       `,
     },
     {
-      code: noFormat`
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo())
-    ? (
-      bar ? bar() : baz()
-    ) : baz ? baz() : bar();
+      code: `
+declare const bleh: any;
+async function f() {
+  return Promise.resolve(2);
+  using something = bleh;
+}
+      `,
+    },
+    {
+      code: `
+declare const bleh: any;
+async function f() {
+  return await Promise.resolve(2);
+  using something = bleh;
 }
       `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 9,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 10,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 10,
-          messageId: 'requiredPromiseAwait',
-        },
-      ],
       options: ['always'],
-      output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-async function qux() {}
-async function buzz() {
-  return (await foo())
-    ? (
-      bar ? await bar() : await baz()
-    ) : baz ? await baz() : await bar();
+    },
+    {
+      code: `
+declare function asyncFn(): Promise<unknown>;
+async function returnAwait() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  return await asyncFn();
 }
       `,
+      options: ['in-try-catch'],
     },
     {
       code: `
-async function foo() {}
-async function bar() {}
-async function buzz() {
-  return (await foo()) ? await 1 : bar();
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  async function innerFunction() {
+    return asyncFn();
+  }
+}
+      `,
+      options: ['in-try-catch'],
+    },
+    {
+      code: `
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
+    },
+  };
+
+  const innerFunction = async () => asyncFn();
+}
+      `,
+      options: ['in-try-catch'],
+    },
+    {
+      // intentionally invalid AST - return is outside a function.
+      // We just want to be sure this doesn't crash.
+      code: `
+using foo = 1 as any;
+return Promise.resolve(42);
+      `,
+    },
+    {
+      // intentionally invalid AST - return is outside a function.
+      // We just want to be sure this doesn't crash.
+      code: `
+{
+  using foo = 1 as any;
+  return Promise.resolve(42);
 }
       `,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
       errors: [
         {
-          line: 5,
+          line: 3,
           messageId: 'nonPromiseAwait',
         },
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-        },
       ],
-      options: ['always'],
       output: `
-async function foo() {}
-async function bar() {}
-async function buzz() {
-  return (await foo()) ? 1 : await bar();
-}
+        async function test() {
+          return 1;
+        }
       `,
     },
     {
       code: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-const buzz = async () => ((await foo()) ? bar() : baz());
+        async function test() {
+          const foo = 1;
+          return await { foo };
+        }
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-        },
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
+          line: 4,
+          messageId: 'nonPromiseAwait',
         },
       ],
-      options: ['always'],
       output: `
-async function foo() {}
-async function bar() {}
-async function baz() {}
-const buzz = async () => ((await foo()) ? await bar() : await baz());
+        async function test() {
+          const foo = 1;
+          return { foo };
+        }
       `,
     },
     {
       code: `
-async function foo() {}
-async function bar() {}
-const buzz = async () => ((await foo()) ? await 1 : bar());
+        async function test() {
+          const foo = 1;
+          return await foo;
+        }
       `,
       errors: [
         {
           line: 4,
           messageId: 'nonPromiseAwait',
         },
-        {
-          line: 4,
-          messageId: 'requiredPromiseAwait',
-        },
       ],
-      options: ['always'],
       output: `
-async function foo() {}
-async function bar() {}
-const buzz = async () => ((await foo()) ? 1 : await bar());
+        async function test() {
+          const foo = 1;
+          return foo;
+        }
       `,
     },
     {
-      // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+      code: 'const test = async () => await 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => 1;',
+    },
+    {
+      code: 'const test = async () => await /* comment */ 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => /* comment */ 1;',
+    },
+    {
       code: `
-async function test<T>(): Promise<T> {
-  const res = await fetch('...');
-  try {
-    return res.json() as Promise<T>;
-  } catch (err) {
-    throw Error('Request Failed.');
-  }
+const fn = (): any => null;
+async function test() {
+  return await fn();
 }
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
+          line: 4,
+          messageId: 'nonPromiseAwait',
           suggestions: [
             {
-              messageId: 'requiredPromiseAwaitSuggestion',
+              messageId: 'nonPromiseAwait',
               output: `
-async function test<T>(): Promise<T> {
-  const res = await fetch('...');
-  try {
-    return await (res.json() as Promise<T>);
-  } catch (err) {
-    throw Error('Request Failed.');
-  }
+const fn = (): any => null;
+async function test() {
+  return fn();
 }
       `,
             },
@@ -634,41 +535,23 @@ async function test<T>(): Promise<T> {
     },
     {
       code: `
-        async function test() {
-          try {
-            const callback1 = function () {};
-            const callback2 = async function () {};
-            function callback3() {}
-            async function callback4() {}
-            const callback5 = () => {};
-            const callback6 = async () => {};
-            return Promise.resolve('try');
-          } finally {
-            return Promise.resolve('finally');
-          }
-        }
+const fn = (): unknown => null;
+async function test() {
+  return await fn();
+}
       `,
       errors: [
         {
-          line: 10,
-          messageId: 'requiredPromiseAwait',
+          line: 4,
+          messageId: 'nonPromiseAwait',
           suggestions: [
             {
-              messageId: 'requiredPromiseAwaitSuggestion',
+              messageId: 'nonPromiseAwait',
               output: `
-        async function test() {
-          try {
-            const callback1 = function () {};
-            const callback2 = async function () {};
-            function callback3() {}
-            async function callback4() {}
-            const callback5 = () => {};
-            const callback6 = async () => {};
-            return await Promise.resolve('try');
-          } finally {
-            return Promise.resolve('finally');
-          }
-        }
+const fn = (): unknown => null;
+async function test() {
+  return fn();
+}
       `,
             },
           ],
@@ -677,188 +560,224 @@ async function test<T>(): Promise<T> {
       output: null,
     },
     {
-      code: `
-        async function bar() {}
-        async function foo() {
+      code: 'const test = async () => await Promise.resolve(1);',
+      errors: [
+        {
+          line: 1,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      output: 'const test = async () => Promise.resolve(1);',
+    },
+
+    ...['error-handling-correctness-only', 'always', 'in-try-catch'].map(
+      option =>
+        ({
+          code: `
+        async function test() {
           try {
-            return undefined || bar();
-          } catch {}
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
       `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
+          errors: [
             {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-        async function bar() {}
-        async function foo() {
+              line: 4,
+              messageId: 'requiredPromiseAwait',
+              suggestions: [
+                {
+                  messageId: 'requiredPromiseAwaitSuggestion',
+                  output: `
+        async function test() {
           try {
-            return await (undefined || bar());
-          } catch {}
+            return await Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
+        }
+      `,
+                },
+              ],
+            },
+            {
+              line: 6,
+              messageId: 'requiredPromiseAwait',
+              suggestions: [
+                {
+                  messageId: 'requiredPromiseAwaitSuggestion',
+                  output: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
       `,
+                },
+              ],
             },
           ],
+          options: [option],
+          output: null,
+        }) satisfies InvalidTestCase<
+          'requiredPromiseAwait' | 'requiredPromiseAwaitSuggestion',
+          [string]
+        >,
+    ),
+
+    {
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
-      output: null,
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
     },
     {
       code: `
-        async function bar() {}
-        async function foo() {
-          try {
-            return bar() || undefined || bar();
-          } catch {}
+        async function test() {
+          return await 1;
         }
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-        async function bar() {}
-        async function foo() {
-          try {
-            return await (bar() || undefined || bar());
-          } catch {}
+          line: 3,
+          messageId: 'nonPromiseAwait',
+        },
+      ],
+      options: ['in-try-catch'],
+      output: `
+        async function test() {
+          return 1;
         }
       `,
-            },
-          ],
+    },
+    {
+      code: 'const test = async () => await 1;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'nonPromiseAwait',
         },
       ],
-      output: null,
+      options: ['in-try-catch'],
+      output: 'const test = async () => 1;',
     },
     {
-      code: `
-async function bar() {}
-async function func1() {
-  try {
-    return null ?? bar();
-  } catch {}
-}
-      `,
+      code: 'const test = async () => await Promise.resolve(1);',
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function bar() {}
-async function func1() {
-  try {
-    return await (null ?? bar());
-  } catch {}
-}
-      `,
-            },
-          ],
+          line: 1,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
-      output: null,
+      options: ['in-try-catch'],
+      output: 'const test = async () => Promise.resolve(1);',
     },
     {
       code: `
-async function bar() {}
-async function func2() {
-  try {
-    return 1 && bar();
-  } catch {}
-}
+        async function test() {
+          return await Promise.resolve(1);
+        }
       `,
       errors: [
         {
-          line: 5,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function bar() {}
-async function func2() {
-  try {
-    return await (1 && bar());
-  } catch {}
-}
-      `,
-            },
-          ],
+          line: 3,
+          messageId: 'disallowedPromiseAwait',
         },
       ],
-      output: null,
+      options: ['in-try-catch'],
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
     },
     {
       code: `
-const foo = {
-  bar: async function () {},
-};
-async function func3() {
-  try {
-    return foo.bar();
-  } catch {}
-}
+        async function test() {
+          return await 1;
+        }
       `,
       errors: [
         {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-const foo = {
-  bar: async function () {},
-};
-async function func3() {
-  try {
-    return await foo.bar();
-  } catch {}
-}
-      `,
-            },
-          ],
+          line: 3,
+          messageId: 'nonPromiseAwait',
         },
       ],
-      output: null,
+      options: ['never'],
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
     },
     {
       code: `
-        class X {
-          async bar() {
-            return;
-          }
-          async func2() {
-            try {
-              return this.bar();
-            } catch {}
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
         }
       `,
       errors: [
         {
-          line: 8,
-          messageId: 'requiredPromiseAwait',
+          line: 4,
+          messageId: 'disallowedPromiseAwait',
           suggestions: [
             {
-              messageId: 'requiredPromiseAwaitSuggestion',
+              messageId: 'disallowedPromiseAwaitSuggestion',
               output: `
-        class X {
-          async bar() {
-            return;
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
-          async func2() {
-            try {
-              return await this.bar();
-            } catch {}
+        }
+      `,
+            },
+          ],
+        },
+        {
+          line: 6,
+          messageId: 'disallowedPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'disallowedPromiseAwaitSuggestion',
+              output: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
           }
         }
       `,
@@ -866,573 +785,520 @@ async function func3() {
           ],
         },
       ],
+      options: ['never'],
       output: null,
     },
     {
       code: `
         async function test() {
-          const res = await Promise.resolve('{}');
-          try {
-            async function nested() {
-              return Promise.resolve('ok');
-            }
-            return await nested();
-          } catch (error) {
-            return await Promise.resolve('error');
-          }
+          return await Promise.resolve(1);
         }
       `,
       errors: [
         {
-          line: 10,
+          line: 3,
           messageId: 'disallowedPromiseAwait',
         },
       ],
+      options: ['never'],
       output: `
         async function test() {
-          const res = await Promise.resolve('{}');
-          try {
-            async function nested() {
-              return Promise.resolve('ok');
-            }
-            return await nested();
-          } catch (error) {
-            return Promise.resolve('error');
-          }
+          return Promise.resolve(1);
         }
       `,
     },
     {
       code: `
-async function f() {
-  try {
-    try {
-    } finally {
-      // affects error handling of outer catch
-      return Promise.reject();
-    }
-  } catch {}
-}
+        async function test() {
+          return await 1;
+        }
       `,
       errors: [
         {
-          line: 7,
-          messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-    try {
-    } finally {
-      // affects error handling of outer catch
-      return await Promise.reject();
-    }
-  } catch {}
-}
-      `,
-            },
-          ],
+          line: 3,
+          messageId: 'nonPromiseAwait',
         },
       ],
-      output: null,
+      options: ['always'],
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
     },
     {
       code: `
-async function f() {
-  try {
-    try {
-    } catch {
-      // affects error handling of outer catch
-      return Promise.reject();
-    }
-  } catch {}
-}
+        async function test() {
+          return Promise.resolve(1);
+        }
       `,
       errors: [
         {
-          line: 7,
+          line: 3,
           messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-    try {
-    } catch {
-      // affects error handling of outer catch
-      return await Promise.reject();
-    }
-  } catch {}
-}
-      `,
-            },
-          ],
         },
       ],
-      output: null,
+      options: ['always'],
+      output: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
     },
     {
-      code: `
-async function f() {
-  try {
-  } catch {
-    try {
-    } finally {
-      try {
-      } catch {
-        return Promise.reject();
-      }
-    }
-  } finally {
-  }
-}
-      `,
+      code: 'const test = async () => Promise.resolve(1);',
       errors: [
         {
-          line: 9,
+          line: 1,
           messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-async function f() {
-  try {
-  } catch {
-    try {
-    } finally {
-      try {
-      } catch {
-        return await Promise.reject();
-      }
-    }
-  } finally {
-  }
-}
-      `,
-            },
-          ],
         },
       ],
-      output: null,
+      options: ['always'],
+      output: 'const test = async () => await Promise.resolve(1);',
     },
     {
-      code: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    using something = bleh;
-    if (anotherCondition) {
-      return Promise.resolve(2);
-    }
-  }
+      code: noFormat`
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo()) ? bar() : baz();
 }
       `,
       errors: [
         {
           line: 7,
           messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    using something = bleh;
-    if (anotherCondition) {
-      return await Promise.resolve(2);
-    }
-  }
-}
-      `,
-            },
-          ],
+        },
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
         },
       ],
       options: ['always'],
-      output: null,
+      output: `
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo()) ? await bar() : await baz();
+}
+      `,
     },
     {
-      code: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    await using something = bleh;
-    if (anotherCondition) {
-      return Promise.resolve(2);
-    }
-  }
+      code: noFormat`
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo())
+    ? (
+      bar ? bar() : baz()
+    ) : baz ? baz() : bar();
 }
       `,
       errors: [
         {
-          line: 7,
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 10,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 10,
           messageId: 'requiredPromiseAwait',
-          suggestions: [
-            {
-              messageId: 'requiredPromiseAwaitSuggestion',
-              output: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    await using something = bleh;
-    if (anotherCondition) {
-      return await Promise.resolve(2);
-    }
-  }
-}
-      `,
-            },
-          ],
         },
       ],
       options: ['always'],
-      output: null,
+      output: `
+async function foo() {}
+async function bar() {}
+async function baz() {}
+async function qux() {}
+async function buzz() {
+  return (await foo())
+    ? (
+      bar ? await bar() : await baz()
+    ) : baz ? await baz() : await bar();
+}
+      `,
     },
     {
       code: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    using something = bleh;
-  } else if (anotherCondition) {
-    return Promise.resolve(2);
-  }
+async function foo() {}
+async function bar() {}
+async function buzz() {
+  return (await foo()) ? await 1 : bar();
 }
       `,
       errors: [
         {
-          line: 7,
+          line: 5,
+          messageId: 'nonPromiseAwait',
+        },
+        {
+          line: 5,
           messageId: 'requiredPromiseAwait',
         },
       ],
       options: ['always'],
       output: `
-declare const bleh: any;
-async function f() {
-  if (cond) {
-    using something = bleh;
-  } else if (anotherCondition) {
-    return await Promise.resolve(2);
-  }
+async function foo() {}
+async function bar() {}
+async function buzz() {
+  return (await foo()) ? 1 : await bar();
 }
       `,
     },
     {
       code: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  async function innerFunction() {
-    return await asyncFn();
-  }
-}
+async function foo() {}
+async function bar() {}
+async function baz() {}
+const buzz = async () => ((await foo()) ? bar() : baz());
       `,
       errors: [
         {
-          line: 11,
-          messageId: 'disallowedPromiseAwait',
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+        },
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
         },
       ],
-      options: ['in-try-catch'],
+      options: ['always'],
       output: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  async function innerFunction() {
-    return asyncFn();
-  }
-}
+async function foo() {}
+async function bar() {}
+async function baz() {}
+const buzz = async () => ((await foo()) ? await bar() : await baz());
       `,
     },
     {
       code: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
-    },
-  };
-
-  const innerFunction = async () => await asyncFn();
-}
+async function foo() {}
+async function bar() {}
+const buzz = async () => ((await foo()) ? await 1 : bar());
       `,
       errors: [
         {
-          line: 10,
-          messageId: 'disallowedPromiseAwait',
+          line: 4,
+          messageId: 'nonPromiseAwait',
+        },
+        {
+          line: 4,
+          messageId: 'requiredPromiseAwait',
         },
       ],
-      options: ['in-try-catch'],
+      options: ['always'],
       output: `
-declare function asyncFn(): Promise<unknown>;
-async function outerFunction() {
-  using _ = {
-    [Symbol.dispose]: () => {
-      console.log('dispose');
+async function foo() {}
+async function bar() {}
+const buzz = async () => ((await foo()) ? 1 : await bar());
+      `,
     },
-  };
-
-  const innerFunction = async () => asyncFn();
+    {
+      // https://github.com/typescript-eslint/typescript-eslint/issues/2109
+      code: `
+async function test<T>(): Promise<T> {
+  const res = await fetch('...');
+  try {
+    return res.json() as Promise<T>;
+  } catch (err) {
+    throw Error('Request Failed.');
+  }
+}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function test<T>(): Promise<T> {
+  const res = await fetch('...');
+  try {
+    return await (res.json() as Promise<T>);
+  } catch (err) {
+    throw Error('Request Failed.');
+  }
 }
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
-  ],
-  valid: [
-    'return;', // No function in scope, so behave like return in a commonjs module
-    `
-      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');
-        }
-      }
-    `,
     {
       code: `
         async function test() {
-          if (Math.random() < 0.33) {
-            return await Promise.resolve(1);
-          } else if (Math.random() < 0.5) {
-            return Promise.resolve(2);
-          }
-
           try {
-          } catch (e) {
-            return await Promise.resolve(3);
+            const callback1 = function () {};
+            const callback2 = async function () {};
+            function callback3() {}
+            async function callback4() {}
+            const callback5 = () => {};
+            const callback6 = async () => {};
+            return Promise.resolve('try');
           } finally {
-            console.log('cleanup');
+            return Promise.resolve('finally');
           }
         }
       `,
-      options: ['error-handling-correctness-only'],
-    },
-    `
-      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: `
-        function test() {
-          return 1;
-        }
-      `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
-        async function test() {
-          return 1;
-        }
-      `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: 'const test = () => 1;',
-      options: ['in-try-catch'],
-    },
-    {
-      code: 'const test = async () => 1;',
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
-        async function test() {
-          return Promise.resolve(1);
-        }
-      `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
+      errors: [
+        {
+          line: 10,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
         async function test() {
           try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
+            const callback1 = function () {};
+            const callback2 = async function () {};
+            function callback3() {}
+            async function callback4() {}
+            const callback5 = () => {};
+            const callback6 = async () => {};
+            return await Promise.resolve('try');
           } finally {
-            console.log('cleanup');
+            return Promise.resolve('finally');
           }
         }
       `,
-      options: ['in-try-catch'],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test() {
+        async function bar() {}
+        async function foo() {
           try {
-            throw 'foo';
-          } catch (e) {
-            return Promise.resolve(1);
-          }
+            return undefined || bar();
+          } catch {}
         }
       `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
-        async function test() {
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+        async function bar() {}
+        async function foo() {
           try {
-            throw 'foo';
-          } catch (e) {
-            throw 'foo2';
-          } finally {
-            return Promise.resolve(1);
-          }
+            return await (undefined || bar());
+          } catch {}
         }
       `,
-      options: ['in-try-catch'],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test() {
+        async function bar() {}
+        async function foo() {
           try {
-            const one = await Promise.resolve(1);
-            return one;
-          } catch (e) {
-            const two = await Promise.resolve(2);
-            return two;
-          } finally {
-            console.log('cleanup');
-          }
+            return bar() || undefined || bar();
+          } catch {}
         }
       `,
-      options: ['in-try-catch'],
-    },
-    {
-      code: `
-        async function test() {
-          return Promise.resolve(1);
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+        async function bar() {}
+        async function foo() {
+          try {
+            return await (bar() || undefined || bar());
+          } catch {}
         }
       `,
-      options: ['never'],
-    },
-    {
-      code: 'const test = async () => Promise.resolve(1);',
-      options: ['never'],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test() {
-          try {
-            return Promise.resolve(1);
-          } catch (e) {
-            return Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
-          }
-        }
+async function bar() {}
+async function func1() {
+  try {
+    return null ?? bar();
+  } catch {}
+}
       `,
-      options: ['never'],
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function bar() {}
+async function func1() {
+  try {
+    return await (null ?? bar());
+  } catch {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test() {
-          return await Promise.resolve(1);
-        }
+async function bar() {}
+async function func2() {
+  try {
+    return 1 && bar();
+  } catch {}
+}
       `,
-      options: ['always'],
+      errors: [
+        {
+          line: 5,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function bar() {}
+async function func2() {
+  try {
+    return await (1 && bar());
+  } catch {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
-      code: 'const test = async () => await Promise.resolve(1);',
-      options: ['always'],
+      code: `
+const foo = {
+  bar: async function () {},
+};
+async function func3() {
+  try {
+    return foo.bar();
+  } catch {}
+}
+      `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+const foo = {
+  bar: async function () {},
+};
+async function func3() {
+  try {
+    return await foo.bar();
+  } catch {}
+}
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test() {
-          try {
-            return await Promise.resolve(1);
-          } catch (e) {
-            return await Promise.resolve(2);
-          } finally {
-            console.log('cleanup');
+        class X {
+          async bar() {
+            return;
+          }
+          async func2() {
+            try {
+              return this.bar();
+            } catch {}
           }
         }
       `,
-      options: ['always'],
-    },
-    {
-      code: `
-        declare function foo(): Promise<boolean>;
-
-        function bar(baz: boolean): Promise<boolean> | boolean {
-          if (baz) {
-            return true;
-          } else {
-            return foo();
+      errors: [
+        {
+          line: 8,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+        class X {
+          async bar() {
+            return;
+          }
+          async func2() {
+            try {
+              return await this.bar();
+            } catch {}
           }
         }
       `,
-      options: ['always'],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        async function test(): Promise<string> {
+        async function test() {
           const res = await Promise.resolve('{}');
           try {
-            return JSON.parse(res);
+            async function nested() {
+              return Promise.resolve('ok');
+            }
+            return await nested();
           } catch (error) {
-            return res;
+            return await Promise.resolve('error');
           }
         }
       `,
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8663
-    {
-      code: `
+      errors: [
+        {
+          line: 10,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
+      output: `
         async function test() {
           const res = await Promise.resolve('{}');
           try {
@@ -1450,33 +1316,79 @@ async function outerFunction() {
       code: `
 async function f() {
   try {
-  } catch {
     try {
-    } catch {
+    } finally {
+      // affects error handling of outer catch
       return Promise.reject();
     }
-  }
+  } catch {}
+}
+      `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function f() {
+  try {
+    try {
+    } finally {
+      // affects error handling of outer catch
+      return await Promise.reject();
+    }
+  } catch {}
 }
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 async function f() {
   try {
-  } finally {
     try {
     } catch {
+      // affects error handling of outer catch
       return Promise.reject();
     }
-  }
+  } catch {}
+}
+      `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function f() {
+  try {
+    try {
+    } catch {
+      // affects error handling of outer catch
+      return await Promise.reject();
+    }
+  } catch {}
 }
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 async function f() {
   try {
-  } finally {
+  } catch {
     try {
     } finally {
       try {
@@ -1484,75 +1396,164 @@ async function f() {
         return Promise.reject();
       }
     }
+  } finally {
+  }
+}
+      `,
+      errors: [
+        {
+          line: 9,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
+async function f() {
+  try {
+  } catch {
+    try {
+    } finally {
+      try {
+      } catch {
+        return await Promise.reject();
+      }
+    }
+  } finally {
   }
 }
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  using something = bleh;
-  return await Promise.resolve(2);
+  if (cond) {
+    using something = bleh;
+    if (anotherCondition) {
+      return Promise.resolve(2);
+    }
+  }
 }
       `,
-    },
-    {
-      code: `
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
 declare const bleh: any;
 async function f() {
-  await using something = bleh;
-  return await Promise.resolve(2);
+  if (cond) {
+    using something = bleh;
+    if (anotherCondition) {
+      return await Promise.resolve(2);
+    }
+  }
 }
       `,
+            },
+          ],
+        },
+      ],
+      options: ['always'],
+      output: null,
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  using something = bleh;
-  {
-    return await Promise.resolve(2);
+  if (cond) {
+    await using something = bleh;
+    if (anotherCondition) {
+      return Promise.resolve(2);
+    }
   }
 }
       `,
-    },
-    {
-      code: `
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+          suggestions: [
+            {
+              messageId: 'requiredPromiseAwaitSuggestion',
+              output: `
 declare const bleh: any;
 async function f() {
-  return Promise.resolve(2);
-  using something = bleh;
+  if (cond) {
+    await using something = bleh;
+    if (anotherCondition) {
+      return await Promise.resolve(2);
+    }
+  }
 }
       `,
+            },
+          ],
+        },
+      ],
+      options: ['always'],
+      output: null,
     },
     {
       code: `
 declare const bleh: any;
 async function f() {
-  return await Promise.resolve(2);
-  using something = bleh;
+  if (cond) {
+    using something = bleh;
+  } else if (anotherCondition) {
+    return Promise.resolve(2);
+  }
 }
       `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'requiredPromiseAwait',
+        },
+      ],
       options: ['always'],
+      output: `
+declare const bleh: any;
+async function f() {
+  if (cond) {
+    using something = bleh;
+  } else if (anotherCondition) {
+    return await Promise.resolve(2);
+  }
+}
+      `,
     },
     {
       code: `
 declare function asyncFn(): Promise<unknown>;
-async function returnAwait() {
+async function outerFunction() {
   using _ = {
     [Symbol.dispose]: () => {
       console.log('dispose');
     },
   };
 
-  return await asyncFn();
+  async function innerFunction() {
+    return await asyncFn();
+  }
 }
       `,
+      errors: [
+        {
+          line: 11,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
       options: ['in-try-catch'],
-    },
-    {
-      code: `
+      output: `
 declare function asyncFn(): Promise<unknown>;
 async function outerFunction() {
   using _ = {
@@ -1566,7 +1567,6 @@ async function outerFunction() {
   }
 }
       `,
-      options: ['in-try-catch'],
     },
     {
       code: `
@@ -1578,26 +1578,26 @@ async function outerFunction() {
     },
   };
 
-  const innerFunction = async () => asyncFn();
+  const innerFunction = async () => await asyncFn();
 }
       `,
+      errors: [
+        {
+          line: 10,
+          messageId: 'disallowedPromiseAwait',
+        },
+      ],
       options: ['in-try-catch'],
+      output: `
+declare function asyncFn(): Promise<unknown>;
+async function outerFunction() {
+  using _ = {
+    [Symbol.dispose]: () => {
+      console.log('dispose');
     },
-    {
-      // intentionally invalid AST - return is outside a function.
-      // We just want to be sure this doesn't crash.
-      code: `
-using foo = 1 as any;
-return Promise.resolve(42);
-      `,
-    },
-    {
-      // intentionally invalid AST - return is outside a function.
-      // We just want to be sure this doesn't crash.
-      code: `
-{
-  using foo = 1 as any;
-  return Promise.resolve(42);
+  };
+
+  const innerFunction = async () => asyncFn();
 }
       `,
     },
diff --git a/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts b/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
index 3fc5d7491a7b..a02bf7214d66 100644
--- a/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
@@ -320,72 +320,6 @@ type T =
 };
 
 ruleTester.run('sort-type-constituents', rule, {
-  invalid: [
-    ...invalid('|'),
-    ...invalid('&'),
-    {
-      code: 'type T = (B | C) & A;',
-      errors: [
-        {
-          data: {
-            name: 'T',
-            type: 'Intersection',
-          },
-          messageId: 'notSortedNamed',
-        },
-      ],
-      output: `type T = A & (B | C);`,
-    },
-    {
-      code: "type A<T> = (T extends number ? 'hi' : 'there') | string;",
-      errors: [
-        {
-          data: {
-            name: 'A',
-            type: 'Union',
-          },
-          messageId: 'notSortedNamed',
-        },
-      ],
-      output: "type A<T> = string | (T extends number ? 'hi' : 'there');",
-    },
-    {
-      code: "type T = 'DeletedAt' | 'DeleteForever';",
-      errors: [
-        {
-          data: {
-            name: 'T',
-            type: 'Union',
-          },
-          messageId: 'notSortedNamed',
-        },
-      ],
-      options: [
-        {
-          caseSensitive: true,
-        },
-      ],
-      output: "type T = 'DeleteForever' | 'DeletedAt';",
-    },
-    {
-      code: 'type T = { a: string } | { A: string } | { B: string };',
-      errors: [
-        {
-          data: {
-            name: 'T',
-            type: 'Union',
-          },
-          messageId: 'notSortedNamed',
-        },
-      ],
-      options: [
-        {
-          caseSensitive: true,
-        },
-      ],
-      output: 'type T = { A: string } | { B: string } | { a: string };',
-    },
-  ],
   valid: [
     ...valid('|'),
     {
@@ -454,4 +388,70 @@ type T = 1 | string | {} | A;
     },
     "type A<T> = string | (T extends number ? 'hi' : 'there');",
   ],
+  invalid: [
+    ...invalid('|'),
+    ...invalid('&'),
+    {
+      code: 'type T = (B | C) & A;',
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Intersection',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      output: `type T = A & (B | C);`,
+    },
+    {
+      code: "type A<T> = (T extends number ? 'hi' : 'there') | string;",
+      errors: [
+        {
+          data: {
+            name: 'A',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      output: "type A<T> = string | (T extends number ? 'hi' : 'there');",
+    },
+    {
+      code: "type T = 'DeletedAt' | 'DeleteForever';",
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      options: [
+        {
+          caseSensitive: true,
+        },
+      ],
+      output: "type T = 'DeleteForever' | 'DeletedAt';",
+    },
+    {
+      code: 'type T = { a: string } | { A: string } | { B: string };',
+      errors: [
+        {
+          data: {
+            name: 'T',
+            type: 'Union',
+          },
+          messageId: 'notSortedNamed',
+        },
+      ],
+      options: [
+        {
+          caseSensitive: true,
+        },
+      ],
+      output: 'type T = { A: string } | { B: string } | { a: string };',
+    },
+  ],
 });
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 51d1369cf12f..a24c50c1e92b 100644
--- a/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
@@ -22,2807 +22,2799 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('strict-boolean-expressions', rule, {
-  invalid: [
-    // non-boolean in RHS of test expression
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        if (true && (1 + 1)) {}
-        while (false || "a" + "b") {}
-        (x: object) => true || false || x ? true : false;
-      `,
-      errors: [
-        {
-          column: 14,
-          line: 2,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: 'if (true && ((1 + 1) !== 0)) {}',
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: 'if (true && (!Number.isNaN((1 + 1)))) {}',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: 'if (true && (Boolean((1 + 1)))) {}',
-            },
-          ],
-        },
-        {
-          column: 25,
-          line: 3,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: '        while (false || (("a" + "b").length > 0)) {}',
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: '        while (false || (("a" + "b") !== "")) {}',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: '        while (false || (Boolean(("a" + "b")))) {}',
-            },
-          ],
-        },
-        { column: 41, line: 4, messageId: 'conditionErrorObject' },
-      ],
-      options: [
-        { allowNullableObject: false, allowNumber: false, allowString: false },
-      ],
-    }),
+  valid: [
+    // boolean in boolean context
+    "true ? 'a' : 'b';",
+    `
+if (false) {
+}
+    `,
+    'while (true) {}',
+    'for (; false; ) {}',
+    '!true;',
+    'false || 123;',
+    "true && 'foo';",
+    '!(false || true);',
+    'true && false ? true : false;',
+    '(false && true) || false;',
+    '(false && true) || [];',
+    '(false && 1) || (true && 2);',
+    `
+declare const x: boolean;
+if (x) {
+}
+    `,
+    '(x: boolean) => !x;',
+    '<T extends boolean>(x: T) => (x ? 1 : 0);',
+    `
+declare const x: never;
+if (x) {
+}
+    `,
 
-    // check if all and only the outermost operands are checked
+    // string in boolean context
+    `
+if ('') {
+}
+    `,
+    "while ('x') {}",
+    "for (; ''; ) {}",
+    "('' && '1') || x;",
+    `
+declare const x: string;
+if (x) {
+}
+    `,
+    '(x: string) => !x;',
+    '<T extends string>(x: T) => (x ? 1 : 0);',
+
+    // number in boolean context
+    `
+if (0) {
+}
+    `,
+    'while (1n) {}',
+    'for (; Infinity; ) {}',
+    '(0 / 0 && 1 + 2) || x;',
+    `
+declare const x: number;
+if (x) {
+}
+    `,
+    '(x: bigint) => !x;',
+    '<T extends number>(x: T) => (x ? 1 : 0);',
+
+    // nullable object in boolean context
+    `
+declare const x: null | object;
+if (x) {
+}
+    `,
+    '(x?: { a: any }) => !x;',
+    '<T extends {} | null | undefined>(x: T) => (x ? 1 : 0);',
+
+    // nullable boolean in boolean context
     {
-      code: noFormat`if (('' && {}) || (0 && void 0)) { }`,
-      errors: [
-        {
-          column: 6,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: `if (((''.length > 0) && {}) || (0 && void 0)) { }`,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `if ((('' !== "") && {}) || (0 && void 0)) { }`,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `if (((Boolean('')) && {}) || (0 && void 0)) { }`,
-            },
-          ],
-        },
-        { column: 12, line: 1, messageId: 'conditionErrorObject' },
-        {
-          column: 20,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: `if (('' && {}) || ((0 !== 0) && void 0)) { }`,
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: `if (('' && {}) || ((!Number.isNaN(0)) && void 0)) { }`,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `if (('' && {}) || ((Boolean(0)) && void 0)) { }`,
-            },
-          ],
-        },
-        { column: 25, line: 1, messageId: 'conditionErrorNullish' },
-      ],
-      options: [
-        { allowNullableObject: false, allowNumber: false, allowString: false },
-      ],
-      output: null,
+      code: `
+        declare const x: boolean | null;
+        if (x) {
+        }
+      `,
+      options: [{ allowNullableBoolean: true }],
     },
     {
-      code: noFormat`
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || (0 && void 0)) { }
-      `,
-      errors: [
-        {
-          column: 6,
-          line: 3,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (((''.length > 0) && foo) || (0 && void 0)) { }
+      code: `
+        (x?: boolean) => !x;
       `,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if ((('' !== "") && foo) || (0 && void 0)) { }
+      options: [{ allowNullableBoolean: true }],
+    },
+    {
+      code: `
+        <T extends boolean | null | undefined>(x: T) => (x ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (((Boolean('')) && foo) || (0 && void 0)) { }
+      options: [{ allowNullableBoolean: true }],
+    },
+
+    // nullable string in boolean context
+    {
+      code: `
+        declare const x: string | null;
+        if (x) {
+        }
       `,
-            },
-          ],
-        },
-        {
-          column: 21,
-          line: 3,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((0 !== 0) && void 0)) { }
+      options: [{ allowNullableString: true }],
+    },
+    {
+      code: `
+        (x?: string) => !x;
       `,
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((!Number.isNaN(0)) && void 0)) { }
+      options: [{ allowNullableString: true }],
+    },
+    {
+      code: `
+        <T extends string | null | undefined>(x: T) => (x ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: true & { __BRAND: 'Foo' };
-if (('' && foo) || ((Boolean(0)) && void 0)) { }
+      options: [{ allowNullableString: true }],
+    },
+
+    // nullable number in boolean context
+    {
+      code: `
+        declare const x: number | null;
+        if (x) {
+        }
       `,
-            },
-          ],
-        },
-        { column: 26, line: 3, messageId: 'conditionErrorNullish' },
-      ],
-      options: [
-        { allowNullableObject: false, allowNumber: false, allowString: false },
-      ],
-      output: null,
+      options: [{ allowNullableNumber: true }],
     },
     {
-      code: noFormat`
-declare const foo: false & { __BRAND: 'Foo' };
-if (('' && {}) || (foo && void 0)) { }
+      code: `
+        (x?: number) => !x;
       `,
-      errors: [
-        {
-          column: 6,
-          line: 3,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if (((''.length > 0) && {}) || (foo && void 0)) { }
+      options: [{ allowNullableNumber: true }],
+    },
+    {
+      code: `
+        <T extends number | null | undefined>(x: T) => (x ? 1 : 0);
       `,
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if ((('' !== "") && {}) || (foo && void 0)) { }
+      options: [{ allowNullableNumber: true }],
+    },
+
+    // any in boolean context
+    {
+      code: `
+        declare const x: any;
+        if (x) {
+        }
       `,
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare const foo: false & { __BRAND: 'Foo' };
-if (((Boolean('')) && {}) || (foo && void 0)) { }
+      options: [{ allowAny: true }],
+    },
+    {
+      code: `
+        x => !x;
       `,
-            },
-          ],
-        },
-        { column: 12, line: 3, messageId: 'conditionErrorObject' },
-        { column: 27, line: 3, messageId: 'conditionErrorNullish' },
-      ],
-      options: [
-        { allowNullableObject: false, allowNumber: false, allowString: false },
-      ],
-      output: null,
+      options: [{ allowAny: true }],
+    },
+    {
+      code: `
+        <T extends any>(x: T) => (x ? 1 : 0);
+      `,
+      options: [{ allowAny: true }],
     },
 
-    // shouldn't check last logical operand when used for control flow
+    // logical operator
     {
-      code: "'asd' && 123 && [] && null;",
-      errors: [
-        {
-          column: 1,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: "('asd'.length > 0) && 123 && [] && null;",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: '(\'asd\' !== "") && 123 && [] && null;',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "(Boolean('asd')) && 123 && [] && null;",
-            },
-          ],
-        },
-        {
-          column: 10,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "'asd' && (123 !== 0) && [] && null;",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: "'asd' && (!Number.isNaN(123)) && [] && null;",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "'asd' && (Boolean(123)) && [] && null;",
-            },
-          ],
-        },
-        {
-          column: 17,
-          line: 1,
-          messageId: 'conditionErrorObject',
-        },
-      ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
+      code: `
+        1 && true && 'x' && {};
+      `,
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
-      code: "'asd' || 123 || [] || null;",
-      errors: [
-        {
-          column: 1,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: "('asd'.length > 0) || 123 || [] || null;",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: '(\'asd\' !== "") || 123 || [] || null;',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "(Boolean('asd')) || 123 || [] || null;",
-            },
-          ],
-        },
-        {
-          column: 10,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "'asd' || (123 !== 0) || [] || null;",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: "'asd' || (!Number.isNaN(123)) || [] || null;",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "'asd' || (Boolean(123)) || [] || null;",
-            },
-          ],
-        },
-        {
-          column: 17,
-          line: 1,
-          messageId: 'conditionErrorObject',
-        },
-      ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
+      code: `
+        let x = 0 || false || '' || null;
+      `,
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
-      code: "let x = (1 && 'a' && null) || 0 || '' || {};",
-      errors: [
-        {
-          column: 10,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "let x = ((1 !== 0) && 'a' && null) || 0 || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "let x = ((!Number.isNaN(1)) && 'a' && null) || 0 || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "let x = ((Boolean(1)) && 'a' && null) || 0 || '' || {};",
-            },
-          ],
-        },
-        {
-          column: 15,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "let x = (1 && ('a'.length > 0) && null) || 0 || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: "let x = (1 && ('a' !== \"\") && null) || 0 || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && (Boolean('a')) && null) || 0 || '' || {};",
-            },
-          ],
-        },
-        {
-          column: 22,
-          line: 1,
-          messageId: 'conditionErrorNullish',
-        },
-        {
-          column: 31,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "let x = (1 && 'a' && null) || (0 !== 0) || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "let x = (1 && 'a' && null) || (!Number.isNaN(0)) || '' || {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && 'a' && null) || (Boolean(0)) || '' || {};",
-            },
-          ],
-        },
-        {
-          column: 36,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "let x = (1 && 'a' && null) || 0 || (''.length > 0) || {};",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: "let x = (1 && 'a' && null) || 0 || ('' !== \"\") || {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "let x = (1 && 'a' && null) || 0 || (Boolean('')) || {};",
-            },
-          ],
-        },
-      ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
+      code: `
+        if (1 && true && 'x') void 0;
+      `,
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
-      code: "return (1 || 'a' || null) && 0 && '' && {};",
-      errors: [
-        {
-          column: 9,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "return ((1 !== 0) || 'a' || null) && 0 && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "return ((!Number.isNaN(1)) || 'a' || null) && 0 && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return ((Boolean(1)) || 'a' || null) && 0 && '' && {};",
-            },
-          ],
-        },
-        {
-          column: 14,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "return (1 || ('a'.length > 0) || null) && 0 && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: "return (1 || ('a' !== \"\") || null) && 0 && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return (1 || (Boolean('a')) || null) && 0 && '' && {};",
-            },
-          ],
-        },
-        {
-          column: 21,
-          line: 1,
-          messageId: 'conditionErrorNullish',
-        },
-        {
-          column: 30,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "return (1 || 'a' || null) && (0 !== 0) && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "return (1 || 'a' || null) && (!Number.isNaN(0)) && '' && {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return (1 || 'a' || null) && (Boolean(0)) && '' && {};",
-            },
-          ],
-        },
-        {
-          column: 35,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "return (1 || 'a' || null) && 0 && (''.length > 0) && {};",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: "return (1 || 'a' || null) && 0 && ('' !== \"\") && {};",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return (1 || 'a' || null) && 0 && (Boolean('')) && {};",
-            },
-          ],
-        },
-      ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
+      code: `
+        if (0 || false || '') void 0;
+      `,
+      options: [{ allowNumber: true, allowString: true }],
     },
     {
-      code: "console.log((1 && []) || ('a' && {}));",
-      errors: [
-        {
-          column: 14,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "console.log(((1 !== 0) && []) || ('a' && {}));",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: "console.log(((!Number.isNaN(1)) && []) || ('a' && {}));",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "console.log(((Boolean(1)) && []) || ('a' && {}));",
-            },
-          ],
-        },
-        {
-          column: 19,
-          line: 1,
-          messageId: 'conditionErrorObject',
+      code: `
+        1 && true && 'x' ? {} : null;
+      `,
+      options: [{ allowNumber: true, allowString: true }],
+    },
+    {
+      code: `
+        0 || false || '' ? null : {};
+      `,
+      options: [{ allowNumber: true, allowString: true }],
+    },
+
+    // nullable enum in boolean context
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (!theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+
+    // nullable mixed enum in boolean context
+    {
+      // falsy number and truthy string
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
+        }
+        (value?: ExampleEnum) => (value ? 1 : 0);
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      // falsy string and truthy number
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      // truthy string and truthy number
+      code: `
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+    {
+      // falsy string and falsy number
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
+
+    {
+      code: `
+declare const x: string[] | null;
+// eslint-disable-next-line
+if (x) {
+}
+      `,
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
         },
+      },
+      options: [
         {
-          column: 27,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: "console.log((1 && []) || (('a'.length > 0) && {}));",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: 'console.log((1 && []) || ((\'a\' !== "") && {}));',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "console.log((1 && []) || ((Boolean('a')) && {}));",
-            },
-          ],
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
         },
       ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
     },
 
-    // should check all logical operands when used in a condition
+    `
+function f(arg: 'a' | null) {
+  if (arg) console.log(arg);
+}
+    `,
+    `
+function f(arg: 'a' | 'b' | null) {
+  if (arg) console.log(arg);
+}
+    `,
     {
-      code: "if ((1 && []) || ('a' && {})) void 0;",
-      errors: [
-        {
-          column: 6,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "if (((1 !== 0) && []) || ('a' && {})) void 0;",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: "if (((!Number.isNaN(1)) && []) || ('a' && {})) void 0;",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "if (((Boolean(1)) && []) || ('a' && {})) void 0;",
-            },
-          ],
-        },
-        {
-          column: 11,
-          line: 1,
-          messageId: 'conditionErrorObject',
-        },
-        {
-          column: 19,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: "if ((1 && []) || (('a'.length > 0) && {})) void 0;",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: 'if ((1 && []) || ((\'a\' !== "") && {})) void 0;',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "if ((1 && []) || ((Boolean('a')) && {})) void 0;",
-            },
-          ],
-        },
+      code: `
+declare const x: 1 | null;
+declare const y: 1;
+if (x) {
+}
+if (y) {
+}
+      `,
+      options: [
         {
-          column: 26,
-          line: 1,
-          messageId: 'conditionErrorObject',
+          allowNumber: true,
         },
       ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
     },
+    `
+function f(arg: 1 | null) {
+  if (arg) console.log(arg);
+}
+    `,
+    `
+function f(arg: 1 | 2 | null) {
+  if (arg) console.log(arg);
+}
+    `,
+    `
+interface Options {
+  readonly enableSomething?: true;
+}
+
+function f(opts: Options): void {
+  if (opts.enableSomething) console.log('Do something');
+}
+    `,
+    `
+declare const x: true | null;
+if (x) {
+}
+    `,
     {
-      code: "let x = null || 0 || 'a' || [] ? {} : undefined;",
-      errors: [
-        {
-          column: 9,
-          line: 1,
-          messageId: 'conditionErrorNullish',
-        },
-        {
-          column: 17,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output:
-                "let x = null || (0 !== 0) || 'a' || [] ? {} : undefined;",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output:
-                "let x = null || (!Number.isNaN(0)) || 'a' || [] ? {} : undefined;",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output:
-                "let x = null || (Boolean(0)) || 'a' || [] ? {} : undefined;",
-            },
-          ],
-        },
-        {
-          column: 22,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output:
-                "let x = null || 0 || ('a'.length > 0) || [] ? {} : undefined;",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output:
-                'let x = null || 0 || (\'a\' !== "") || [] ? {} : undefined;',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output:
-                "let x = null || 0 || (Boolean('a')) || [] ? {} : undefined;",
-            },
-          ],
-        },
+      code: `
+declare const x: 'a' | null;
+declare const y: 'a';
+if (x) {
+}
+if (y) {
+}
+      `,
+      options: [
         {
-          column: 29,
-          line: 1,
-          messageId: 'conditionErrorObject',
+          allowString: true,
         },
       ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
     },
+    `
+declare const foo: boolean & { __BRAND: 'Foo' };
+if (foo) {
+}
+    `,
+    `
+declare const foo: true & { __BRAND: 'Foo' };
+if (foo) {
+}
+    `,
+    `
+declare const foo: false & { __BRAND: 'Foo' };
+if (foo) {
+}
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts a;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    `
+declare function assert(a: boolean, b: unknown): asserts b is string;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    // Intentional TS error - cannot assert a parameter in a binding pattern.
+    `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert(a: boolean, { b }: { b: unknown }): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(nullableString, boo);
+    `,
+    `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(...nullableString, nullableString);
+    `,
+    `
+declare function assert(
+  this: object,
+  a: number,
+  b?: unknown,
+  c?: unknown,
+): asserts c;
+declare const nullableString: string | null;
+declare const foo: number;
+const o: { assert: typeof assert } = {
+  assert,
+};
+o.assert(foo, nullableString);
+    `,
     {
-      code: "return !(null || 0 || 'a' || []);",
-      errors: [
-        {
-          column: 10,
-          line: 1,
-          messageId: 'conditionErrorNullish',
-        },
-        {
-          column: 18,
-          line: 1,
-          messageId: 'conditionErrorNumber',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareZero',
-              output: "return !(null || (0 !== 0) || 'a' || []);",
-            },
-            {
-              messageId: 'conditionFixCompareNaN',
-              output: "return !(null || (!Number.isNaN(0)) || 'a' || []);",
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return !(null || (Boolean(0)) || 'a' || []);",
-            },
-          ],
-        },
-        {
-          column: 23,
-          line: 1,
-          messageId: 'conditionErrorString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareStringLength',
-              output: "return !(null || 0 || ('a'.length > 0) || []);",
-            },
-            {
-              messageId: 'conditionFixCompareEmptyString',
-              output: 'return !(null || 0 || (\'a\' !== "") || []);',
-            },
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: "return !(null || 0 || (Boolean('a')) || []);",
-            },
-          ],
-        },
-        {
-          column: 30,
-          line: 1,
-          messageId: 'conditionErrorObject',
-        },
-      ],
-      options: [{ allowNumber: false, allowString: false }],
-      output: null,
+      code: `
+declare function assert(x: unknown): x is string;
+declare const nullableString: string | null;
+assert(nullableString);
+      `,
     },
+    {
+      code: `
+class ThisAsserter {
+  assertThis(this: unknown, arg2: unknown): asserts this {}
+}
 
-    // nullish in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        null || {};
-        undefined && [];
-        declare const x: null; if (x) {}
-        (x: undefined) => !x;
-        <T extends null | undefined>(x: T) => x ? 1 : 0;
-        <T extends null>(x: T) => x ? 1 : 0;
-        <T extends undefined>(x: T) => x ? 1 : 0;
+declare const lol: string | number | unknown | null;
+
+const thisAsserter: ThisAsserter = new ThisAsserter();
+thisAsserter.assertThis(lol);
       `,
-      errors: [
-        { column: 1, line: 2, messageId: 'conditionErrorNullish' },
-        { column: 9, line: 3, messageId: 'conditionErrorNullish' },
-        { column: 36, line: 4, messageId: 'conditionErrorNullish' },
-        { column: 28, line: 5, messageId: 'conditionErrorNullish' },
-        { column: 47, line: 6, messageId: 'conditionErrorNullish' },
-        { column: 35, line: 7, messageId: 'conditionErrorNullish' },
-        { column: 40, line: 8, messageId: 'conditionErrorNullish' },
-      ],
-    }),
+    },
+    {
+      code: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(...args: any[]): void;
 
-    // object in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        [] || 1;
-        ({}) && "a";
-        declare const x: symbol; if (x) {}
-        (x: () => void) => !x;
-        <T extends object>(x: T) => x ? 1 : 0;
-        <T extends Object | Function>(x: T) => x ? 1 : 0;
-        <T extends { a: number }>(x: T) => x ? 1 : 0;
-        <T extends () => void>(x: T) => x ? 1 : 0;
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString);
       `,
-      errors: [
-        { column: 1, line: 2, messageId: 'conditionErrorObject' },
-        { column: 10, line: 3, messageId: 'conditionErrorObject' },
-        { column: 38, line: 4, messageId: 'conditionErrorObject' },
-        { column: 29, line: 5, messageId: 'conditionErrorObject' },
-        { column: 37, line: 6, messageId: 'conditionErrorObject' },
-        { column: 48, line: 7, messageId: 'conditionErrorObject' },
-        { column: 44, line: 8, messageId: 'conditionErrorObject' },
-        { column: 41, line: 9, messageId: 'conditionErrorObject' },
-      ],
-    }),
+    },
+    // Intentional TS error - A rest parameter must be last in a parameter list.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(...a: boolean[], b: unknown): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    // Intentional TS error - A type predicate cannot reference a rest parameter.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(a: boolean, ...b: unknown[]): asserts b;
+declare const nullableString: string | null;
+declare const boo: boolean;
+assert(boo, nullableString);
+    `,
+    // Intentional TS error - An assertion function must have a parameter to assert.
+    // This is just to test that we don't crash or falsely report.
+    `
+declare function assert(): asserts x;
+declare const nullableString: string | null;
+assert(nullableString);
+    `,
+    `
+function assert(one: unknown): asserts one;
+function assert(one: unknown, two: unknown): asserts two;
+function assert(...args: unknown[]) {
+  throw new Error('not implemented');
+}
+declare const nullableString: string | null;
+assert(nullableString);
+assert('one', nullableString);
+    `,
+    // Intentional use of `any` to test a function call with no call signatures.
+    `
+declare const assert: any;
+declare const nullableString: string | null;
+assert(nullableString);
+    `,
+    // Coverage for absent "test expression".
+    // Ensure that no crash or false positive occurs
+    `
+      for (let x = 0; ; x++) {
+        break;
+      }
+    `,
+  ],
 
-    // string in boolean context
+  invalid: [
+    // non-boolean in RHS of test expression
     ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`
-        while ("") {}
-        for (; "foo";) {}
-        declare const x: string; if (x) {}
-        (x: string) => (!x);
-        <T extends string>(x: T) => x ? 1 : 0;
+        if (true && (1 + 1)) {}
+        while (false || "a" + "b") {}
+        (x: object) => true || false || x ? true : false;
       `,
       errors: [
         {
-          column: 8,
+          column: 14,
           line: 2,
-          messageId: 'conditionErrorString',
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `while ("".length > 0) {}`,
+              messageId: 'conditionFixCompareZero',
+              output: 'if (true && ((1 + 1) !== 0)) {}',
             },
             {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `while ("" !== "") {}`,
+              messageId: 'conditionFixCompareNaN',
+              output: 'if (true && (!Number.isNaN((1 + 1)))) {}',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `while (Boolean("")) {}`,
+              output: 'if (true && (Boolean((1 + 1)))) {}',
             },
           ],
         },
         {
-          column: 16,
+          column: 25,
           line: 3,
           messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `        for (; "foo".length > 0;) {}`,
+              output: '        while (false || (("a" + "b").length > 0)) {}',
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `        for (; "foo" !== "";) {}`,
+              output: '        while (false || (("a" + "b") !== "")) {}',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        for (; Boolean("foo");) {}`,
+              output: '        while (false || (Boolean(("a" + "b")))) {}',
             },
           ],
         },
+        { column: 41, line: 4, messageId: 'conditionErrorObject' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+    }),
+
+    // check if all and only the outermost operands are checked
+    {
+      code: noFormat`if (('' && {}) || (0 && void 0)) { }`,
+      errors: [
         {
-          column: 38,
-          line: 4,
+          column: 6,
+          line: 1,
           messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `        declare const x: string; if (x.length > 0) {}`,
+              output: `if (((''.length > 0) && {}) || (0 && void 0)) { }`,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `        declare const x: string; if (x !== "") {}`,
+              output: `if ((('' !== "") && {}) || (0 && void 0)) { }`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        declare const x: string; if (Boolean(x)) {}`,
+              output: `if (((Boolean('')) && {}) || (0 && void 0)) { }`,
             },
           ],
         },
+        { column: 12, line: 1, messageId: 'conditionErrorObject' },
         {
-          column: 26,
-          line: 5,
-          messageId: 'conditionErrorString',
+          column: 20,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareStringLength',
-              output: `        (x: string) => (x.length === 0);`,
+              messageId: 'conditionFixCompareZero',
+              output: `if (('' && {}) || ((0 !== 0) && void 0)) { }`,
             },
             {
-              messageId: 'conditionFixCompareEmptyString',
-              output: `        (x: string) => (x === "");`,
+              messageId: 'conditionFixCompareNaN',
+              output: `if (('' && {}) || ((!Number.isNaN(0)) && void 0)) { }`,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        (x: string) => (!Boolean(x));`,
+              output: `if (('' && {}) || ((Boolean(0)) && void 0)) { }`,
             },
           ],
         },
+        { column: 25, line: 1, messageId: 'conditionErrorNullish' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+      output: null,
+    },
+    {
+      code: noFormat`
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || (0 && void 0)) { }
+      `,
+      errors: [
         {
-          column: 37,
-          line: 6,
+          column: 6,
+          line: 3,
           messageId: 'conditionErrorString',
           suggestions: [
             {
               messageId: 'conditionFixCompareStringLength',
-              output: `        <T extends string>(x: T) => (x.length > 0) ? 1 : 0;`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (((''.length > 0) && foo) || (0 && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCompareEmptyString',
-              output: `        <T extends string>(x: T) => (x !== "") ? 1 : 0;`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if ((('' !== "") && foo) || (0 && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        <T extends string>(x: T) => (Boolean(x)) ? 1 : 0;`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (((Boolean('')) && foo) || (0 && void 0)) { }
+      `,
             },
           ],
         },
-      ],
-      options: [{ allowString: false }],
-    }),
-
-    // number in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        while (0n) {}
-        for (; 123;) {}
-        declare const x: number; if (x) {}
-        (x: bigint) => !x;
-        <T extends number>(x: T) => (x) ? 1 : 0;
-        ![]["length"]; // doesn't count as array.length when computed
-        declare const a: any[] & { notLength: number }; if (a.notLength) {}
-      `,
-      errors: [
         {
-          column: 8,
-          line: 2,
+          column: 21,
+          line: 3,
           messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              // TODO: fix compare zero suggestion for bigint
-              output: `while (0n !== 0) {}`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((0 !== 0) && void 0)) { }
+      `,
             },
             {
-              // TODO: remove check NaN suggestion for bigint
               messageId: 'conditionFixCompareNaN',
-              output: `while (!Number.isNaN(0n)) {}`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((!Number.isNaN(0)) && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `while (Boolean(0n)) {}`,
+              output: `
+declare const foo: true & { __BRAND: 'Foo' };
+if (('' && foo) || ((Boolean(0)) && void 0)) { }
+      `,
             },
           ],
         },
+        { column: 26, line: 3, messageId: 'conditionErrorNullish' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+      output: null,
+    },
+    {
+      code: noFormat`
+declare const foo: false & { __BRAND: 'Foo' };
+if (('' && {}) || (foo && void 0)) { }
+      `,
+      errors: [
         {
-          column: 16,
+          column: 6,
           line: 3,
-          messageId: 'conditionErrorNumber',
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        for (; 123 !== 0;) {}`,
+              messageId: 'conditionFixCompareStringLength',
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if (((''.length > 0) && {}) || (foo && void 0)) { }
+      `,
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        for (; !Number.isNaN(123);) {}`,
+              messageId: 'conditionFixCompareEmptyString',
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if ((('' !== "") && {}) || (foo && void 0)) { }
+      `,
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        for (; Boolean(123);) {}`,
+              output: `
+declare const foo: false & { __BRAND: 'Foo' };
+if (((Boolean('')) && {}) || (foo && void 0)) { }
+      `,
             },
           ],
         },
+        { column: 12, line: 3, messageId: 'conditionErrorObject' },
+        { column: 27, line: 3, messageId: 'conditionErrorNullish' },
+      ],
+      options: [
+        { allowNullableObject: false, allowNumber: false, allowString: false },
+      ],
+      output: null,
+    },
+
+    // shouldn't check last logical operand when used for control flow
+    {
+      code: "'asd' && 123 && [] && null;",
+      errors: [
         {
-          column: 38,
-          line: 4,
-          messageId: 'conditionErrorNumber',
+          column: 1,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        declare const x: number; if (x !== 0) {}`,
+              messageId: 'conditionFixCompareStringLength',
+              output: "('asd'.length > 0) && 123 && [] && null;",
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        declare const x: number; if (!Number.isNaN(x)) {}`,
+              messageId: 'conditionFixCompareEmptyString',
+              output: '(\'asd\' !== "") && 123 && [] && null;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        declare const x: number; if (Boolean(x)) {}`,
+              output: "(Boolean('asd')) && 123 && [] && null;",
             },
           ],
         },
         {
-          column: 25,
-          line: 5,
+          column: 10,
+          line: 1,
           messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              // TODO: fix compare zero suggestion for bigint
-              output: `        (x: bigint) => x === 0;`,
+              output: "'asd' && (123 !== 0) && [] && null;",
             },
             {
-              // TODO: remove check NaN suggestion for bigint
               messageId: 'conditionFixCompareNaN',
-              output: `        (x: bigint) => Number.isNaN(x);`,
+              output: "'asd' && (!Number.isNaN(123)) && [] && null;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        (x: bigint) => !Boolean(x);`,
+              output: "'asd' && (Boolean(123)) && [] && null;",
             },
           ],
         },
         {
-          column: 38,
-          line: 6,
-          messageId: 'conditionErrorNumber',
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "'asd' || 123 || [] || null;",
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareZero',
-              output: `        <T extends number>(x: T) => (x !== 0) ? 1 : 0;`,
+              messageId: 'conditionFixCompareStringLength',
+              output: "('asd'.length > 0) || 123 || [] || null;",
             },
             {
-              messageId: 'conditionFixCompareNaN',
-              output: `        <T extends number>(x: T) => (!Number.isNaN(x)) ? 1 : 0;`,
+              messageId: 'conditionFixCompareEmptyString',
+              output: '(\'asd\' !== "") || 123 || [] || null;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        <T extends number>(x: T) => (Boolean(x)) ? 1 : 0;`,
+              output: "(Boolean('asd')) || 123 || [] || null;",
             },
           ],
         },
         {
           column: 10,
-          line: 7,
+          line: 1,
           messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: `        []["length"] === 0; // doesn't count as array.length when computed`,
+              output: "'asd' || (123 !== 0) || [] || null;",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: `        Number.isNaN([]["length"]); // doesn't count as array.length when computed`,
+              output: "'asd' || (!Number.isNaN(123)) || [] || null;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        !Boolean([]["length"]); // doesn't count as array.length when computed`,
+              output: "'asd' || (Boolean(123)) || [] || null;",
             },
           ],
         },
         {
-          column: 61,
-          line: 8,
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "let x = (1 && 'a' && null) || 0 || '' || {};",
+      errors: [
+        {
+          column: 10,
+          line: 1,
           messageId: 'conditionErrorNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareZero',
-              output: `        declare const a: any[] & { notLength: number }; if (a.notLength !== 0) {}`,
+              output: "let x = ((1 !== 0) && 'a' && null) || 0 || '' || {};",
             },
             {
               messageId: 'conditionFixCompareNaN',
-              output: `        declare const a: any[] & { notLength: number }; if (!Number.isNaN(a.notLength)) {}`,
+              output:
+                "let x = ((!Number.isNaN(1)) && 'a' && null) || 0 || '' || {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `        declare const a: any[] & { notLength: number }; if (Boolean(a.notLength)) {}`,
+              output: "let x = ((Boolean(1)) && 'a' && null) || 0 || '' || {};",
             },
           ],
         },
-      ],
-      options: [{ allowNumber: false }],
-    }),
-
-    // number (array.length) in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        if (![].length) {}
-        (a: number[]) => a.length && "..."
-        <T extends unknown[]>(...a: T) => a.length || "empty";
-      `,
-      errors: [
-        { column: 6, line: 2, messageId: 'conditionErrorNumber' },
-        { column: 26, line: 3, messageId: 'conditionErrorNumber' },
-        { column: 43, line: 4, messageId: 'conditionErrorNumber' },
-      ],
-      options: [{ allowNumber: false }],
-      output: `
-        if ([].length === 0) {}
-        (a: number[]) => (a.length > 0) && "..."
-        <T extends unknown[]>(...a: T) => (a.length > 0) || "empty";
-      `,
-    }),
-
-    // mixed `string | number` value in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        declare const x: string | number; if (x) {}
-        (x: bigint | string) => !x;
-        <T extends number | bigint | string>(x: T) => x ? 1 : 0;
-      `,
-      errors: [
-        { column: 39, line: 2, messageId: 'conditionErrorOther' },
-        { column: 34, line: 3, messageId: 'conditionErrorOther' },
-        { column: 55, line: 4, messageId: 'conditionErrorOther' },
-      ],
-      options: [{ allowNumber: true, allowString: true }],
-    }),
-
-    // nullable boolean in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        declare const x: boolean | null; if (x) {}
-        (x?: boolean) => !x;
-        <T extends boolean | null | undefined>(x: T) => x ? 1 : 0;
-      `,
-      errors: [
         {
-          column: 38,
-          line: 2,
-          messageId: 'conditionErrorNullableBoolean',
+          column: 15,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixDefaultFalse',
-              output: `declare const x: boolean | null; if (x ?? false) {}`,
+              messageId: 'conditionFixCompareStringLength',
+              output:
+                "let x = (1 && ('a'.length > 0) && null) || 0 || '' || {};",
             },
             {
-              messageId: 'conditionFixCompareTrue',
-              output: `declare const x: boolean | null; if (x === true) {}`,
+              messageId: 'conditionFixCompareEmptyString',
+              output: "let x = (1 && ('a' !== \"\") && null) || 0 || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = (1 && (Boolean('a')) && null) || 0 || '' || {};",
             },
           ],
         },
         {
-          column: 27,
-          line: 3,
-          messageId: 'conditionErrorNullableBoolean',
+          column: 22,
+          line: 1,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 31,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixDefaultFalse',
-              output: `        (x?: boolean) => !(x ?? false);`,
+              messageId: 'conditionFixCompareZero',
+              output: "let x = (1 && 'a' && null) || (0 !== 0) || '' || {};",
             },
             {
-              messageId: 'conditionFixCompareFalse',
-              output: `        (x?: boolean) => x === false;`,
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "let x = (1 && 'a' && null) || (!Number.isNaN(0)) || '' || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = (1 && 'a' && null) || (Boolean(0)) || '' || {};",
             },
           ],
         },
         {
-          column: 57,
-          line: 4,
-          messageId: 'conditionErrorNullableBoolean',
+          column: 36,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixDefaultFalse',
-              output: `        <T extends boolean | null | undefined>(x: T) => (x ?? false) ? 1 : 0;`,
+              messageId: 'conditionFixCompareStringLength',
+              output:
+                "let x = (1 && 'a' && null) || 0 || (''.length > 0) || {};",
             },
             {
-              messageId: 'conditionFixCompareTrue',
-              output: `        <T extends boolean | null | undefined>(x: T) => (x === true) ? 1 : 0;`,
+              messageId: 'conditionFixCompareEmptyString',
+              output: "let x = (1 && 'a' && null) || 0 || ('' !== \"\") || {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "let x = (1 && 'a' && null) || 0 || (Boolean('')) || {};",
             },
           ],
         },
       ],
-      options: [{ allowNullableBoolean: false }],
-    }),
-
-    // nullable object in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        declare const x: object | null; if (x) {}
-        (x?: { a: number }) => !x;
-        <T extends {} | null | undefined>(x: T) => x ? 1 : 0;
-      `,
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "return (1 || 'a' || null) && 0 && '' && {};",
       errors: [
         {
-          column: 37,
-          line: 2,
-          messageId: 'conditionErrorNullableObject',
+          column: 9,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: object | null; if (x != null) {}',
+              messageId: 'conditionFixCompareZero',
+              output: "return ((1 !== 0) || 'a' || null) && 0 && '' && {};",
             },
-          ],
-        },
-        {
-          column: 33,
-          line: 3,
-          messageId: 'conditionErrorNullableObject',
-          suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: `        (x?: { a: number }) => x == null;`,
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "return ((!Number.isNaN(1)) || 'a' || null) && 0 && '' && {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return ((Boolean(1)) || 'a' || null) && 0 && '' && {};",
             },
           ],
         },
         {
-          column: 52,
-          line: 4,
-          messageId: 'conditionErrorNullableObject',
+          column: 14,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: `        <T extends {} | null | undefined>(x: T) => (x != null) ? 1 : 0;`,
+              messageId: 'conditionFixCompareStringLength',
+              output:
+                "return (1 || ('a'.length > 0) || null) && 0 && '' && {};",
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: "return (1 || ('a' !== \"\") || null) && 0 && '' && {};",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return (1 || (Boolean('a')) || null) && 0 && '' && {};",
             },
           ],
         },
-      ],
-      options: [{ allowNullableObject: false }],
-    }),
-
-    // nullable string in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        declare const x: string | null; if (x) {}
-        (x?: string) => !x;
-        <T extends string | null | undefined>(x: T) => x ? 1 : 0;
-        function foo(x: '' | 'bar' | null) { if (!x) {} }
-      `,
-      errors: [
         {
-          column: 37,
-          line: 2,
-          messageId: 'conditionErrorNullableString',
+          column: 21,
+          line: 1,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 30,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: string | null; if (x != null) {}',
+              messageId: 'conditionFixCompareZero',
+              output: "return (1 || 'a' || null) && (0 !== 0) && '' && {};",
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: 'declare const x: string | null; if (x ?? "") {}',
+              messageId: 'conditionFixCompareNaN',
+              output:
+                "return (1 || 'a' || null) && (!Number.isNaN(0)) && '' && {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: 'declare const x: string | null; if (Boolean(x)) {}',
+              output: "return (1 || 'a' || null) && (Boolean(0)) && '' && {};",
             },
           ],
         },
         {
-          column: 26,
-          line: 3,
-          messageId: 'conditionErrorNullableString',
+          column: 35,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: '        (x?: string) => x == null;',
+              messageId: 'conditionFixCompareStringLength',
+              output:
+                "return (1 || 'a' || null) && 0 && (''.length > 0) && {};",
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: '        (x?: string) => !(x ?? "");',
+              messageId: 'conditionFixCompareEmptyString',
+              output: "return (1 || 'a' || null) && 0 && ('' !== \"\") && {};",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        (x?: string) => !Boolean(x);',
+              output: "return (1 || 'a' || null) && 0 && (Boolean('')) && {};",
             },
           ],
         },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "console.log((1 && []) || ('a' && {}));",
+      errors: [
         {
-          column: 56,
-          line: 4,
-          messageId: 'conditionErrorNullableString',
+          column: 14,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (x != null) ? 1 : 0;',
+              messageId: 'conditionFixCompareZero',
+              output: "console.log(((1 !== 0) && []) || ('a' && {}));",
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (x ?? "") ? 1 : 0;',
+              messageId: 'conditionFixCompareNaN',
+              output: "console.log(((!Number.isNaN(1)) && []) || ('a' && {}));",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                '        <T extends string | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
+              output: "console.log(((Boolean(1)) && []) || ('a' && {}));",
             },
           ],
         },
         {
-          column: 51,
-          line: 5,
-          messageId: 'conditionErrorNullableString',
+          column: 19,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+        {
+          column: 27,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (x == null) {} }",
+              messageId: 'conditionFixCompareStringLength',
+              output: "console.log((1 && []) || (('a'.length > 0) && {}));",
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (!(x ?? \"\")) {} }",
+              messageId: 'conditionFixCompareEmptyString',
+              output: 'console.log((1 && []) || ((\'a\' !== "") && {}));',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output:
-                "        function foo(x: '' | 'bar' | null) { if (!Boolean(x)) {} }",
+              output: "console.log((1 && []) || ((Boolean('a')) && {}));",
             },
           ],
         },
       ],
-    }),
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
 
-    // nullable number in boolean context
-    ...batchedSingleLineTests<MessageId, Options>({
-      code: noFormat`
-        declare const x: number | null; if (x) {}
-        (x?: number) => !x;
-        <T extends number | null | undefined>(x: T) => x ? 1 : 0;
-        function foo(x: 0 | 1 | null) { if (!x) {} }
-      `,
+    // should check all logical operands when used in a condition
+    {
+      code: "if ((1 && []) || ('a' && {})) void 0;",
       errors: [
         {
-          column: 37,
-          line: 2,
-          messageId: 'conditionErrorNullableNumber',
+          column: 6,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: 'declare const x: number | null; if (x != null) {}',
+              messageId: 'conditionFixCompareZero',
+              output: "if (((1 !== 0) && []) || ('a' && {})) void 0;",
             },
             {
-              messageId: 'conditionFixDefaultZero',
-              output: 'declare const x: number | null; if (x ?? 0) {}',
+              messageId: 'conditionFixCompareNaN',
+              output: "if (((!Number.isNaN(1)) && []) || ('a' && {})) void 0;",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: 'declare const x: number | null; if (Boolean(x)) {}',
+              output: "if (((Boolean(1)) && []) || ('a' && {})) void 0;",
             },
           ],
         },
         {
-          column: 26,
-          line: 3,
-          messageId: 'conditionErrorNullableNumber',
+          column: 11,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+        {
+          column: 19,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
-              output: '        (x?: number) => x == null;',
+              messageId: 'conditionFixCompareStringLength',
+              output: "if ((1 && []) || (('a'.length > 0) && {})) void 0;",
             },
             {
-              messageId: 'conditionFixDefaultZero',
-              output: '        (x?: number) => !(x ?? 0);',
+              messageId: 'conditionFixCompareEmptyString',
+              output: 'if ((1 && []) || ((\'a\' !== "") && {})) void 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        (x?: number) => !Boolean(x);',
+              output: "if ((1 && []) || ((Boolean('a')) && {})) void 0;",
             },
           ],
         },
         {
-          column: 56,
-          line: 4,
-          messageId: 'conditionErrorNullableNumber',
+          column: 26,
+          line: 1,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
+    },
+    {
+      code: "let x = null || 0 || 'a' || [] ? {} : undefined;",
+      errors: [
+        {
+          column: 9,
+          line: 1,
+          messageId: 'conditionErrorNullish',
+        },
+        {
+          column: 17,
+          line: 1,
+          messageId: 'conditionErrorNumber',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
+              messageId: 'conditionFixCompareZero',
               output:
-                '        <T extends number | null | undefined>(x: T) => (x != null) ? 1 : 0;',
+                "let x = null || (0 !== 0) || 'a' || [] ? {} : undefined;",
             },
             {
-              messageId: 'conditionFixDefaultZero',
+              messageId: 'conditionFixCompareNaN',
               output:
-                '        <T extends number | null | undefined>(x: T) => (x ?? 0) ? 1 : 0;',
+                "let x = null || (!Number.isNaN(0)) || 'a' || [] ? {} : undefined;",
             },
             {
               messageId: 'conditionFixCastBoolean',
               output:
-                '        <T extends number | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
+                "let x = null || (Boolean(0)) || 'a' || [] ? {} : undefined;",
             },
           ],
         },
         {
-          column: 46,
-          line: 5,
-          messageId: 'conditionErrorNullableNumber',
+          column: 22,
+          line: 1,
+          messageId: 'conditionErrorString',
           suggestions: [
             {
-              messageId: 'conditionFixCompareNullish',
+              messageId: 'conditionFixCompareStringLength',
               output:
-                '        function foo(x: 0 | 1 | null) { if (x == null) {} }',
+                "let x = null || 0 || ('a'.length > 0) || [] ? {} : undefined;",
             },
             {
-              messageId: 'conditionFixDefaultZero',
+              messageId: 'conditionFixCompareEmptyString',
               output:
-                '        function foo(x: 0 | 1 | null) { if (!(x ?? 0)) {} }',
+                'let x = null || 0 || (\'a\' !== "") || [] ? {} : undefined;',
             },
             {
               messageId: 'conditionFixCastBoolean',
               output:
-                '        function foo(x: 0 | 1 | null) { if (!Boolean(x)) {} }',
+                "let x = null || 0 || (Boolean('a')) || [] ? {} : undefined;",
             },
           ],
         },
-      ],
-    }),
-
-    // nullable enum in boolean context
-    {
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum) {
-        }
-      `,
-      errors: [
-        {
-          column: 13,
-          endColumn: 20,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
-        },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum != null) {
-        }
-      `,
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
-      errors: [
         {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
+          column: 29,
+          line: 1,
+          messageId: 'conditionErrorObject',
         },
       ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
     {
-      code: `
-        enum ExampleEnum {
-          This,
-          That,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
+      code: "return !(null || 0 || 'a' || []);",
       errors: [
         {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
+          column: 10,
+          line: 1,
+          messageId: 'conditionErrorNullish',
         },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This,
-          That,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 'a',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
-      errors: [
         {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
+          column: 18,
+          line: 1,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: "return !(null || (0 !== 0) || 'a' || []);",
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: "return !(null || (!Number.isNaN(0)) || 'a' || []);",
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return !(null || (Boolean(0)) || 'a' || []);",
+            },
+          ],
         },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 'a',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
-      errors: [
         {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
-        },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
-      `,
-      errors: [
+          column: 23,
+          line: 1,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: "return !(null || 0 || ('a'.length > 0) || []);",
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: 'return !(null || 0 || (\'a\' !== "") || []);',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: "return !(null || 0 || (Boolean('a')) || []);",
+            },
+          ],
+        },
         {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
+          column: 30,
+          line: 1,
+          messageId: 'conditionErrorObject',
         },
       ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
+      options: [{ allowNumber: false, allowString: false }],
+      output: null,
     },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (!theEnum) {
-        }
+
+    // nullish in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        null || {};
+        undefined && [];
+        declare const x: null; if (x) {}
+        (x: undefined) => !x;
+        <T extends null | undefined>(x: T) => x ? 1 : 0;
+        <T extends null>(x: T) => x ? 1 : 0;
+        <T extends undefined>(x: T) => x ? 1 : 0;
       `,
       errors: [
-        {
-          column: 14,
-          endColumn: 21,
-          endLine: 7,
-          line: 7,
-          messageId: 'conditionErrorNullableEnum',
-        },
+        { column: 1, line: 2, messageId: 'conditionErrorNullish' },
+        { column: 9, line: 3, messageId: 'conditionErrorNullish' },
+        { column: 36, line: 4, messageId: 'conditionErrorNullish' },
+        { column: 28, line: 5, messageId: 'conditionErrorNullish' },
+        { column: 47, line: 6, messageId: 'conditionErrorNullish' },
+        { column: 35, line: 7, messageId: 'conditionErrorNullish' },
+        { column: 40, line: 8, messageId: 'conditionErrorNullish' },
       ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
-        if (theEnum == null) {
-        }
-      `,
-    },
+    }),
 
-    // nullable mixed enum in boolean context
-    {
-      // falsy number and truthy string
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => (value ? 1 : 0);
+    // object in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        [] || 1;
+        ({}) && "a";
+        declare const x: symbol; if (x) {}
+        (x: () => void) => !x;
+        <T extends object>(x: T) => x ? 1 : 0;
+        <T extends Object | Function>(x: T) => x ? 1 : 0;
+        <T extends { a: number }>(x: T) => x ? 1 : 0;
+        <T extends () => void>(x: T) => x ? 1 : 0;
       `,
       errors: [
-        {
-          column: 35,
-          endColumn: 40,
-          endLine: 6,
-          line: 6,
-          messageId: 'conditionErrorNullableEnum',
-        },
+        { column: 1, line: 2, messageId: 'conditionErrorObject' },
+        { column: 10, line: 3, messageId: 'conditionErrorObject' },
+        { column: 38, line: 4, messageId: 'conditionErrorObject' },
+        { column: 29, line: 5, messageId: 'conditionErrorObject' },
+        { column: 37, line: 6, messageId: 'conditionErrorObject' },
+        { column: 48, line: 7, messageId: 'conditionErrorObject' },
+        { column: 44, line: 8, messageId: 'conditionErrorObject' },
+        { column: 41, line: 9, messageId: 'conditionErrorObject' },
       ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => ((value != null) ? 1 : 0);
-      `,
-    },
-    {
-      // falsy string and truthy number
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
+    }),
+
+    // string in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        while ("") {}
+        for (; "foo";) {}
+        declare const x: string; if (x) {}
+        (x: string) => (!x);
+        <T extends string>(x: T) => x ? 1 : 0;
       `,
       errors: [
         {
-          column: 36,
-          endColumn: 41,
-          endLine: 6,
-          line: 6,
-          messageId: 'conditionErrorNullableEnum',
+          column: 8,
+          line: 2,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `while ("".length > 0) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `while ("" !== "") {}`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `while (Boolean("")) {}`,
+            },
+          ],
         },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
-      `,
-    },
-    {
-      // truthy string and truthy number
-      code: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      errors: [
         {
-          column: 36,
-          endColumn: 41,
-          endLine: 6,
-          line: 6,
-          messageId: 'conditionErrorNullableEnum',
+          column: 16,
+          line: 3,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `        for (; "foo".length > 0;) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        for (; "foo" !== "";) {}`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        for (; Boolean("foo");) {}`,
+            },
+          ],
+        },
+        {
+          column: 38,
+          line: 4,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `        declare const x: string; if (x.length > 0) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        declare const x: string; if (x !== "") {}`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        declare const x: string; if (Boolean(x)) {}`,
+            },
+          ],
+        },
+        {
+          column: 26,
+          line: 5,
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `        (x: string) => (x.length === 0);`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        (x: string) => (x === "");`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        (x: string) => (!Boolean(x));`,
+            },
+          ],
         },
-      ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
-        }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
-      `,
-    },
-    {
-      // falsy string and falsy number
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
-      `,
-      errors: [
         {
-          column: 36,
-          endColumn: 41,
-          endLine: 6,
+          column: 37,
           line: 6,
-          messageId: 'conditionErrorNullableEnum',
+          messageId: 'conditionErrorString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareStringLength',
+              output: `        <T extends string>(x: T) => (x.length > 0) ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCompareEmptyString',
+              output: `        <T extends string>(x: T) => (x !== "") ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        <T extends string>(x: T) => (Boolean(x)) ? 1 : 0;`,
+            },
+          ],
         },
       ],
-      options: [{ allowNullableEnum: false }],
-      output: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
-      `,
-    },
+      options: [{ allowString: false }],
+    }),
 
-    // any in boolean context
+    // number in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`
-        if (x) {}
-        x => !x;
-        <T extends any>(x: T) => x ? 1 : 0;
-        <T>(x: T) => x ? 1 : 0;
+        while (0n) {}
+        for (; 123;) {}
+        declare const x: number; if (x) {}
+        (x: bigint) => !x;
+        <T extends number>(x: T) => (x) ? 1 : 0;
+        ![]["length"]; // doesn't count as array.length when computed
+        declare const a: any[] & { notLength: number }; if (a.notLength) {}
       `,
       errors: [
         {
-          column: 5,
+          column: 8,
           line: 2,
-          messageId: 'conditionErrorAny',
+          messageId: 'conditionErrorNumber',
           suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              // TODO: fix compare zero suggestion for bigint
+              output: `while (0n !== 0) {}`,
+            },
+            {
+              // TODO: remove check NaN suggestion for bigint
+              messageId: 'conditionFixCompareNaN',
+              output: `while (!Number.isNaN(0n)) {}`,
+            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: 'if (Boolean(x)) {}',
+              output: `while (Boolean(0n)) {}`,
             },
           ],
         },
         {
-          column: 15,
+          column: 16,
           line: 3,
-          messageId: 'conditionErrorAny',
+          messageId: 'conditionErrorNumber',
           suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        for (; 123 !== 0;) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        for (; !Number.isNaN(123);) {}`,
+            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        x => !(Boolean(x));',
+              output: `        for (; Boolean(123);) {}`,
             },
           ],
         },
         {
-          column: 34,
+          column: 38,
           line: 4,
-          messageId: 'conditionErrorAny',
+          messageId: 'conditionErrorNumber',
           suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        declare const x: number; if (x !== 0) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        declare const x: number; if (!Number.isNaN(x)) {}`,
+            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        <T extends any>(x: T) => (Boolean(x)) ? 1 : 0;',
+              output: `        declare const x: number; if (Boolean(x)) {}`,
             },
           ],
         },
         {
-          column: 22,
+          column: 25,
           line: 5,
-          messageId: 'conditionErrorAny',
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              // TODO: fix compare zero suggestion for bigint
+              output: `        (x: bigint) => x === 0;`,
+            },
+            {
+              // TODO: remove check NaN suggestion for bigint
+              messageId: 'conditionFixCompareNaN',
+              output: `        (x: bigint) => Number.isNaN(x);`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        (x: bigint) => !Boolean(x);`,
+            },
+          ],
+        },
+        {
+          column: 38,
+          line: 6,
+          messageId: 'conditionErrorNumber',
           suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        <T extends number>(x: T) => (x !== 0) ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        <T extends number>(x: T) => (!Number.isNaN(x)) ? 1 : 0;`,
+            },
             {
               messageId: 'conditionFixCastBoolean',
-              output: '        <T>(x: T) => (Boolean(x)) ? 1 : 0;',
+              output: `        <T extends number>(x: T) => (Boolean(x)) ? 1 : 0;`,
+            },
+          ],
+        },
+        {
+          column: 10,
+          line: 7,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        []["length"] === 0; // doesn't count as array.length when computed`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        Number.isNaN([]["length"]); // doesn't count as array.length when computed`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        !Boolean([]["length"]); // doesn't count as array.length when computed`,
+            },
+          ],
+        },
+        {
+          column: 61,
+          line: 8,
+          messageId: 'conditionErrorNumber',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareZero',
+              output: `        declare const a: any[] & { notLength: number }; if (a.notLength !== 0) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareNaN',
+              output: `        declare const a: any[] & { notLength: number }; if (!Number.isNaN(a.notLength)) {}`,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `        declare const a: any[] & { notLength: number }; if (Boolean(a.notLength)) {}`,
             },
           ],
         },
       ],
+      options: [{ allowNumber: false }],
     }),
 
-    // noStrictNullCheck
-    {
-      code: `
-declare const x: string[] | null;
-if (x) {
-}
+    // number (array.length) in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        if (![].length) {}
+        (a: number[]) => a.length && "..."
+        <T extends unknown[]>(...a: T) => a.length || "empty";
+      `,
+      errors: [
+        { column: 6, line: 2, messageId: 'conditionErrorNumber' },
+        { column: 26, line: 3, messageId: 'conditionErrorNumber' },
+        { column: 43, line: 4, messageId: 'conditionErrorNumber' },
+      ],
+      options: [{ allowNumber: false }],
+      output: `
+        if ([].length === 0) {}
+        (a: number[]) => (a.length > 0) && "..."
+        <T extends unknown[]>(...a: T) => (a.length > 0) || "empty";
+      `,
+    }),
+
+    // mixed `string | number` value in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: string | number; if (x) {}
+        (x: bigint | string) => !x;
+        <T extends number | bigint | string>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
+        { column: 39, line: 2, messageId: 'conditionErrorOther' },
+        { column: 34, line: 3, messageId: 'conditionErrorOther' },
+        { column: 55, line: 4, messageId: 'conditionErrorOther' },
+      ],
+      options: [{ allowNumber: true, allowString: true }],
+    }),
+
+    // nullable boolean in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: boolean | null; if (x) {}
+        (x?: boolean) => !x;
+        <T extends boolean | null | undefined>(x: T) => x ? 1 : 0;
       `,
       errors: [
         {
-          column: 1,
-          line: 0,
-          messageId: 'noStrictNullCheck',
+          column: 38,
+          line: 2,
+          messageId: 'conditionErrorNullableBoolean',
+          suggestions: [
+            {
+              messageId: 'conditionFixDefaultFalse',
+              output: `declare const x: boolean | null; if (x ?? false) {}`,
+            },
+            {
+              messageId: 'conditionFixCompareTrue',
+              output: `declare const x: boolean | null; if (x === true) {}`,
+            },
+          ],
         },
         {
-          column: 5,
+          column: 27,
           line: 3,
-          messageId: 'conditionErrorObject',
+          messageId: 'conditionErrorNullableBoolean',
+          suggestions: [
+            {
+              messageId: 'conditionFixDefaultFalse',
+              output: `        (x?: boolean) => !(x ?? false);`,
+            },
+            {
+              messageId: 'conditionFixCompareFalse',
+              output: `        (x?: boolean) => x === false;`,
+            },
+          ],
         },
-      ],
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        {
+          column: 57,
+          line: 4,
+          messageId: 'conditionErrorNullableBoolean',
+          suggestions: [
+            {
+              messageId: 'conditionFixDefaultFalse',
+              output: `        <T extends boolean | null | undefined>(x: T) => (x ?? false) ? 1 : 0;`,
+            },
+            {
+              messageId: 'conditionFixCompareTrue',
+              output: `        <T extends boolean | null | undefined>(x: T) => (x === true) ? 1 : 0;`,
+            },
+          ],
         },
-      },
-      output: null,
-    },
+      ],
+      options: [{ allowNullableBoolean: false }],
+    }),
 
-    // automatic semicolon insertion test
-    {
+    // nullable object in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        obj || 0
-        obj && 1 || 0
+        declare const x: object | null; if (x) {}
+        (x?: { a: number }) => !x;
+        <T extends {} | null | undefined>(x: T) => x ? 1 : 0;
       `,
       errors: [
         {
-          column: 10,
-          line: 3,
+          column: 37,
+          line: 2,
           messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        (obj == null) ? 1 : 0
-        !obj
-        obj || 0
-        obj && 1 || 0
-      `,
+              output: 'declare const x: object | null; if (x != null) {}',
             },
           ],
         },
         {
-          column: 10,
-          line: 4,
+          column: 33,
+          line: 3,
           messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        obj == null
-        obj || 0
-        obj && 1 || 0
-      `,
+              output: `        (x?: { a: number }) => x == null;`,
             },
           ],
         },
         {
-          column: 9,
-          line: 5,
+          column: 52,
+          line: 4,
           messageId: 'conditionErrorNullableObject',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        ;(obj != null) || 0
-        obj && 1 || 0
-      `,
+              output: `        <T extends {} | null | undefined>(x: T) => (x != null) ? 1 : 0;`,
             },
           ],
         },
+      ],
+      options: [{ allowNullableObject: false }],
+    }),
+
+    // nullable string in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: string | null; if (x) {}
+        (x?: string) => !x;
+        <T extends string | null | undefined>(x: T) => x ? 1 : 0;
+        function foo(x: '' | 'bar' | null) { if (!x) {} }
+      `,
+      errors: [
         {
-          column: 9,
-          line: 6,
-          messageId: 'conditionErrorNullableObject',
+          column: 37,
+          line: 2,
+          messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-        declare const obj: { x: number } | null;
-        !obj ? 1 : 0
-        !obj
-        obj || 0
-        ;(obj != null) && 1 || 0
-      `,
+              output: 'declare const x: string | null; if (x != null) {}',
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: 'declare const x: string | null; if (x ?? "") {}',
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: 'declare const x: string | null; if (Boolean(x)) {}',
             },
           ],
         },
-      ],
-      options: [{ allowNullableObject: false }],
-      output: null,
-    },
-    {
-      code: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString);
-      `,
-      errors: [
         {
-          column: 8,
-          line: 4,
+          column: 26,
+          line: 3,
           messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString != null);
-      `,
+              output: '        (x?: string) => x == null;',
             },
             {
               messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(nullableString ?? "");
-      `,
+              output: '        (x?: string) => !(x ?? "");',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(x: unknown): asserts x;
-declare const nullableString: string | null;
-assert(Boolean(nullableString));
-      `,
+              output: '        (x?: string) => !Boolean(x);',
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      code: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString);
-      `,
-      errors: [
         {
-          column: 13,
+          column: 56,
           line: 4,
           messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
-      `,
+              output:
+                '        <T extends string | null | undefined>(x: T) => (x != null) ? 1 : 0;',
             },
             {
               messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
-      `,
+              output:
+                '        <T extends string | null | undefined>(x: T) => (x ?? "") ? 1 : 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
-      `,
+              output:
+                '        <T extends string | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      code: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString);
-      `,
-      errors: [
         {
-          column: 13,
+          column: 51,
           line: 5,
           messageId: 'conditionErrorNullableString',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
-      `,
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (x == null) {} }",
             },
             {
               messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
-      `,
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (!(x ?? \"\")) {} }",
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: number, b: unknown): asserts b;
-declare function assert(one: number, two: unknown): asserts two;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
-      `,
+              output:
+                "        function foo(x: '' | 'bar' | null) { if (!Boolean(x)) {} }",
             },
           ],
         },
       ],
-      output: null,
-    },
-    {
-      code: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString);
+    }),
+
+    // nullable number in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        declare const x: number | null; if (x) {}
+        (x?: number) => !x;
+        <T extends number | null | undefined>(x: T) => x ? 1 : 0;
+        function foo(x: 0 | 1 | null) { if (!x) {} }
       `,
       errors: [
         {
-          column: 13,
-          line: 4,
-          messageId: 'conditionErrorNullableString',
+          column: 37,
+          line: 2,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString != null);
-      `,
+              output: 'declare const x: number | null; if (x != null) {}',
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, nullableString ?? "");
-      `,
+              messageId: 'conditionFixDefaultZero',
+              output: 'declare const x: number | null; if (x ?? 0) {}',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(this: object, a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-assert(foo, Boolean(nullableString));
-      `,
+              output: 'declare const x: number | null; if (Boolean(x)) {}',
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      code: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString);
-      `,
-      errors: [
         {
-          messageId: 'conditionErrorNullableString',
+          column: 26,
+          line: 3,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString != null);
-      `,
+              output: '        (x?: number) => x == null;',
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(maybeString ?? "");
-      `,
+              messageId: 'conditionFixDefaultZero',
+              output: '        (x?: number) => !(x ?? 0);',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-function asserts1(x: string | number | undefined): asserts x {}
-function asserts2(x: string | number | undefined): asserts x {}
-
-const maybeString = Math.random() ? 'string'.slice() : undefined;
-
-const someAssert: typeof asserts1 | typeof asserts2 =
-  Math.random() > 0.5 ? asserts1 : asserts2;
-
-someAssert(Boolean(maybeString));
-      `,
+              output: '        (x?: number) => !Boolean(x);',
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      // The implementation signature doesn't count towards the call signatures
-      code: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString);
-      `,
-      errors: [
         {
-          column: 18,
-          line: 18,
-          messageId: 'conditionErrorNullableString',
+          column: 56,
+          line: 4,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString != null);
-      `,
+              output:
+                '        <T extends number | null | undefined>(x: T) => (x != null) ? 1 : 0;',
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString ?? "");
-      `,
+              messageId: 'conditionFixDefaultZero',
+              output:
+                '        <T extends number | null | undefined>(x: T) => (x ?? 0) ? 1 : 0;',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, Boolean(nullableString));
-      `,
+              output:
+                '        <T extends number | null | undefined>(x: T) => (Boolean(x)) ? 1 : 0;',
             },
           ],
         },
-      ],
-      output: null,
-    },
-    {
-      // The implementation signature doesn't count towards the call signatures
-      code: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString, 'more', 'args', 'afterwards');
-      `,
-      errors: [
         {
-          column: 18,
-          line: 19,
-          messageId: 'conditionErrorNullableString',
+          column: 46,
+          line: 5,
+          messageId: 'conditionErrorNullableNumber',
           suggestions: [
             {
               messageId: 'conditionFixCompareNullish',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString != null, 'more', 'args', 'afterwards');
-      `,
+              output:
+                '        function foo(x: 0 | 1 | null) { if (x == null) {} }',
             },
             {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
-
-declare const nullableString: string | null;
-assert(3 as any, nullableString ?? "", 'more', 'args', 'afterwards');
-      `,
+              messageId: 'conditionFixDefaultZero',
+              output:
+                '        function foo(x: 0 | 1 | null) { if (!(x ?? 0)) {} }',
             },
             {
               messageId: 'conditionFixCastBoolean',
-              output: `
-function assert(this: object, a: number, b: unknown): asserts b;
-function assert(a: bigint, b: unknown): asserts b;
-function assert(this: object, a: string, two: string): asserts two;
-function assert(
-  this: object,
-  a: string,
-  assertee: string,
-  c: bigint,
-  d: object,
-): asserts assertee;
-function assert(a: any, two: unknown, ...rest: any[]): asserts two;
-
-function assert(...args: any[]) {
-  throw new Error('lol');
-}
+              output:
+                '        function foo(x: 0 | 1 | null) { if (!Boolean(x)) {} }',
+            },
+          ],
+        },
+      ],
+    }),
 
-declare const nullableString: string | null;
-assert(3 as any, Boolean(nullableString), 'more', 'args', 'afterwards');
+    // nullable enum in boolean context
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 13,
+          endColumn: 20,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum != null) {
+        }
       `,
-            },
-          ],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
         },
       ],
-      output: null,
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
     },
     {
       code: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
+        enum ExampleEnum {
+          This,
+          That,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
       `,
       errors: [
         {
-          line: 6,
-          messageId: 'conditionErrorNullableString',
-          suggestions: [
-            {
-              messageId: 'conditionFixCompareNullish',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString != null);
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This,
+          That,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
       `,
-            },
-            {
-              messageId: 'conditionFixDefaultEmptyString',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString ?? "");
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 'a',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
       `,
-            },
-
-            {
-              messageId: 'conditionFixCastBoolean',
-              output: `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, Boolean(nullableString));
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 'a',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
       `,
-            },
-          ],
+    },
+    {
+      code: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
         },
       ],
-      output: null,
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
+      `,
     },
-  ],
-
-  valid: [
-    // boolean in boolean context
-    "true ? 'a' : 'b';",
-    `
-if (false) {
-}
-    `,
-    'while (true) {}',
-    'for (; false; ) {}',
-    '!true;',
-    'false || 123;',
-    "true && 'foo';",
-    '!(false || true);',
-    'true && false ? true : false;',
-    '(false && true) || false;',
-    '(false && true) || [];',
-    '(false && 1) || (true && 2);',
-    `
-declare const x: boolean;
-if (x) {
-}
-    `,
-    '(x: boolean) => !x;',
-    '<T extends boolean>(x: T) => (x ? 1 : 0);',
-    `
-declare const x: never;
-if (x) {
-}
-    `,
-
-    // string in boolean context
-    `
-if ('') {
-}
-    `,
-    "while ('x') {}",
-    "for (; ''; ) {}",
-    "('' && '1') || x;",
-    `
-declare const x: string;
-if (x) {
-}
-    `,
-    '(x: string) => !x;',
-    '<T extends string>(x: T) => (x ? 1 : 0);',
-
-    // number in boolean context
-    `
-if (0) {
-}
-    `,
-    'while (1n) {}',
-    'for (; Infinity; ) {}',
-    '(0 / 0 && 1 + 2) || x;',
-    `
-declare const x: number;
-if (x) {
-}
-    `,
-    '(x: bigint) => !x;',
-    '<T extends number>(x: T) => (x ? 1 : 0);',
-
-    // nullable object in boolean context
-    `
-declare const x: null | object;
-if (x) {
-}
-    `,
-    '(x?: { a: any }) => !x;',
-    '<T extends {} | null | undefined>(x: T) => (x ? 1 : 0);',
-
-    // nullable boolean in boolean context
     {
       code: `
-        declare const x: boolean | null;
-        if (x) {
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 'one',
+          That = 'two',
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
         }
       `,
-      options: [{ allowNullableBoolean: true }],
     },
     {
       code: `
-        (x?: boolean) => !x;
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (!theEnum) {
+        }
       `,
-      options: [{ allowNullableBoolean: true }],
-    },
-    {
-      code: `
-        <T extends boolean | null | undefined>(x: T) => (x ? 1 : 0);
+      errors: [
+        {
+          column: 14,
+          endColumn: 21,
+          endLine: 7,
+          line: 7,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 1,
+          That = 2,
+        }
+        const theEnum = Math.random() < 0.3 ? ExampleEnum.This : null;
+        if (theEnum == null) {
+        }
       `,
-      options: [{ allowNullableBoolean: true }],
     },
 
-    // nullable string in boolean context
+    // nullable mixed enum in boolean context
     {
+      // falsy number and truthy string
       code: `
-        declare const x: string | null;
-        if (x) {
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
         }
+        (value?: ExampleEnum) => (value ? 1 : 0);
+      `,
+      errors: [
+        {
+          column: 35,
+          endColumn: 40,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 'one',
+        }
+        (value?: ExampleEnum) => ((value != null) ? 1 : 0);
       `,
-      options: [{ allowNullableString: true }],
     },
     {
+      // falsy string and truthy number
       code: `
-        (x?: string) => !x;
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      errors: [
+        {
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 1,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
       `,
-      options: [{ allowNullableString: true }],
     },
     {
+      // truthy string and truthy number
       code: `
-        <T extends string | null | undefined>(x: T) => (x ? 1 : 0);
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      errors: [
+        {
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = 'this',
+          That = 1,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
       `,
-      options: [{ allowNullableString: true }],
     },
-
-    // nullable number in boolean context
     {
+      // falsy string and falsy number
       code: `
-        declare const x: number | null;
-        if (x) {
+        enum ExampleEnum {
+          This = '',
+          That = 0,
         }
+        (value?: ExampleEnum) => (!value ? 1 : 0);
+      `,
+      errors: [
+        {
+          column: 36,
+          endColumn: 41,
+          endLine: 6,
+          line: 6,
+          messageId: 'conditionErrorNullableEnum',
+        },
+      ],
+      options: [{ allowNullableEnum: false }],
+      output: `
+        enum ExampleEnum {
+          This = '',
+          That = 0,
+        }
+        (value?: ExampleEnum) => ((value == null) ? 1 : 0);
       `,
-      options: [{ allowNullableNumber: true }],
     },
+
+    // any in boolean context
+    ...batchedSingleLineTests<MessageId, Options>({
+      code: noFormat`
+        if (x) {}
+        x => !x;
+        <T extends any>(x: T) => x ? 1 : 0;
+        <T>(x: T) => x ? 1 : 0;
+      `,
+      errors: [
+        {
+          column: 5,
+          line: 2,
+          messageId: 'conditionErrorAny',
+          suggestions: [
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: 'if (Boolean(x)) {}',
+            },
+          ],
+        },
+        {
+          column: 15,
+          line: 3,
+          messageId: 'conditionErrorAny',
+          suggestions: [
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: '        x => !(Boolean(x));',
+            },
+          ],
+        },
+        {
+          column: 34,
+          line: 4,
+          messageId: 'conditionErrorAny',
+          suggestions: [
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: '        <T extends any>(x: T) => (Boolean(x)) ? 1 : 0;',
+            },
+          ],
+        },
+        {
+          column: 22,
+          line: 5,
+          messageId: 'conditionErrorAny',
+          suggestions: [
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: '        <T>(x: T) => (Boolean(x)) ? 1 : 0;',
+            },
+          ],
+        },
+      ],
+    }),
+
+    // noStrictNullCheck
     {
       code: `
-        (x?: number) => !x;
+declare const x: string[] | null;
+if (x) {
+}
       `,
-      options: [{ allowNullableNumber: true }],
+      errors: [
+        {
+          column: 1,
+          line: 0,
+          messageId: 'noStrictNullCheck',
+        },
+        {
+          column: 5,
+          line: 3,
+          messageId: 'conditionErrorObject',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
+      },
+      output: null,
     },
+
+    // automatic semicolon insertion test
     {
-      code: `
-        <T extends number | null | undefined>(x: T) => (x ? 1 : 0);
+      code: noFormat`
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        obj || 0
+        obj && 1 || 0
+      `,
+      errors: [
+        {
+          column: 10,
+          line: 3,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        (obj == null) ? 1 : 0
+        !obj
+        obj || 0
+        obj && 1 || 0
+      `,
+            },
+          ],
+        },
+        {
+          column: 10,
+          line: 4,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        obj == null
+        obj || 0
+        obj && 1 || 0
       `,
-      options: [{ allowNullableNumber: true }],
-    },
-
-    // any in boolean context
-    {
-      code: `
-        declare const x: any;
-        if (x) {
-        }
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 5,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        ;(obj != null) || 0
+        obj && 1 || 0
       `,
-      options: [{ allowAny: true }],
-    },
-    {
-      code: `
-        x => !x;
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 6,
+          messageId: 'conditionErrorNullableObject',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+        declare const obj: { x: number } | null;
+        !obj ? 1 : 0
+        !obj
+        obj || 0
+        ;(obj != null) && 1 || 0
       `,
-      options: [{ allowAny: true }],
+            },
+          ],
+        },
+      ],
+      options: [{ allowNullableObject: false }],
+      output: null,
     },
     {
       code: `
-        <T extends any>(x: T) => (x ? 1 : 0);
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString);
       `,
-      options: [{ allowAny: true }],
-    },
-
-    // logical operator
-    {
-      code: `
-        1 && true && 'x' && {};
+      errors: [
+        {
+          column: 8,
+          line: 4,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString != null);
       `,
-      options: [{ allowNumber: true, allowString: true }],
-    },
-    {
-      code: `
-        let x = 0 || false || '' || null;
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(nullableString ?? "");
       `,
-      options: [{ allowNumber: true, allowString: true }],
-    },
-    {
-      code: `
-        if (1 && true && 'x') void 0;
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(x: unknown): asserts x;
+declare const nullableString: string | null;
+assert(Boolean(nullableString));
       `,
-      options: [{ allowNumber: true, allowString: true }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        if (0 || false || '') void 0;
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString);
       `,
-      options: [{ allowNumber: true, allowString: true }],
-    },
-    {
-      code: `
-        1 && true && 'x' ? {} : null;
+      errors: [
+        {
+          column: 13,
+          line: 4,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
       `,
-      options: [{ allowNumber: true, allowString: true }],
-    },
-    {
-      code: `
-        0 || false || '' ? null : {};
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
       `,
-      options: [{ allowNumber: true, allowString: true }],
-    },
-
-    // nullable enum in boolean context
-    {
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (theEnum) {
-        }
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
       `,
-      options: [{ allowNullableEnum: true }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
       code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 1,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString);
       `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 1,
-          That = 2,
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
+      errors: [
+        {
+          column: 13,
+          line: 5,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
       `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      code: `
-        enum ExampleEnum {
-          This = 'one',
-          That = 'two',
-        }
-        const rand = Math.random();
-        let theEnum: ExampleEnum | null = null;
-        if (rand < 0.3) {
-          theEnum = ExampleEnum.This;
-        }
-        if (!theEnum) {
-        }
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
       `,
-      options: [{ allowNullableEnum: true }],
-    },
-
-    // nullable mixed enum in boolean context
-    {
-      // falsy number and truthy string
-      code: `
-        enum ExampleEnum {
-          This = 0,
-          That = 'one',
-        }
-        (value?: ExampleEnum) => (value ? 1 : 0);
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(a: number, b: unknown): asserts b;
+declare function assert(one: number, two: unknown): asserts two;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
       `,
-      options: [{ allowNullableEnum: true }],
+            },
+          ],
+        },
+      ],
+      output: null,
     },
     {
-      // falsy string and truthy number
       code: `
-        enum ExampleEnum {
-          This = '',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString);
       `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      // truthy string and truthy number
-      code: `
-        enum ExampleEnum {
-          This = 'this',
-          That = 1,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
+      errors: [
+        {
+          column: 13,
+          line: 4,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString != null);
       `,
-      options: [{ allowNullableEnum: true }],
-    },
-    {
-      // falsy string and falsy number
-      code: `
-        enum ExampleEnum {
-          This = '',
-          That = 0,
-        }
-        (value?: ExampleEnum) => (!value ? 1 : 0);
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, nullableString ?? "");
       `,
-      options: [{ allowNullableEnum: true }],
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(this: object, a: number, b: unknown): asserts b;
+declare const nullableString: string | null;
+assert(foo, Boolean(nullableString));
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
-
     {
       code: `
-declare const x: string[] | null;
-// eslint-disable-next-line
-if (x) {
-}
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString);
       `,
-      languageOptions: {
-        parserOptions: {
-          tsconfigRootDir: path.join(rootPath, 'unstrict'),
-        },
-      },
-      options: [
+      errors: [
         {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(maybeString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+function asserts1(x: string | number | undefined): asserts x {}
+function asserts2(x: string | number | undefined): asserts x {}
+
+const maybeString = Math.random() ? 'string'.slice() : undefined;
+
+const someAssert: typeof asserts1 | typeof asserts2 =
+  Math.random() > 0.5 ? asserts1 : asserts2;
+
+someAssert(Boolean(maybeString));
+      `,
+            },
+          ],
         },
       ],
+      output: null,
     },
-
-    `
-function f(arg: 'a' | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-function f(arg: 'a' | 'b' | null) {
-  if (arg) console.log(arg);
-}
-    `,
     {
+      // The implementation signature doesn't count towards the call signatures
       code: `
-declare const x: 1 | null;
-declare const y: 1;
-if (x) {
-}
-if (y) {
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
 }
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString);
       `,
-      options: [
+      errors: [
         {
-          allowNumber: true,
-        },
-      ],
-    },
-    `
-function f(arg: 1 | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-function f(arg: 1 | 2 | null) {
-  if (arg) console.log(arg);
-}
-    `,
-    `
-interface Options {
-  readonly enableSomething?: true;
-}
+          column: 18,
+          line: 18,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
 
-function f(opts: Options): void {
-  if (opts.enableSomething) console.log('Do something');
-}
-    `,
-    `
-declare const x: true | null;
-if (x) {
+function assert(...args: any[]) {
+  throw new Error('lol');
 }
-    `,
-    {
-      code: `
-declare const x: 'a' | null;
-declare const y: 'a';
-if (x) {
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
 }
-if (y) {
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString ?? "");
+      `,
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
 }
+
+declare const nullableString: string | null;
+assert(3 as any, Boolean(nullableString));
       `,
-      options: [
-        {
-          allowString: true,
+            },
+          ],
         },
       ],
+      output: null,
     },
-    `
-declare const foo: boolean & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare const foo: true & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare const foo: false & { __BRAND: 'Foo' };
-if (foo) {
-}
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts a;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    `
-declare function assert(a: boolean, b: unknown): asserts b is string;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    // Intentional TS error - cannot assert a parameter in a binding pattern.
-    `
-declare function assert(a: boolean, b: unknown): asserts b;
-declare function assert(a: boolean, { b }: { b: unknown }): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(nullableString, boo);
-    `,
-    `
-declare function assert(a: number, b: unknown): asserts b;
-declare const nullableString: string | null;
-declare const boo: boolean;
-assert(...nullableString, nullableString);
-    `,
-    `
-declare function assert(
-  this: object,
-  a: number,
-  b?: unknown,
-  c?: unknown,
-): asserts c;
-declare const nullableString: string | null;
-declare const foo: number;
-const o: { assert: typeof assert } = {
-  assert,
-};
-o.assert(foo, nullableString);
-    `,
     {
+      // The implementation signature doesn't count towards the call signatures
       code: `
-declare function assert(x: unknown): x is string;
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
 declare const nullableString: string | null;
-assert(nullableString);
+assert(3 as any, nullableString, 'more', 'args', 'afterwards');
       `,
-    },
-    {
-      code: `
-class ThisAsserter {
-  assertThis(this: unknown, arg2: unknown): asserts this {}
+      errors: [
+        {
+          column: 18,
+          line: 19,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
+
+function assert(...args: any[]) {
+  throw new Error('lol');
 }
 
-declare const lol: string | number | unknown | null;
+declare const nullableString: string | null;
+assert(3 as any, nullableString != null, 'more', 'args', 'afterwards');
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+function assert(this: object, a: number, b: unknown): asserts b;
+function assert(a: bigint, b: unknown): asserts b;
+function assert(this: object, a: string, two: string): asserts two;
+function assert(
+  this: object,
+  a: string,
+  assertee: string,
+  c: bigint,
+  d: object,
+): asserts assertee;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
 
-const thisAsserter: ThisAsserter = new ThisAsserter();
-thisAsserter.assertThis(lol);
+function assert(...args: any[]) {
+  throw new Error('lol');
+}
+
+declare const nullableString: string | null;
+assert(3 as any, nullableString ?? "", 'more', 'args', 'afterwards');
       `,
-    },
-    {
-      code: `
+            },
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
 function assert(this: object, a: number, b: unknown): asserts b;
 function assert(a: bigint, b: unknown): asserts b;
 function assert(this: object, a: string, two: string): asserts two;
@@ -2833,61 +2825,69 @@ function assert(
   c: bigint,
   d: object,
 ): asserts assertee;
-function assert(...args: any[]): void;
+function assert(a: any, two: unknown, ...rest: any[]): asserts two;
 
 function assert(...args: any[]) {
   throw new Error('lol');
 }
 
 declare const nullableString: string | null;
-assert(3 as any, nullableString);
+assert(3 as any, Boolean(nullableString), 'more', 'args', 'afterwards');
       `,
+            },
+          ],
+        },
+      ],
+      output: null,
     },
-    // Intentional TS error - A rest parameter must be last in a parameter list.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(...a: boolean[], b: unknown): asserts b;
+    {
+      code: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
 declare const nullableString: string | null;
 declare const boo: boolean;
 assert(boo, nullableString);
-    `,
-    // Intentional TS error - A type predicate cannot reference a rest parameter.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(a: boolean, ...b: unknown[]): asserts b;
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'conditionErrorNullableString',
+          suggestions: [
+            {
+              messageId: 'conditionFixCompareNullish',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
 declare const nullableString: string | null;
 declare const boo: boolean;
-assert(boo, nullableString);
-    `,
-    // Intentional TS error - An assertion function must have a parameter to assert.
-    // This is just to test that we don't crash or falsely report.
-    `
-declare function assert(): asserts x;
-declare const nullableString: string | null;
-assert(nullableString);
-    `,
-    `
-function assert(one: unknown): asserts one;
-function assert(one: unknown, two: unknown): asserts two;
-function assert(...args: unknown[]) {
-  throw new Error('not implemented');
-}
+assert(boo, nullableString != null);
+      `,
+            },
+            {
+              messageId: 'conditionFixDefaultEmptyString',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
 declare const nullableString: string | null;
-assert(nullableString);
-assert('one', nullableString);
-    `,
-    // Intentional use of `any` to test a function call with no call signatures.
-    `
-declare const assert: any;
+declare const boo: boolean;
+assert(boo, nullableString ?? "");
+      `,
+            },
+
+            {
+              messageId: 'conditionFixCastBoolean',
+              output: `
+declare function assert(a: boolean, b: unknown): asserts b;
+declare function assert({ a }: { a: boolean }, b: unknown): asserts b;
 declare const nullableString: string | null;
-assert(nullableString);
-    `,
-    // Coverage for absent "test expression".
-    // Ensure that no crash or false positive occurs
-    `
-      for (let x = 0; ; x++) {
-        break;
-      }
-    `,
+declare const boo: boolean;
+assert(boo, Boolean(nullableString));
+      `,
+            },
+          ],
+        },
+      ],
+      output: null,
+    },
   ],
 });
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 05a19743f04e..13869b62c859 100644
--- a/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
+++ b/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
@@ -15,270 +15,380 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('switch-exhaustiveness-check', switchExhaustivenessCheck, {
-  invalid: [
+  valid: [
+    // All branches matched
+    `
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
+    break;
+  }
+  case 'Tuesday': {
+    result = 2;
+    break;
+  }
+  case 'Wednesday': {
+    result = 3;
+    break;
+  }
+  case 'Thursday': {
+    result = 4;
+    break;
+  }
+  case 'Friday': {
+    result = 5;
+    break;
+  }
+  case 'Saturday': {
+    result = 6;
+    break;
+  }
+  case 'Sunday': {
+    result = 7;
+    break;
+  }
+}
+    `,
+    // Other primitive literals work too
+    `
+type Num = 0 | 1 | 2;
+
+function test(value: Num): number {
+  switch (value) {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    case 2:
+      return 2;
+  }
+}
+    `,
+    `
+type Bool = true | false;
+
+function test(value: Bool): number {
+  switch (value) {
+    case true:
+      return 1;
+    case false:
+      return 0;
+  }
+}
+    `,
+    `
+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;
+  }
+}
+    `,
+    // Works with type references
+    `
+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;
+  }
+}
+    `,
+    // Works with `typeof`
+    `
+const A = 'a';
+const B = 1;
+const C = true;
+
+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;
+  }
+}
+    `,
+    // Switch contains default clause.
+    `
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
+    break;
+  }
+  default: {
+    result = 42;
+  }
+}
+    `,
+    // Exhaustiveness check only works for union types...
+    `
+const day = 'Monday' as string;
+let result = 0;
+
+switch (day) {
+  case 'Monday': {
+    result = 1;
+    break;
+  }
+  case 'Tuesday': {
+    result = 2;
+    break;
+  }
+}
+    `,
+    // ... and enums (at least for now).
+    `
+enum Enum {
+  A,
+  B,
+}
+
+function test(value: Enum): number {
+  switch (value) {
+    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 };
+
+function test(value: ObjectUnion): number {
+  switch (value.a) {
+    case 1:
+      return 1;
+  }
+}
+    `,
+    // switch with default clause on non-union type
     {
       code: `
-declare const value: 'literal';
-switch (value) {
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: 'literal';
+declare const value: number;
 switch (value) {
-case "literal": { throw new Error('Not implemented yet: "literal" case') }
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: true,
         },
       ],
     },
+    // switch with default clause on string type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: 'literal' & { _brand: true };
-switch (value) {
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: 'literal' & { _brand: true };
+declare const value: string;
 switch (value) {
-case "literal": { throw new Error('Not implemented yet: "literal" case') }
+  case 'foo':
+    return 0;
+  case 'bar':
+    return 1;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
+    // switch with default clause on number type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: ('literal' & { _brand: true }) | 1;
-switch (value) {
-  case 'literal':
-    break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: ('literal' & { _brand: true }) | 1;
+declare const value: number;
 switch (value) {
-  case 'literal':
-    break;
-  case 1: { throw new Error('Not implemented yet: 1 case') }
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
+    // switch with default clause on bigint type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: '1' | '2' | number;
+declare const value: bigint;
 switch (value) {
-  case '1':
-    break;
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: '1' | '2' | number;
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    // switch with default clause on symbol type +
+    // "allowDefaultCaseForExhaustiveSwitch" option
+    {
+      code: `
+declare const value: symbol;
+const foo = Symbol('foo');
 switch (value) {
-  case '1':
-    break;
-  case "2": { throw new Error('Not implemented yet: "2" case') }
+  case foo:
+    return 0;
+  default:
+    return -1;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: false,
         },
       ],
     },
+    // switch with default clause on union with number +
+    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: '1' | '2' | number;
+declare const value: 0 | 1 | number;
 switch (value) {
-  case '1':
-    break;
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default:
+    return -1;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case "2": { throw new Error('Not implemented yet: "2" case') }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: '1' | '2' | number;
+      ],
+    },
+    {
+      code: `
+declare const value: 'literal';
 switch (value) {
-  case '1':
-    break;
-  default: { throw new Error('default case') }
+  case 'literal':
+    return 0;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: (string & { foo: 'bar' }) | '1';
-switch (value) {
-  case '1':
-    break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: (string & { foo: 'bar' }) | '1';
+declare const value: null;
 switch (value) {
-  case '1':
-    break;
-  default: { throw new Error('default case') }
+  case null:
+    return 0;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+declare const value: undefined;
 switch (value) {
+  case undefined:
+    return 0;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
-switch (value) {
-case undefined: { throw new Error('Not implemented yet: undefined case') }
-case null: { throw new Error('Not implemented yet: null case') }
-case "1": { throw new Error('Not implemented yet: "1" case') }
-case 1: { throw new Error('Not implemented yet: 1 case') }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+      ],
+    },
+    {
+      code: `
+declare const value: null | undefined;
 switch (value) {
-default: { throw new Error('default case') }
+  case null:
+    return 0;
+  case undefined:
+    return 0;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -288,32 +398,29 @@ default: { throw new Error('default case') }
     },
     {
       code: `
-declare const value: string | number;
+declare const value: 'literal' & { _brand: true };
 switch (value) {
-  case 1:
+  case 'literal':
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: string | number;
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: ('literal' & { _brand: true }) | 1;
 switch (value) {
+  case 'literal':
+    break;
   case 1:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -323,34 +430,16 @@ switch (value) {
     },
     {
       code: `
-declare const value: number;
-declare const a: number;
+declare const value: (1 & { _brand: true }) | 'literal' | null;
 switch (value) {
-  case a:
+  case 'literal':
     break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 4,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: number;
-declare const a: number;
-switch (value) {
-  case a:
+  case 1:
+    break;
+  case null:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -360,214 +449,157 @@ switch (value) {
     },
     {
       code: `
-declare const value: bigint;
+declare const value: '1' | '2' | number;
 switch (value) {
-  case 10n:
+  case '1':
     break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: bigint;
-switch (value) {
-  case 10n:
+  case '2':
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-declare const value: symbol;
-const a = Symbol('a');
+declare const value: '1' | '2' | number;
 switch (value) {
-  case a:
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 4,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: symbol;
-const a = Symbol('a');
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: '1' | '2' | number;
 switch (value) {
-  case a:
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-const a = Symbol('aa');
-const b = Symbol('bb');
-declare const value: typeof a | typeof b | 1;
+declare const value: '1' | '2' | (number & { foo: 'bar' });
 switch (value) {
-  case 1:
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 5,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const a = Symbol('aa');
-const b = Symbol('bb');
-declare const value: typeof a | typeof b | 1;
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: '1' | '2' | number;
 switch (value) {
-  case 1:
+  case '1':
+    break;
+  case '2':
+    break;
+  default:
     break;
-  case a: { throw new Error('Not implemented yet: a case') }
-  case b: { throw new Error('Not implemented yet: b case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
+declare const value: number | null | undefined;
 switch (value) {
-  case a:
+  case null:
+    break;
+  case undefined:
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 4,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const a = Symbol('a');
-declare const value: typeof a | string;
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: '1' | '2' | number;
 switch (value) {
-  case a:
+  case '1':
+    break;
+  default:
     break;
-  default: { throw new Error('default case') }
 }
-      `,
-            },
-          ],
-        },
-      ],
+      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-declare const value: boolean;
-switch (value) {
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean;
+declare const value: (string & { foo: 'bar' }) | '1';
 switch (value) {
-case false: { throw new Error('Not implemented yet: false case') }
-case true: { throw new Error('Not implemented yet: true case') }
+  case '1':
+    break;
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
+          allowDefaultCaseForExhaustiveSwitch: true,
           requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-declare const value: boolean | 1;
+const a = Symbol('a');
+declare const value: typeof a | 2;
 switch (value) {
-  case false:
+  case a:
     break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | 1;
-switch (value) {
-  case false:
+  case 2:
     break;
-  case true: { throw new Error('Not implemented yet: true case') }
-  case 1: { throw new Error('Not implemented yet: 1 case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -577,51 +609,40 @@ switch (value) {
     },
     {
       code: `
-declare const value: boolean | number;
+declare const value: string | number;
 switch (value) {
   case 1:
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | number;
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: string | number;
 switch (value) {
-  case 1:
-    break;
-  case false: { throw new Error('Not implemented yet: false case') }
-  case true: { throw new Error('Not implemented yet: true case') }
 }
       `,
-            },
-          ],
-        },
+      options: [
         {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: boolean | number;
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: string | number;
 switch (value) {
-  case 1:
+  default:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -631,103 +652,62 @@ switch (value) {
     },
     {
       code: `
-declare const value: object;
-switch (value) {
-  case 1:
-    break;
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 3,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-declare const value: object;
+declare const value: number;
+declare const a: number;
 switch (value) {
-  case 1:
+  case a:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
       code: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
+declare const value: bigint;
 switch (value) {
-  case 1:
-    break;
-  case Aaa.Foo:
+  case 10n:
     break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 9,
-          line: 7,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: symbol;
+const a = Symbol('a');
 switch (value) {
-  case 1:
-    break;
-  case Aaa.Foo:
+  case a:
     break;
-  case Aaa.Bar: { throw new Error('Not implemented yet: Aaa.Bar case') }
 }
       `,
-            },
-          ],
-        },
+      options: [
         {
-          column: 9,
-          line: 7,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1 | string;
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+declare const value: symbol;
+const a = Symbol('a');
 switch (value) {
-  case 1:
+  case a:
     break;
-  case Aaa.Foo:
+  default:
     break;
-  default: { throw new Error('default case') }
 }
       `,
-            },
-          ],
-        },
-      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: true,
@@ -736,548 +716,430 @@ switch (value) {
       ],
     },
     {
-      // 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;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
-    break;
-  }
-}
-      `,
-      errors: [
-        {
-          column: 9,
-          data: {
-            missingBranches:
-              '"Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
-          },
-          line: 14,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  case a:
+    break;
+  default:
     break;
-  }
-  case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
-  case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
-  case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
-  case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
-  case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
-  case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // Didn't match all enum variants
       code: `
-enum Enum {
-  A,
-  B,
-}
-
-function test(value: Enum): number {
-  switch (value) {
-    case Enum.A:
-      return 1;
-  }
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  default:
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 11,
-          data: {
-            missingBranches: 'Enum.B',
-          },
-          line: 8,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-enum Enum {
-  A,
-  B,
-}
-
-function test(value: Enum): number {
-  switch (value) {
-    case Enum.A:
-      return 1;
-    case Enum.B: { throw new Error('Not implemented yet: Enum.B case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-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;
-  }
+declare const value: boolean | 1;
+switch (value) {
+  case 1:
+    break;
+  default:
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 11,
-          data: {
-            missingBranches: '"b" | "c"',
-          },
-          line: 8,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-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": { throw new Error('Not implemented yet: "b" case') }
-    case "c": { throw new Error('Not implemented yet: "c" case') }
-  }
-}
-      `,
-            },
-          ],
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-const A = 'a';
-const B = 1;
-const C = true;
-
-type Union = typeof A | typeof B | typeof C;
-
-function test(value: Union): number {
-  switch (value) {
-    case 'a':
-      return 1;
-  }
+declare const value: boolean | 1;
+switch (value) {
+  case 1:
+    break;
+  case true:
+    break;
+  case false:
+    break;
+  default:
+    break;
 }
       `,
-      errors: [
+      options: [
         {
-          column: 11,
-          data: {
-            missingBranches: 'true | 1',
-          },
-          line: 9,
-          messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-const A = 'a';
-const B = 1;
-const C = true;
-
-type Union = typeof A | typeof B | typeof C;
-
-function test(value: Union): number {
-  switch (value) {
-    case 'a':
-      return 1;
-    case true: { throw new Error('Not implemented yet: true case') }
-    case 1: { throw new Error('Not implemented yet: 1 case') }
-  }
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
+    },
+    {
+      code: `
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1;
+switch (value) {
+  case 1:
+    break;
+  case Aaa.Foo:
+    break;
+  case Aaa.Bar:
+    break;
 }
       `,
-            },
-          ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
+  ],
+  invalid: [
     {
       code: `
-type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
-
-function test(value: DiscriminatedUnion): number {
-  switch (value.type) {
-    case 'A':
-      return 1;
-  }
+declare const value: 'literal';
+switch (value) {
 }
       `,
       errors: [
         {
-          column: 11,
-          data: {
-            missingBranches: '"B"',
-          },
-          line: 5,
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
-
-function test(value: DiscriminatedUnion): number {
-  switch (value.type) {
-    case 'A':
-      return 1;
-    case "B": { throw new Error('Not implemented yet: "B" case') }
-  }
+declare const value: 'literal';
+switch (value) {
+case "literal": { throw new Error('Not implemented yet: "literal" case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      // Still complains with empty switch
       code: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-
-switch (day) {
+declare const value: 'literal' & { _brand: true };
+switch (value) {
 }
       `,
       errors: [
         {
           column: 9,
-          data: {
-            missingBranches:
-              '"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
-          },
-          line: 13,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
-          suggestions: [
-            {
-              messageId: 'addMissingCases',
-              output: `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-
-switch (day) {
-case "Monday": { throw new Error('Not implemented yet: "Monday" case') }
-case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
-case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
-case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
-case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
-case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
-case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: 'literal' & { _brand: true };
+switch (value) {
+case "literal": { throw new Error('Not implemented yet: "literal" case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
       code: `
-const a = Symbol('a');
-const b = Symbol('b');
-const c = Symbol('c');
-
-type T = typeof a | typeof b | typeof c;
-
-function test(value: T): number {
-  switch (value) {
-    case a:
-      return 1;
-  }
+declare const value: ('literal' & { _brand: true }) | 1;
+switch (value) {
+  case 'literal':
+    break;
 }
       `,
       errors: [
         {
-          column: 11,
-          data: {
-            missingBranches: 'typeof b | typeof c',
-          },
-          line: 9,
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-const a = Symbol('a');
-const b = Symbol('b');
-const c = Symbol('c');
-
-type T = typeof a | typeof b | typeof c;
-
-function test(value: T): number {
-  switch (value) {
-    case a:
-      return 1;
-    case b: { throw new Error('Not implemented yet: b case') }
-    case c: { throw new Error('Not implemented yet: c case') }
-  }
+declare const value: ('literal' & { _brand: true }) | 1;
+switch (value) {
+  case 'literal':
+    break;
+  case 1: { throw new Error('Not implemented yet: 1 case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
-    // Provides suggestions to add missing cases
     {
-      // with existing cases present
       code: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-    case 1:
-      return 1;
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-    case 1:
-      return 1;
-    case 2: { throw new Error('Not implemented yet: 2 case') }
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  case "2": { throw new Error('Not implemented yet: "2" case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: false,
+        },
+      ],
     },
     {
-      // without existing cases
       code: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-type T = 1 | 2;
-
-function test(value: T): number {
-  switch (value) {
-  case 1: { throw new Error('Not implemented yet: 1 case') }
-  case 2: { throw new Error('Not implemented yet: 2 case') }
-  }
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  case "2": { throw new Error('Not implemented yet: "2" case') }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: '1' | '2' | number;
+switch (value) {
+  case '1':
+    break;
+  default: { throw new Error('default case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      // keys include special characters
       code: `
-export enum Enum {
-  'test-test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: (string & { foo: 'bar' }) | '1';
+switch (value) {
+  case '1':
+    break;
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-export enum Enum {
-  'test-test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['test-test']: { throw new Error('Not implemented yet: Enum[\\'test-test\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
+declare const value: (string & { foo: 'bar' }) | '1';
+switch (value) {
+  case '1':
+    break;
+  default: { throw new Error('default case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      // keys include empty string
       code: `
-export enum Enum {
-  '' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+switch (value) {
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-export enum Enum {
-  '' = 'test-test',
-  'test' = 'test',
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+switch (value) {
+case undefined: { throw new Error('Not implemented yet: undefined case') }
+case null: { throw new Error('Not implemented yet: null case') }
+case "1": { throw new Error('Not implemented yet: "1" case') }
+case 1: { throw new Error('Not implemented yet: 1 case') }
 }
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['']: { throw new Error('Not implemented yet: Enum[\\'\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: (string & { foo: 'bar' }) | '1' | 1 | null | undefined;
+switch (value) {
+default: { throw new Error('default case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      // keys include number as first character
       code: `
-export enum Enum {
-  '9test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  }
+declare const value: string | number;
+switch (value) {
+  case 1:
+    break;
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-export enum Enum {
-  '9test' = 'test-test',
-  'test' = 'test',
-}
-
-function test(arg: Enum): string {
-  switch (arg) {
-  case Enum['9test']: { throw new Error('Not implemented yet: Enum[\\'9test\\'] case') }
-  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
-  }
+declare const value: string | number;
+switch (value) {
+  case 1:
+    break;
+  default: { throw new Error('default case') }
 }
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
       code: `
-const value: number = Math.floor(Math.random() * 3);
+declare const value: number;
+declare const a: number;
 switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
+  case a:
+    break;
 }
       `,
       errors: [
         {
+          column: 9,
+          line: 4,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-const value: number = Math.floor(Math.random() * 3);
+declare const value: number;
+declare const a: number;
 switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
+  case a:
+    break;
   default: { throw new Error('default case') }
 }
       `,
@@ -1287,175 +1149,183 @@ switch (value) {
       ],
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-        enum Enum {
-          'a' = 1,
-          [\`key-with
-
-          new-line\`] = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        }
+declare const value: bigint;
+switch (value) {
+  case 10n:
+    break;
+}
       `,
       errors: [
         {
+          column: 9,
+          line: 3,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-        enum Enum {
-          'a' = 1,
-          [\`key-with
-
-          new-line\`] = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
-        case Enum['key-with\\n\\n          new-line']: { throw new Error('Not implemented yet: Enum[\\'key-with\\\\n\\\\n          new-line\\'] case') }
-        }
+declare const value: bigint;
+switch (value) {
+  case 10n:
+    break;
+  default: { throw new Error('default case') }
+}
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      code: noFormat`
-        enum Enum {
-          'a' = 1,
-          "'a' \`b\` \\"c\\"" = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {}
+      code: `
+declare const value: symbol;
+const a = Symbol('a');
+switch (value) {
+  case a:
+    break;
+}
       `,
       errors: [
         {
+          column: 9,
+          line: 4,
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
               output: `
-        enum Enum {
-          'a' = 1,
-          "'a' \`b\` \\"c\\"" = 2,
-        }
-
-        declare const a: Enum;
-
-        switch (a) {
-        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
-        case Enum['\\'a\\' \`b\` "c"']: { throw new Error('Not implemented yet: Enum[\\'\\\\\\'a\\\\\\' \`b\` "c"\\'] case') }
-        }
+declare const value: symbol;
+const a = Symbol('a');
+switch (value) {
+  case a:
+    break;
+  default: { throw new Error('default case') }
+}
       `,
             },
           ],
         },
       ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: true,
+        },
+      ],
     },
     {
-      // superfluous switch with a string-based union
       code: `
-type MyUnion = 'foo' | 'bar' | 'baz';
-
-declare const myUnion: MyUnion;
-
-switch (myUnion) {
-  case 'foo':
-  case 'bar':
-  case 'baz': {
-    break;
-  }
-  default: {
+const a = Symbol('aa');
+const b = Symbol('bb');
+declare const value: typeof a | typeof b | 1;
+switch (value) {
+  case 1:
     break;
-  }
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
+          column: 9,
+          line: 5,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const a = Symbol('aa');
+const b = Symbol('bb');
+declare const value: typeof a | typeof b | 1;
+switch (value) {
+  case 1:
+    break;
+  case a: { throw new Error('Not implemented yet: a case') }
+  case b: { throw new Error('Not implemented yet: b case') }
+}
+      `,
+            },
+          ],
         },
       ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with a string-based enum
       code: `
-enum MyEnum {
-  Foo = 'Foo',
-  Bar = 'Bar',
-  Baz = 'Baz',
-}
-
-declare const myEnum: MyEnum;
-
-switch (myEnum) {
-  case MyEnum.Foo:
-  case MyEnum.Bar:
-  case MyEnum.Baz: {
-    break;
-  }
-  default: {
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  case a:
     break;
-  }
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
+          column: 9,
+          line: 4,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const a = Symbol('a');
+declare const value: typeof a | string;
+switch (value) {
+  case a:
+    break;
+  default: { throw new Error('default case') }
+}
+      `,
+            },
+          ],
         },
       ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with a number-based enum
       code: `
-enum MyEnum {
-  Foo,
-  Bar,
-  Baz,
-}
-
-declare const myEnum: MyEnum;
-
-switch (myEnum) {
-  case MyEnum.Foo:
-  case MyEnum.Bar:
-  case MyEnum.Baz: {
-    break;
-  }
-  default: {
-    break;
-  }
+declare const value: boolean;
+switch (value) {
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean;
+switch (value) {
+case false: { throw new Error('Not implemented yet: false case') }
+case true: { throw new Error('Not implemented yet: true case') }
+}
+      `,
+            },
+          ],
         },
       ],
       options: [
@@ -1466,248 +1336,204 @@ switch (myEnum) {
       ],
     },
     {
-      // superfluous switch with a boolean
       code: `
-declare const myBoolean: boolean;
-
-switch (myBoolean) {
-  case true:
-  case false: {
+declare const value: boolean | 1;
+switch (value) {
+  case false:
     break;
-  }
-  default: {
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | 1;
+switch (value) {
+  case false:
     break;
-  }
+  case true: { throw new Error('Not implemented yet: true case') }
+  case 1: { throw new Error('Not implemented yet: 1 case') }
 }
       `,
-      errors: [
-        {
-          messageId: 'dangerousDefaultCase',
+            },
+          ],
         },
       ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with undefined
       code: `
-declare const myValue: undefined;
-
-switch (myValue) {
-  case undefined: {
-    break;
-  }
-
-  default: {
+declare const value: boolean | number;
+switch (value) {
+  case 1:
     break;
-  }
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | number;
+switch (value) {
+  case 1:
+    break;
+  case false: { throw new Error('Not implemented yet: false case') }
+  case true: { throw new Error('Not implemented yet: true case') }
+}
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: boolean | number;
+switch (value) {
+  case 1:
+    break;
+  default: { throw new Error('default case') }
+}
+      `,
+            },
+          ],
         },
       ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with null
       code: `
-declare const myValue: null;
-
-switch (myValue) {
-  case null: {
-    break;
-  }
-
-  default: {
+declare const value: object;
+switch (value) {
+  case 1:
     break;
-  }
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
+          column: 9,
+          line: 3,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+declare const value: object;
+switch (value) {
+  case 1:
+    break;
+  default: { throw new Error('default case') }
+}
+      `,
+            },
+          ],
         },
       ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
-      // superfluous switch with union of various types
       code: `
-declare const myValue: 'foo' | boolean | undefined | null;
-
-switch (myValue) {
-  case 'foo':
-  case true:
-  case false:
-  case undefined:
-  case null: {
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1 | string;
+switch (value) {
+  case 1:
     break;
-  }
-
-  default: {
+  case Aaa.Foo:
     break;
-  }
 }
       `,
       errors: [
         {
-          messageId: 'dangerousDefaultCase',
-        },
-      ],
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-  ],
-  valid: [
-    // All branches matched
-    `
-type Day =
-  | 'Monday'
-  | 'Tuesday'
-  | 'Wednesday'
-  | 'Thursday'
-  | 'Friday'
-  | 'Saturday'
-  | 'Sunday';
-
-const day = 'Monday' as Day;
-let result = 0;
-
-switch (day) {
-  case 'Monday': {
-    result = 1;
-    break;
-  }
-  case 'Tuesday': {
-    result = 2;
-    break;
-  }
-  case 'Wednesday': {
-    result = 3;
-    break;
-  }
-  case 'Thursday': {
-    result = 4;
-    break;
-  }
-  case 'Friday': {
-    result = 5;
-    break;
-  }
-  case 'Saturday': {
-    result = 6;
+          column: 9,
+          line: 7,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+enum Aaa {
+  Foo,
+  Bar,
+}
+declare const value: Aaa | 1 | string;
+switch (value) {
+  case 1:
     break;
-  }
-  case 'Sunday': {
-    result = 7;
+  case Aaa.Foo:
     break;
-  }
-}
-    `,
-    // Other primitive literals work too
-    `
-type Num = 0 | 1 | 2;
-
-function test(value: Num): number {
-  switch (value) {
-    case 0:
-      return 0;
-    case 1:
-      return 1;
-    case 2:
-      return 2;
-  }
-}
-    `,
-    `
-type Bool = true | false;
-
-function test(value: Bool): number {
-  switch (value) {
-    case true:
-      return 1;
-    case false:
-      return 0;
-  }
-}
-    `,
-    `
-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 Aaa.Bar: { throw new Error('Not implemented yet: Aaa.Bar case') }
 }
-    `,
-    // Works with type references
-    `
-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;
-  }
+      `,
+            },
+          ],
+        },
+        {
+          column: 9,
+          line: 7,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+enum Aaa {
+  Foo,
+  Bar,
 }
-    `,
-    // Works with `typeof`
-    `
-const A = 'a';
-const B = 1;
-const C = true;
-
-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;
-  }
+declare const value: Aaa | 1 | string;
+switch (value) {
+  case 1:
+    break;
+  case Aaa.Foo:
+    break;
+  default: { throw new Error('default case') }
 }
-    `,
-    // Switch contains default clause.
-    `
+      `,
+            },
+          ],
+        },
+      ],
+      options: [
+        {
+          allowDefaultCaseForExhaustiveSwitch: true,
+          requireDefaultForNonUnion: true,
+        },
+      ],
+    },
+    {
+      // Matched only one branch out of seven.
+      code: `
 type Day =
   | 'Monday'
   | 'Tuesday'
@@ -1725,14 +1551,31 @@ switch (day) {
     result = 1;
     break;
   }
-  default: {
-    result = 42;
-  }
 }
-    `,
-    // Exhaustiveness check only works for union types...
-    `
-const day = 'Monday' as string;
+      `,
+      errors: [
+        {
+          column: 9,
+          data: {
+            missingBranches:
+              '"Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
+          },
+          line: 14,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
 let result = 0;
 
 switch (day) {
@@ -1740,14 +1583,22 @@ switch (day) {
     result = 1;
     break;
   }
-  case 'Tuesday': {
-    result = 2;
-    break;
-  }
+  case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
+  case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
+  case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
+  case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
+  case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
+  case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
 }
-    `,
-    // ... and enums (at least for now).
-    `
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      // Didn't match all enum variants
+      code: `
 enum Enum {
   A,
   B,
@@ -1757,427 +1608,618 @@ function test(value: Enum): number {
   switch (value) {
     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 };
-
-function test(value: ObjectUnion): number {
-  switch (value.a) {
-    case 1:
-      return 1;
   }
-}
-    `,
-    // switch with default clause on non-union type
-    {
-      code: `
-declare const value: number;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    // switch with default clause on string type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: string;
-switch (value) {
-  case 'foo':
-    return 0;
-  case 'bar':
-    return 1;
-  default:
-    return -1;
+          column: 11,
+          data: {
+            missingBranches: 'Enum.B',
+          },
+          line: 8,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+enum Enum {
+  A,
+  B,
 }
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on number type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: number;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
+
+function test(value: Enum): number {
+  switch (value) {
+    case Enum.A:
+      return 1;
+    case Enum.B: { throw new Error('Not implemented yet: Enum.B case') }
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+            },
+          ],
         },
       ],
     },
-    // switch with default clause on bigint type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: bigint;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
+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;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    // switch with default clause on symbol type +
-    // "allowDefaultCaseForExhaustiveSwitch" option
-    {
-      code: `
-declare const value: symbol;
-const foo = Symbol('foo');
-switch (value) {
-  case foo:
-    return 0;
-  default:
-    return -1;
+          column: 11,
+          data: {
+            missingBranches: '"b" | "c"',
+          },
+          line: 8,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+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": { throw new Error('Not implemented yet: "b" case') }
+    case "c": { throw new Error('Not implemented yet: "c" case') }
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+            },
+          ],
         },
       ],
     },
-    // switch with default clause on union with number +
-    // "allowDefaultCaseForExhaustiveSwitch" option
     {
       code: `
-declare const value: 0 | 1 | number;
-switch (value) {
-  case 0:
-    return 0;
-  case 1:
-    return 1;
-  default:
-    return -1;
+const A = 'a';
+const B = 1;
+const C = true;
+
+type Union = typeof A | typeof B | typeof C;
+
+function test(value: Union): number {
+  switch (value) {
+    case 'a':
+      return 1;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          column: 11,
+          data: {
+            missingBranches: 'true | 1',
+          },
+          line: 9,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const A = 'a';
+const B = 1;
+const C = true;
+
+type Union = typeof A | typeof B | typeof C;
+
+function test(value: Union): number {
+  switch (value) {
+    case 'a':
+      return 1;
+    case true: { throw new Error('Not implemented yet: true case') }
+    case 1: { throw new Error('Not implemented yet: 1 case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
       code: `
-declare const value: 'literal';
-switch (value) {
-  case 'literal':
-    return 0;
+type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
+
+function test(value: DiscriminatedUnion): number {
+  switch (value.type) {
+    case 'A':
+      return 1;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          column: 11,
+          data: {
+            missingBranches: '"B"',
+          },
+          line: 5,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
+
+function test(value: DiscriminatedUnion): number {
+  switch (value.type) {
+    case 'A':
+      return 1;
+    case "B": { throw new Error('Not implemented yet: "B" case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
+      // Still complains with empty switch
       code: `
-declare const value: null;
-switch (value) {
-  case null:
-    return 0;
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+
+switch (day) {
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          column: 9,
+          data: {
+            missingBranches:
+              '"Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"',
+          },
+          line: 13,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+
+switch (day) {
+case "Monday": { throw new Error('Not implemented yet: "Monday" case') }
+case "Tuesday": { throw new Error('Not implemented yet: "Tuesday" case') }
+case "Wednesday": { throw new Error('Not implemented yet: "Wednesday" case') }
+case "Thursday": { throw new Error('Not implemented yet: "Thursday" case') }
+case "Friday": { throw new Error('Not implemented yet: "Friday" case') }
+case "Saturday": { throw new Error('Not implemented yet: "Saturday" case') }
+case "Sunday": { throw new Error('Not implemented yet: "Sunday" case') }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
       code: `
-declare const value: undefined;
-switch (value) {
-  case undefined:
-    return 0;
+const a = Symbol('a');
+const b = Symbol('b');
+const c = Symbol('c');
+
+type T = typeof a | typeof b | typeof c;
+
+function test(value: T): number {
+  switch (value) {
+    case a:
+      return 1;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          column: 11,
+          data: {
+            missingBranches: 'typeof b | typeof c',
+          },
+          line: 9,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const a = Symbol('a');
+const b = Symbol('b');
+const c = Symbol('c');
+
+type T = typeof a | typeof b | typeof c;
+
+function test(value: T): number {
+  switch (value) {
+    case a:
+      return 1;
+    case b: { throw new Error('Not implemented yet: b case') }
+    case c: { throw new Error('Not implemented yet: c case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
+    // Provides suggestions to add missing cases
     {
+      // with existing cases present
       code: `
-declare const value: null | undefined;
-switch (value) {
-  case null:
-    return 0;
-  case undefined:
-    return 0;
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+    case 1:
+      return 1;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+    case 1:
+      return 1;
+    case 2: { throw new Error('Not implemented yet: 2 case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
+      // without existing cases
       code: `
-declare const value: 'literal' & { _brand: true };
-switch (value) {
-  case 'literal':
-    break;
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: ('literal' & { _brand: true }) | 1;
-switch (value) {
-  case 'literal':
-    break;
-  case 1:
-    break;
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+type T = 1 | 2;
+
+function test(value: T): number {
+  switch (value) {
+  case 1: { throw new Error('Not implemented yet: 1 case') }
+  case 2: { throw new Error('Not implemented yet: 2 case') }
+  }
 }
       `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+            },
+          ],
         },
       ],
     },
     {
+      // keys include special characters
       code: `
-declare const value: (1 & { _brand: true }) | 'literal' | null;
-switch (value) {
-  case 'literal':
-    break;
-  case 1:
-    break;
-  case null:
-    break;
+export enum Enum {
+  'test-test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+export enum Enum {
+  'test-test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['test-test']: { throw new Error('Not implemented yet: Enum[\\'test-test\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
+      // keys include empty string
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
+export enum Enum {
+  '' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+export enum Enum {
+  '' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['']: { throw new Error('Not implemented yet: Enum[\\'\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
+      // keys include number as first character
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
-  default:
-    break;
+export enum Enum {
+  '9test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+export enum Enum {
+  '9test' = 'test-test',
+  'test' = 'test',
+}
+
+function test(arg: Enum): string {
+  switch (arg) {
+  case Enum['9test']: { throw new Error('Not implemented yet: Enum[\\'9test\\'] case') }
+  case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
+  }
+}
+      `,
+            },
+          ],
         },
       ],
     },
     {
       code: `
-declare const value: '1' | '2' | number;
+const value: number = Math.floor(Math.random() * 3);
 switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
-  default:
-    break;
+  case 0:
+    return 0;
+  case 1:
+    return 1;
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: '1' | '2' | (number & { foo: 'bar' });
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+const value: number = Math.floor(Math.random() * 3);
 switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
-  default:
-    break;
+  case 0:
+    return 0;
+  case 1:
+    return 1;
+  default: { throw new Error('default case') }
 }
       `,
+            },
+          ],
+        },
+      ],
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          requireDefaultForNonUnion: true,
         },
       ],
     },
     {
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
-    break;
-  case '2':
-    break;
-  default:
-    break;
-}
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
+        case Enum['key-with\\n\\n          new-line']: { throw new Error('Not implemented yet: Enum[\\'key-with\\\\n\\\\n          new-line\\'] case') }
+        }
+      `,
+            },
+          ],
         },
       ],
     },
     {
-      code: `
-declare const value: number | null | undefined;
-switch (value) {
-  case null:
-    break;
-  case undefined:
-    break;
-}
+      code: noFormat`
+        enum Enum {
+          'a' = 1,
+          "'a' \`b\` \\"c\\"" = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {}
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+        enum Enum {
+          'a' = 1,
+          "'a' \`b\` \\"c\\"" = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
+        case Enum['\\'a\\' \`b\` "c"']: { throw new Error('Not implemented yet: Enum[\\'\\\\\\'a\\\\\\' \`b\` "c"\\'] case') }
+        }
+      `,
+            },
+          ],
         },
       ],
     },
     {
+      // superfluous switch with a string-based union
       code: `
-declare const value: '1' | '2' | number;
-switch (value) {
-  case '1':
+type MyUnion = 'foo' | 'bar' | 'baz';
+
+declare const myUnion: MyUnion;
+
+switch (myUnion) {
+  case 'foo':
+  case 'bar':
+  case 'baz': {
     break;
-  default:
+  }
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: false,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-declare const value: (string & { foo: 'bar' }) | '1';
-switch (value) {
-  case '1':
-    break;
-}
-      `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with a string-based enum
       code: `
-const a = Symbol('a');
-declare const value: typeof a | 2;
-switch (value) {
-  case a:
+enum MyEnum {
+  Foo = 'Foo',
+  Bar = 'Bar',
+  Baz = 'Baz',
+}
+
+declare const myEnum: MyEnum;
+
+switch (myEnum) {
+  case MyEnum.Foo:
+  case MyEnum.Bar:
+  case MyEnum.Baz: {
     break;
-  case 2:
+  }
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-declare const value: string | number;
-switch (value) {
-  case 1:
-    break;
-}
-      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -2186,42 +2228,32 @@ switch (value) {
       ],
     },
     {
+      // superfluous switch with a number-based enum
       code: `
-declare const value: string | number;
-switch (value) {
+enum MyEnum {
+  Foo,
+  Bar,
+  Baz,
 }
-      `,
-      options: [
-        {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
-        },
-      ],
-    },
-    {
-      code: `
-declare const value: string | number;
-switch (value) {
-  default:
+
+declare const myEnum: MyEnum;
+
+switch (myEnum) {
+  case MyEnum.Foo:
+  case MyEnum.Bar:
+  case MyEnum.Baz: {
+    break;
+  }
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-declare const value: number;
-declare const a: number;
-switch (value) {
-  case a:
-    break;
-}
-      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
@@ -2230,145 +2262,113 @@ switch (value) {
       ],
     },
     {
+      // superfluous switch with a boolean
       code: `
-declare const value: bigint;
-switch (value) {
-  case 10n:
+declare const myBoolean: boolean;
+
+switch (myBoolean) {
+  case true:
+  case false: {
+    break;
+  }
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-declare const value: symbol;
-const a = Symbol('a');
-switch (value) {
-  case a:
-    break;
-}
-      `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with undefined
       code: `
-declare const value: symbol;
-const a = Symbol('a');
-switch (value) {
-  case a:
+declare const myValue: undefined;
+
+switch (myValue) {
+  case undefined: {
     break;
-  default:
+  }
+
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
-switch (value) {
-  case a:
-    break;
-  default:
-    break;
-}
-      `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with null
       code: `
-const a = Symbol('a');
-declare const value: typeof a | string;
-switch (value) {
-  default:
+declare const myValue: null;
+
+switch (myValue) {
+  case null: {
     break;
+  }
+
+  default: {
+    break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: true,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-declare const value: boolean | 1;
-switch (value) {
-  case 1:
-    break;
-  default:
-    break;
-}
-      `,
       options: [
         {
           allowDefaultCaseForExhaustiveSwitch: false,
-          requireDefaultForNonUnion: true,
+          requireDefaultForNonUnion: false,
         },
       ],
     },
     {
+      // superfluous switch with union of various types
       code: `
-declare const value: boolean | 1;
-switch (value) {
-  case 1:
-    break;
+declare const myValue: 'foo' | boolean | undefined | null;
+
+switch (myValue) {
+  case 'foo':
   case true:
-    break;
   case false:
+  case undefined:
+  case null: {
     break;
-  default:
+  }
+
+  default: {
     break;
+  }
 }
       `,
-      options: [
+      errors: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
-          requireDefaultForNonUnion: false,
+          messageId: 'dangerousDefaultCase',
         },
       ],
-    },
-    {
-      code: `
-enum Aaa {
-  Foo,
-  Bar,
-}
-declare const value: Aaa | 1;
-switch (value) {
-  case 1:
-    break;
-  case Aaa.Foo:
-    break;
-  case Aaa.Bar:
-    break;
-}
-      `,
       options: [
         {
-          allowDefaultCaseForExhaustiveSwitch: true,
+          allowDefaultCaseForExhaustiveSwitch: false,
           requireDefaultForNonUnion: false,
         },
       ],
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 c0f2df7e22fc..1a35be9fb8da 100644
--- a/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
+++ b/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
@@ -5,69 +5,6 @@ import rule from '../../src/rules/triple-slash-reference';
 const ruleTester = new RuleTester();
 
 ruleTester.run('triple-slash-reference', rule, {
-  invalid: [
-    {
-      code: `
-/// <reference types="foo" />
-import * as foo from 'foo';
-      `,
-      errors: [
-        {
-          column: 1,
-          line: 2,
-          messageId: 'tripleSlashReference',
-        },
-      ],
-      options: [{ types: 'prefer-import' }],
-    },
-    {
-      code: `
-/// <reference types="foo" />
-import foo = require('foo');
-      `,
-      errors: [
-        {
-          column: 1,
-          line: 2,
-          messageId: 'tripleSlashReference',
-        },
-      ],
-      options: [{ types: 'prefer-import' }],
-    },
-    {
-      code: '/// <reference path="foo" />',
-      errors: [
-        {
-          column: 1,
-          line: 1,
-          messageId: 'tripleSlashReference',
-        },
-      ],
-      options: [{ path: 'never' }],
-    },
-    {
-      code: '/// <reference types="foo" />',
-      errors: [
-        {
-          column: 1,
-          line: 1,
-          messageId: 'tripleSlashReference',
-        },
-      ],
-      options: [{ types: 'never' }],
-    },
-    {
-      code: '/// <reference lib="foo" />',
-      errors: [
-        {
-          column: 1,
-          line: 1,
-          messageId: 'tripleSlashReference',
-        },
-      ],
-      options: [{ lib: 'never' }],
-    },
-  ],
   valid: [
     {
       code: `
@@ -184,4 +121,67 @@ import foo = require('foo');
       options: [{ lib: 'never', path: 'never', types: 'never' }],
     },
   ],
+  invalid: [
+    {
+      code: `
+/// <reference types="foo" />
+import * as foo from 'foo';
+      `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'prefer-import' }],
+    },
+    {
+      code: `
+/// <reference types="foo" />
+import foo = require('foo');
+      `,
+      errors: [
+        {
+          column: 1,
+          line: 2,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'prefer-import' }],
+    },
+    {
+      code: '/// <reference path="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ path: 'never' }],
+    },
+    {
+      code: '/// <reference types="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ types: 'never' }],
+    },
+    {
+      code: '/// <reference lib="foo" />',
+      errors: [
+        {
+          column: 1,
+          line: 1,
+          messageId: 'tripleSlashReference',
+        },
+      ],
+      options: [{ lib: 'never' }],
+    },
+  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/typedef.test.ts b/packages/eslint-plugin/tests/rules/typedef.test.ts
index bd203d7876a7..d9a246698b57 100644
--- a/packages/eslint-plugin/tests/rules/typedef.test.ts
+++ b/packages/eslint-plugin/tests/rules/typedef.test.ts
@@ -14,15 +14,10 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('typedef', rule, {
-  invalid: [
+  valid: [
     // Array destructuring
     {
-      code: 'const [a] = [1];',
-      errors: [
-        {
-          messageId: 'expectedTypedef',
-        },
-      ],
+      code: 'function foo(...[a]: string[]) {}',
       options: [
         {
           arrayDestructuring: true,
@@ -30,371 +25,328 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: 'const [a, b] = [1, 2];',
-      errors: [
+      code: 'const foo = (...[a]: string[]) => {};',
+      options: [
         {
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const [a]: [number] = [1];',
       options: [
         {
           arrayDestructuring: true,
         },
       ],
     },
-    // Object destructuring
     {
-      code: 'const { a } = { a: 1 };',
-      errors: [
+      code: 'const [a, b]: [number, number] = [1, 2];',
+      options: [
         {
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: '[a] = [1];',
       options: [
         {
-          objectDestructuring: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
-      code: 'const { a, b } = { a: 1, b: 2 };',
-      errors: [
+      code: 'b = [a] = [1];',
+      options: [
         {
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const [b]: [number] = ([a] = [1]);',
       options: [
         {
-          objectDestructuring: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
-      code: `
-        const {
-          id,
-          details: {
-            name: {
-              first,
-              middle,
-              last,
-              forTest: { moreNested },
-            },
-          },
-        } = getUser();
-      `,
-      errors: [
-        {
-          data: { name: 'first' },
-          messageId: 'expectedTypedef',
-        },
-        {
-          data: { name: 'middle' },
-          messageId: 'expectedTypedef',
-        },
-        {
-          data: { name: 'last' },
-          messageId: 'expectedTypedef',
-        },
+      code: 'const [[a]]: number[][] = [[1]];',
+      options: [
         {
-          data: { name: 'moreNested' },
-          messageId: 'expectedTypedef',
+          arrayDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const foo = ([{ bar }]: { bar: string }[]) => {};',
       options: [
         {
+          arrayDestructuring: true,
           objectDestructuring: true,
         },
       ],
     },
-    // Arrow parameters
     {
-      code: 'const receivesNumber = (a): void => {};',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: 'const foo = ([{ bar }]: [{ bar: string }]) => {};',
       options: [
         {
-          arrowParameter: true,
+          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'const receivesStrings = (a, b): void => {};',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-        {
-          data: { name: 'b' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: 'const [a] = [1];',
       options: [
         {
-          arrowParameter: true,
+          arrayDestructuring: false,
         },
       ],
     },
-    // Member variable declarations
     {
       code: `
-        class Test {
-          state = 1;
+        for (const [key, val] of new Map([['key', 1]])) {
         }
       `,
-      errors: [
-        {
-          data: { name: 'state' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
-          memberVariableDeclaration: true,
+          arrayDestructuring: true,
         },
       ],
     },
     {
       code: `
-        class Test {
-          ['state'] = 1;
+        for (const [[key]] of [[['key']]]) {
         }
       `,
-      errors: [
-        {
-          messageId: 'expectedTypedef',
-        },
-      ],
       options: [
         {
-          memberVariableDeclaration: true,
+          arrayDestructuring: true,
         },
       ],
     },
-    // Function parameters
     {
-      code: 'function receivesNumber(a): void {}',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: `
+        for (const [[{ key }]] of [[[{ key: 'value' }]]]) {
+        }
+      `,
       options: [
         {
-          parameter: true,
+          arrayDestructuring: true,
         },
       ],
     },
+    `
+      let a: number;
+      [a] = [1];
+    `,
+    // Arrow parameters
+    '((a: number): void => {})();',
+    '((a: string, b: string): void => {})();',
     {
-      code: 'function receivesStrings(a, b): void {}',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-        {
-          data: { name: 'b' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: '((a: number): void => {})();',
       options: [
         {
-          parameter: true,
+          arrowParameter: false,
         },
       ],
     },
     {
-      code: 'function receivesNumber([a]): void {}',
-      errors: [
-        {
-          column: 25,
-          messageId: 'expectedTypedef',
-        },
-      ],
+      code: '((a: string, b: string): void => {})();',
       options: [
         {
-          parameter: true,
+          arrowParameter: false,
         },
       ],
     },
+    // Member variable declarations
+    `
+      class Test {
+        state: number;
+      }
+    `,
+    `
+      class Test {
+        state: number = 1;
+      }
+    `,
     {
-      code: 'function receivesNumbers([a, b]): void {}',
-      errors: [
-        {
-          column: 26,
-          messageId: 'expectedTypedef',
-        },
-      ],
+      code: `
+        class Test {
+          state = 1;
+        }
+      `,
       options: [
         {
-          parameter: true,
+          memberVariableDeclaration: false,
         },
       ],
     },
+    // Object destructuring
     {
-      code: 'function receivesString({ a }): void {}',
-      errors: [
-        {
-          column: 25,
-          messageId: 'expectedTypedef',
-        },
-      ],
+      code: 'const { a }: { a: number } = { a: 1 };',
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'function receivesStrings({ a, b }): void {}',
-      errors: [
-        {
-          column: 26,
-          messageId: 'expectedTypedef',
-        },
-      ],
+      code: 'const { a, b }: { [i: string]: number } = { a: 1, b: 2 };',
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
-    // Constructor parameters
     {
       code: `
-        class Test {
-          constructor(param) {}
+        for (const {
+          p1: {
+            p2: { p3 },
+          },
+        } of [{ p1: { p2: { p3: 'value' } } }]) {
         }
       `,
-      errors: [
-        {
-          column: 23,
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
       code: `
-        class Test {
-          constructor(param = 'something') {}
+        for (const {
+          p1: {
+            p2: {
+              p3: [key],
+            },
+          },
+        } of [{ p1: { p2: { p3: ['value'] } } }]) {
         }
       `,
-      errors: [
+      options: [
         {
-          column: 23,
-          messageId: 'expectedTypedef',
+          objectDestructuring: true,
         },
       ],
+    },
+    {
+      code: 'const { a } = { a: 1 };',
       options: [
         {
-          parameter: true,
+          objectDestructuring: false,
         },
       ],
     },
     {
       code: `
-        class Test {
-          constructor(private param = 'something') {}
+        for (const { key, val } of [{ key: 'key', val: 1 }]) {
         }
       `,
-      errors: [
+      options: [
         {
-          column: 23,
-          messageId: 'expectedTypedef',
-        },
-      ],
-      options: [
-        {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
-    // Method parameters
     {
       code: `
-        class Test {
-          public method(x): number {
-            return x;
-          }
-        }
+        const {
+          id,
+          details: {
+            name: {
+              first,
+              middle,
+              last,
+              forTest: { moreNested },
+            },
+          },
+        }: User = getUser();
       `,
-      errors: [
-        {
-          column: 25,
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
-          parameter: true,
+          objectDestructuring: true,
         },
       ],
     },
-    {
-      code: `
-        class Test {
-          public method(x = 123): number {
-            return x;
-          }
+    // 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 {}',
+    // Constructor parameters
+    `
+      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;
         }
-      `,
-      errors: [
-        {
-          column: 25,
-          messageId: 'expectedTypedef',
-        },
-      ],
-      options: [
-        {
-          parameter: true,
-        },
-      ],
-    },
-    {
-      code: `
-        class Test {
-          public constructor(public x) {}
+      }
+    `,
+    `
+      class Test {
+        public method(x: number = 123): number {
+          return x;
         }
-      `,
-      errors: [
-        {
-          column: 30,
-          messageId: 'expectedTypedef',
-        },
-      ],
-      options: [
-        {
-          parameter: true,
-        },
-      ],
-    },
+      }
+    `,
     // Property declarations
+    `
+      type Test = {
+        member: number;
+      };
+    `,
+    `
+      type Test = {
+        [i: string]: number;
+      };
+    `,
+    `
+      interface Test {
+        member: string;
+      }
+    `,
+    `
+      interface Test {
+        [i: number]: string;
+      }
+    `,
     {
       code: `
         type Test = {
           member;
         };
       `,
-      errors: [
-        {
-          data: { name: 'member' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
-          propertyDeclaration: true,
+          propertyDeclaration: false,
         },
       ],
     },
@@ -404,111 +356,85 @@ ruleTester.run('typedef', rule, {
           [i: string];
         };
       `,
-      errors: [
-        {
-          messageId: 'expectedTypedef',
-        },
-      ],
       options: [
         {
-          propertyDeclaration: true,
+          propertyDeclaration: false,
         },
       ],
     },
+    // Variable declarations
     {
-      code: `
-        interface Test {
-          member;
-        }
-      `,
-      errors: [
-        {
-          data: { name: 'member' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: "const x: string = '';",
       options: [
         {
-          propertyDeclaration: true,
+          variableDeclaration: true,
         },
       ],
     },
     {
-      code: noFormat`
-        interface Test {
-          [i: string];
-        }
-      `,
-      errors: [
+      code: "let x: string = '';",
+      options: [
         {
-          messageId: 'expectedTypedef',
+          variableDeclaration: true,
         },
       ],
+    },
+    {
+      code: 'let x: string;',
       options: [
         {
-          propertyDeclaration: true,
+          variableDeclaration: true,
         },
       ],
     },
-    // Variable declarations
     {
       code: 'const a = 1;',
-      errors: [
+      options: [
         {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: false,
         },
       ],
+    },
+    {
+      code: 'let a;',
       options: [
         {
-          variableDeclaration: true,
+          variableDeclaration: false,
         },
       ],
     },
     {
-      code: `
-        const a = 1,
-          b: number = 2,
-          c = 3;
-      `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
+      code: 'let a = 1;',
+      options: [
         {
-          data: { name: 'c' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: false,
         },
       ],
+    },
+    {
+      code: 'const [a, b] = [1, 2];',
       options: [
         {
+          objectDestructuring: false,
           variableDeclaration: true,
         },
       ],
     },
     {
-      code: 'let a;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: "const { a, b } = { a: '', b: '' };",
       options: [
         {
+          objectDestructuring: false,
           variableDeclaration: true,
         },
       ],
     },
+    // Contexts where TypeScript doesn't allow annotations
     {
-      code: 'let a = 1;',
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: `
+        for (x of [1, 2, 3]) {
+        }
+      `,
       options: [
         {
           variableDeclaration: true,
@@ -517,20 +443,9 @@ ruleTester.run('typedef', rule, {
     },
     {
       code: `
-        let a = 1,
-          b: number,
-          c = 2;
+        for (const x in {}) {
+        }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
-        {
-          data: { name: 'c' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
       options: [
         {
           variableDeclaration: true,
@@ -538,13 +453,19 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: "const foo = 'foo';",
-      errors: [
+      code: `
+        try {
+        } catch (e) {}
+      `,
+      options: [
         {
-          data: { name: 'foo' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: true,
         },
       ],
+    },
+    // variable declaration ignore function
+    {
+      code: 'const foo = function (): void {};',
       options: [
         {
           variableDeclaration: true,
@@ -553,32 +474,29 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: 'const foo = function (): void {};',
-      errors: [
-        {
-          data: { name: 'foo' },
-          messageId: 'expectedTypedefNamed',
-        },
-      ],
+      code: 'const foo = (): void => {};',
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
     {
-      code: 'const foo = (): void => {};',
-      errors: [
+      code: 'const foo: () => void = (): void => {};',
+      options: [
         {
-          data: { name: 'foo' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
+    },
+    {
+      code: 'const foo: () => void = function (): void {};',
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
@@ -589,37 +507,41 @@ class Foo {
   b = function (): void {};
 }
       `,
-      errors: [
-        {
-          data: { name: 'a' },
-          messageId: 'expectedTypedefNamed',
-        },
+      options: [
         {
-          data: { name: 'b' },
-          messageId: 'expectedTypedefNamed',
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: true,
         },
       ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/4033
+    {
+      code: `
+class ClassName {
+  public str: string = 'str';
+  #num: number = 13;
+
+  func: () => void = (): void => {
+    console.log(this.str);
+  };
+}
+      `,
       options: [
         {
           memberVariableDeclaration: true,
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
   ],
-  valid: [
+  invalid: [
     // Array destructuring
     {
-      code: 'function foo(...[a]: string[]) {}',
-      options: [
+      code: 'const [a] = [1];',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const foo = (...[a]: string[]) => {};',
       options: [
         {
           arrayDestructuring: true,
@@ -627,408 +549,457 @@ class Foo {
       ],
     },
     {
-      code: 'const [a]: [number] = [1];',
-      options: [
+      code: 'const [a, b] = [1, 2];',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const [a, b]: [number, number] = [1, 2];',
       options: [
         {
           arrayDestructuring: true,
         },
       ],
     },
+    // Object destructuring
     {
-      code: '[a] = [1];',
-      options: [
+      code: 'const { a } = { a: 1 };',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'b = [a] = [1];',
       options: [
         {
-          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'const [b]: [number] = ([a] = [1]);',
-      options: [
+      code: 'const { a, b } = { a: 1, b: 2 };',
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const [[a]]: number[][] = [[1]];',
       options: [
         {
-          arrayDestructuring: true,
+          objectDestructuring: true,
         },
       ],
     },
     {
-      code: 'const foo = ([{ bar }]: { bar: string }[]) => {};',
-      options: [
+      code: `
+        const {
+          id,
+          details: {
+            name: {
+              first,
+              middle,
+              last,
+              forTest: { moreNested },
+            },
+          },
+        } = getUser();
+      `,
+      errors: [
         {
-          arrayDestructuring: true,
-          objectDestructuring: true,
+          data: { name: 'first' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'middle' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'last' },
+          messageId: 'expectedTypedef',
+        },
+        {
+          data: { name: 'moreNested' },
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    {
-      code: 'const foo = ([{ bar }]: [{ bar: string }]) => {};',
       options: [
         {
-          arrayDestructuring: true,
           objectDestructuring: true,
         },
       ],
     },
+    // Arrow parameters
     {
-      code: 'const [a] = [1];',
+      code: 'const receivesNumber = (a): void => {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: false,
+          arrowParameter: true,
         },
       ],
     },
     {
-      code: `
-        for (const [key, val] of new Map([['key', 1]])) {
-        }
-      `,
+      code: 'const receivesStrings = (a, b): void => {};',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
+          arrowParameter: true,
         },
       ],
     },
+    // Member variable declarations
     {
       code: `
-        for (const [[key]] of [[['key']]]) {
+        class Test {
+          state = 1;
         }
       `,
+      errors: [
+        {
+          data: { name: 'state' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          arrayDestructuring: true,
+          memberVariableDeclaration: true,
         },
       ],
     },
     {
       code: `
-        for (const [[{ key }]] of [[[{ key: 'value' }]]]) {
+        class Test {
+          ['state'] = 1;
         }
       `,
-      options: [
+      errors: [
         {
-          arrayDestructuring: true,
+          messageId: 'expectedTypedef',
         },
       ],
-    },
-    `
-      let a: number;
-      [a] = [1];
-    `,
-    // Arrow parameters
-    '((a: number): void => {})();',
-    '((a: string, b: string): void => {})();',
-    {
-      code: '((a: number): void => {})();',
       options: [
         {
-          arrowParameter: false,
+          memberVariableDeclaration: true,
         },
       ],
     },
+    // Function parameters
     {
-      code: '((a: string, b: string): void => {})();',
-      options: [
+      code: 'function receivesNumber(a): void {}',
+      errors: [
         {
-          arrowParameter: false,
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    // Member variable declarations
-    `
-      class Test {
-        state: number;
-      }
-    `,
-    `
-      class Test {
-        state: number = 1;
-      }
-    `,
-    {
-      code: `
-        class Test {
-          state = 1;
-        }
-      `,
       options: [
         {
-          memberVariableDeclaration: false,
+          parameter: true,
         },
       ],
     },
-    // Object destructuring
     {
-      code: 'const { a }: { a: number } = { a: 1 };',
-      options: [
+      code: 'function receivesStrings(a, b): void {}',
+      errors: [
         {
-          objectDestructuring: true,
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    {
-      code: 'const { a, b }: { [i: string]: number } = { a: 1, b: 2 };',
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: `
-        for (const {
-          p1: {
-            p2: { p3 },
-          },
-        } of [{ p1: { p2: { p3: 'value' } } }]) {
-        }
-      `,
+      code: 'function receivesNumber([a]): void {}',
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: `
-        for (const {
-          p1: {
-            p2: {
-              p3: [key],
-            },
-          },
-        } of [{ p1: { p2: { p3: ['value'] } } }]) {
-        }
-      `,
+      code: 'function receivesNumbers([a, b]): void {}',
+      errors: [
+        {
+          column: 26,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: 'const { a } = { a: 1 };',
+      code: 'function receivesString({ a }): void {}',
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: false,
+          parameter: true,
         },
       ],
     },
     {
-      code: `
-        for (const { key, val } of [{ key: 'key', val: 1 }]) {
-        }
-      `,
+      code: 'function receivesStrings({ a, b }): void {}',
+      errors: [
+        {
+          column: 26,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: true,
+          parameter: true,
         },
       ],
     },
+    // Constructor parameters
     {
       code: `
-        const {
-          id,
-          details: {
-            name: {
-              first,
-              middle,
-              last,
-              forTest: { moreNested },
-            },
-          },
-        }: User = getUser();
+        class Test {
+          constructor(param) {}
+        }
       `,
-      options: [
+      errors: [
         {
-          objectDestructuring: true,
+          column: 23,
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    // 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 {}',
-    // Constructor parameters
-    `
-      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;
-        }
-      }
-    `,
-    // Property declarations
-    `
-      type Test = {
-        member: number;
-      };
-    `,
-    `
-      type Test = {
-        [i: string]: number;
-      };
-    `,
-    `
-      interface Test {
-        member: string;
-      }
-    `,
-    `
-      interface Test {
-        [i: number]: string;
-      }
-    `,
+      options: [
+        {
+          parameter: true,
+        },
+      ],
+    },
     {
       code: `
-        type Test = {
-          member;
-        };
+        class Test {
+          constructor(param = 'something') {}
+        }
       `,
+      errors: [
+        {
+          column: 23,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          propertyDeclaration: false,
+          parameter: true,
         },
       ],
     },
     {
-      code: noFormat`
-        type Test = {
-          [i: string];
-        };
+      code: `
+        class Test {
+          constructor(private param = 'something') {}
+        }
       `,
+      errors: [
+        {
+          column: 23,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          propertyDeclaration: false,
+          parameter: true,
         },
       ],
     },
-    // Variable declarations
+    // Method parameters
     {
-      code: "const x: string = '';",
+      code: `
+        class Test {
+          public method(x): number {
+            return x;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          variableDeclaration: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: "let x: string = '';",
+      code: `
+        class Test {
+          public method(x = 123): number {
+            return x;
+          }
+        }
+      `,
+      errors: [
+        {
+          column: 25,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          variableDeclaration: true,
+          parameter: true,
         },
       ],
     },
     {
-      code: 'let x: string;',
+      code: `
+        class Test {
+          public constructor(public x) {}
+        }
+      `,
+      errors: [
+        {
+          column: 30,
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          variableDeclaration: true,
+          parameter: true,
         },
       ],
     },
+    // Property declarations
     {
-      code: 'const a = 1;',
+      code: `
+        type Test = {
+          member;
+        };
+      `,
+      errors: [
+        {
+          data: { name: 'member' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          variableDeclaration: false,
+          propertyDeclaration: true,
         },
       ],
     },
     {
-      code: 'let a;',
+      code: noFormat`
+        type Test = {
+          [i: string];
+        };
+      `,
+      errors: [
+        {
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          variableDeclaration: false,
+          propertyDeclaration: true,
         },
       ],
     },
     {
-      code: 'let a = 1;',
+      code: `
+        interface Test {
+          member;
+        }
+      `,
+      errors: [
+        {
+          data: { name: 'member' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          variableDeclaration: false,
+          propertyDeclaration: true,
         },
       ],
     },
     {
-      code: 'const [a, b] = [1, 2];',
+      code: noFormat`
+        interface Test {
+          [i: string];
+        }
+      `,
+      errors: [
+        {
+          messageId: 'expectedTypedef',
+        },
+      ],
       options: [
         {
-          objectDestructuring: false,
-          variableDeclaration: true,
+          propertyDeclaration: true,
         },
       ],
     },
+    // Variable declarations
     {
-      code: "const { a, b } = { a: '', b: '' };",
+      code: 'const a = 1;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
-          objectDestructuring: false,
           variableDeclaration: true,
         },
       ],
     },
-    // Contexts where TypeScript doesn't allow annotations
     {
       code: `
-        for (x of [1, 2, 3]) {
-        }
+        const a = 1,
+          b: number = 2,
+          c = 3;
       `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'c' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
@@ -1036,10 +1007,13 @@ class Foo {
       ],
     },
     {
-      code: `
-        for (const x in {}) {
-        }
-      `,
+      code: 'let a;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
@@ -1047,28 +1021,49 @@ class Foo {
       ],
     },
     {
-      code: `
-        try {
-        } catch (e) {}
-      `,
+      code: 'let a = 1;',
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
         },
       ],
     },
-    // variable declaration ignore function
     {
-      code: 'const foo = function (): void {};',
+      code: `
+        let a = 1,
+          b: number,
+          c = 2;
+      `,
+      errors: [
+        {
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'c' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
         },
       ],
     },
     {
-      code: 'const foo = (): void => {};',
+      code: "const foo = 'foo';",
+      errors: [
+        {
+          data: { name: 'foo' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
@@ -1077,20 +1072,32 @@ class Foo {
       ],
     },
     {
-      code: 'const foo: () => void = (): void => {};',
+      code: 'const foo = function (): void {};',
+      errors: [
+        {
+          data: { name: 'foo' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
     {
-      code: 'const foo: () => void = function (): void {};',
+      code: 'const foo = (): void => {};',
+      errors: [
+        {
+          data: { name: 'foo' },
+          messageId: 'expectedTypedefNamed',
+        },
+      ],
       options: [
         {
           variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
@@ -1101,28 +1108,21 @@ class Foo {
   b = function (): void {};
 }
       `,
-      options: [
+      errors: [
         {
-          variableDeclaration: true,
-          variableDeclarationIgnoreFunction: true,
+          data: { name: 'a' },
+          messageId: 'expectedTypedefNamed',
+        },
+        {
+          data: { name: 'b' },
+          messageId: 'expectedTypedefNamed',
         },
       ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/4033
-    {
-      code: `
-class ClassName {
-  public str: string = 'str';
-  #num: number = 13;
-
-  func: () => void = (): void => {
-    console.log(this.str);
-  };
-}
-      `,
       options: [
         {
           memberVariableDeclaration: true,
+          variableDeclaration: true,
+          variableDeclarationIgnoreFunction: false,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
index 3767f76b0cca..aeca1a171d50 100644
--- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -54,1203 +54,1203 @@ function addContainsMethodsClassInvalid(
 }
 
 ruleTester.run('unbound-method', rule, {
-  invalid: [
-    {
-      code: `
-class Console {
-  log(str) {
-    process.stdout.write(str);
-  }
-}
+  valid: [
+    'Promise.resolve().then(console.log);',
+    "['1', '2', '3'].map(Number.parseInt);",
+    '[5.2, 7.1, 3.6].map(Math.floor);',
+    `
+      const foo = Number;
+      ['1', '2', '3'].map(foo.parseInt);
+    `,
+    `
+      const foo = Math;
+      [5.2, 7.1, 3.6].map(foo.floor);
+    `,
+    "['1', '2', '3'].map(Number['floor']);",
+    'const x = console.log;',
+    'const x = Object.defineProperty;',
+    `
+      const foo = Object;
+      const x = foo.defineProperty;
+    `,
+    'const x = String.fromCharCode;',
+    `
+      const foo = String;
+      const x = foo.fromCharCode;
+    `,
+    'const x = RegExp.prototype;',
+    'const x = Symbol.keyFor;',
+    `
+      const foo = Symbol;
+      const x = foo.keyFor;
+    `,
+    'const x = Array.isArray;',
+    `
+      const foo = Array;
+      const x = foo.isArray;
+    `,
+    `
+      class Foo extends Array {}
+      const x = Foo.isArray;
+    `,
+    'const x = Proxy.revocable;',
+    `
+      const foo = Proxy;
+      const x = foo.revocable;
+    `,
+    'const x = Date.parse;',
+    `
+      const foo = Date;
+      const x = foo.parse;
+    `,
+    'const x = Atomics.load;',
+    `
+      const foo = Atomics;
+      const x = foo.load;
+    `,
+    'const x = Reflect.deleteProperty;',
+    'const x = JSON.stringify;',
+    `
+      const foo = JSON;
+      const x = foo.stringify;
+    `,
+    `
+      const o = {
+        f: function (this: void) {},
+      };
+      const f = o.f;
+    `,
+    `
+      const { alert } = window;
+    `,
+    `
+      let b = window.blur;
+    `,
+    `
+      function foo() {}
+      const fooObject = { foo };
+      const { foo: bar } = fooObject;
+    `,
+    ...[
+      'instance.bound();',
+      'instance.unbound();',
 
-const console = new Console();
+      'ContainsMethods.boundStatic();',
+      'ContainsMethods.unboundStatic();',
 
-Promise.resolve().then(console.log);
-      `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-import { console } from './class';
-const x = console.log;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: addContainsMethodsClass(`
-function foo(arg: ContainsMethods | null) {
-  const unbound = arg?.unbound;
-  arg.unbound += 1;
-  arg?.unbound as any;
-}
-      `),
-      errors: [
-        {
-          line: 20,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-        {
-          line: 21,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-        {
-          line: 22,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    ...addContainsMethodsClassInvalid([
-      'const unbound = instance.unbound;',
-      'const unboundStatic = ContainsMethods.unboundStatic;',
+      'const bound = instance.bound;',
+      'const boundStatic = ContainsMethods;',
 
-      'const { unbound } = instance;',
-      'const { unboundStatic } = ContainsMethods;',
+      'const { bound } = instance;',
+      'const { boundStatic } = ContainsMethods;',
 
-      '<any>instance.unbound;',
-      'instance.unbound as any;',
+      '(instance.bound)();',
+      '(instance.unbound)();',
 
-      '<any>ContainsMethods.unboundStatic;',
-      'ContainsMethods.unboundStatic as any;',
+      '(ContainsMethods.boundStatic)();',
+      '(ContainsMethods.unboundStatic)();',
 
-      'instance.unbound || 0;',
-      'ContainsMethods.unboundStatic || 0;',
+      'instance.bound``;',
+      'instance.unbound``;',
 
-      'instance.unbound ? instance.unbound : null',
-    ]),
-    {
-      code: `
-class ContainsMethods {
-  unbound?(): void;
+      'if (instance.bound) { }',
+      'if (instance.unbound) { }',
 
-  static unboundStatic?(): void;
-}
+      'if (instance.bound !== undefined) { }',
+      'if (instance.unbound !== undefined) { }',
 
-new ContainsMethods().unbound;
+      'if (ContainsMethods.boundStatic) { }',
+      'if (ContainsMethods.unboundStatic) { }',
 
-ContainsMethods.unboundStatic;
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-      options: [
-        {
-          ignoreStatic: true,
-        },
-      ],
-    },
+      'if (ContainsMethods.boundStatic !== undefined) { }',
+      'if (ContainsMethods.unboundStatic !== undefined) { }',
+
+      'if (ContainsMethods.boundStatic && instance) { }',
+      'if (ContainsMethods.unboundStatic && instance) { }',
+
+      'if (instance.bound || instance) { }',
+      'if (instance.unbound || instance) { }',
+
+      'ContainsMethods.unboundStatic && 0 || ContainsMethods;',
+
+      '(instance.bound || instance) ? 1 : 0',
+      '(instance.unbound || instance) ? 1 : 0',
+
+      'while (instance.bound) { }',
+      'while (instance.unbound) { }',
+
+      'while (instance.bound !== undefined) { }',
+      'while (instance.unbound !== undefined) { }',
+
+      'while (ContainsMethods.boundStatic) { }',
+      'while (ContainsMethods.unboundStatic) { }',
+
+      'while (ContainsMethods.boundStatic !== undefined) { }',
+      'while (ContainsMethods.unboundStatic !== undefined) { }',
+
+      'instance.bound as any;',
+      'ContainsMethods.boundStatic as any;',
+
+      'instance.bound++;',
+      '+instance.bound;',
+      '++instance.bound;',
+      'instance.bound--;',
+      '-instance.bound;',
+      '--instance.bound;',
+      'instance.bound += 1;',
+      'instance.bound -= 1;',
+      'instance.bound *= 1;',
+      'instance.bound /= 1;',
+
+      'instance.bound || 0;',
+      'instance.bound && 0;',
+
+      'instance.bound ? 1 : 0;',
+      'instance.unbound ? 1 : 0;',
+
+      'ContainsMethods.boundStatic++;',
+      '+ContainsMethods.boundStatic;',
+      '++ContainsMethods.boundStatic;',
+      'ContainsMethods.boundStatic--;',
+      '-ContainsMethods.boundStatic;',
+      '--ContainsMethods.boundStatic;',
+      'ContainsMethods.boundStatic += 1;',
+      'ContainsMethods.boundStatic -= 1;',
+      'ContainsMethods.boundStatic *= 1;',
+      'ContainsMethods.boundStatic /= 1;',
+
+      'ContainsMethods.boundStatic || 0;',
+      'instane.boundStatic && 0;',
+
+      'ContainsMethods.boundStatic ? 1 : 0;',
+      'ContainsMethods.unboundStatic ? 1 : 0;',
+
+      "typeof instance.bound === 'function';",
+      "typeof instance.unbound === 'function';",
+
+      "typeof ContainsMethods.boundStatic === 'function';",
+      "typeof ContainsMethods.unboundStatic === 'function';",
+
+      'instance.unbound = () => {};',
+      'instance.unbound = instance.unbound.bind(instance);',
+      'if (!!instance.unbound) {}',
+      'void instance.unbound',
+      'delete instance.unbound',
+
+      'const { double } = arith;',
+    ].map(addContainsMethodsClass),
+    `
+interface RecordA {
+  readonly type: 'A';
+  readonly a: {};
+}
+interface RecordB {
+  readonly type: 'B';
+  readonly b: {};
+}
+type AnyRecord = RecordA | RecordB;
+
+function test(obj: AnyRecord) {
+  switch (obj.type) {
+  }
+}
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/496
-    {
-      code: `
+    `
 class CommunicationError {
-  foo() {}
+  constructor() {
+    const x = CommunicationError.prototype;
+  }
 }
-const x = CommunicationError.prototype.foo;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      // Promise.all is not auto-bound to Promise
-      code: 'const x = Promise.all;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound() {}
+    `,
+    `
+class CommunicationError {}
+const x = CommunicationError.prototype;
+    `,
+    // optional chain
+    `
+class ContainsMethods {
+  bound?: () => void;
+  unbound?(): void;
+
+  static boundStatic?: () => void;
+  static unboundStatic?(): void;
 }
-const instance = new Foo();
 
-let x;
+function foo(instance: ContainsMethods | null) {
+  instance?.bound();
+  instance?.unbound();
 
-x = instance.unbound; // THIS SHOULD ERROR
-instance.unbound = x; // THIS SHOULD NOT
-      `,
-      errors: [
-        {
-          line: 9,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Number {
-  static parseInt = function (string: string, radix?: number): number {};
-}
-const foo = Foo;
-['1', '2', '3'].map(foo.parseInt);
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Number;
-const x = foo.toFixed;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Object;
-const x = foo.hasOwnProperty;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: String;
-const x = foo.slice;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-declare const foo: Date;
-const x = foo.getTime;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Number {}
-const x = Foo.parseInt;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends String {}
-const x = Foo.fromCharCode;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Object {}
-const x = Foo.defineProperty;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo extends Date {}
-const x = Foo.parse;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
-}
-const unbound = new Foo().unbound;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound() {}
+  if (instance?.bound) {
+  }
+  if (instance?.unbound) {
+  }
+
+  typeof instance?.bound === 'function';
+  typeof instance?.unbound === 'function';
 }
-const { unbound } = new Foo();
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1425
+    `
+interface OptionalMethod {
+  mightBeDefined?(): void;
 }
-const { unbound } = new Foo();
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound() {}
+
+const x: OptionalMethod = {};
+declare const myCondition: boolean;
+if (myCondition || x.mightBeDefined) {
+  console.log('hello world');
 }
-let unbound;
-({ unbound } = new Foo());
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class Foo {
-  unbound = function () {};
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1256
+    `
+class A {
+  unbound(): void {
+    this.unbound = undefined;
+    this.unbound = this.unbound.bind(this);
+  }
 }
-let unbound;
-({ unbound } = new Foo());
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    'const { parseInt } = Number;',
+    'const { log } = console;',
+    `
+let parseInt;
+({ parseInt } = Number);
+    `,
+    `
+let log;
+({ log } = console);
+    `,
+    `
+const foo = {
+  bar: 'bar',
+};
+const { bar } = foo;
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  unbnound() {}
+  bar = 4;
 }
-function foo({ unbound }: Foo = new Foo()) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+const { bar } = new Foo();
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-declare const bar: Foo;
-function foo({ unbound }: Foo = bar) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+const { bound } = new Foo();
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-declare const bar: Foo;
-function foo({ unbound }: Foo = { unbound: () => {} }) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound } = new Foo()) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
 declare const bar: Foo;
-function foo({ unbound }: Foo = { unbound: function () {} }) {}
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound }: Foo) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-function foo({ unbound }: Foo) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+class Bar {
+  bound = () => 'bar';
+}
+function foo({ bound }: Foo | Bar) {}
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-function bar(cb: (arg: Foo) => void) {}
-bar(({ unbound }) => {});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = ({ bound }: Foo) => void;
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-function bar(cb: (arg: { unbound: () => void }) => void) {}
-bar(({ unbound } = new Foo()) => {});
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = ({ unbound }: Foo) => void;
+    `,
+    `
 class Foo {
-  unbound = function () {};
+  bound = () => 'foo';
 }
-for (const { unbound } of [new Foo(), new Foo()]) {
+class Bar {
+  bound = () => 'bar';
 }
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo({ bound }: Foo & Bar) {}
+    `,
+    `
 class Foo {
   unbound = function () {};
-
-  foo({ unbound }: Foo) {}
 }
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+declare const { unbound }: Foo;
+    `,
+    "declare const { unbound } = '***';",
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = function () {};
-}
-function foo({ unbound }: Foo | Bar) {}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+type foo = (a: (b: (c: ({ unbound }: Foo) => void) => void) => void) => void;
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-function foo({ unbound }: { unbound: () => string } | Foo) {}
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+class Bar {
+  property: ({ unbound }: Foo) => void;
+}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
-}
-function foo({ unbound }: Foo | Bar) {}
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+function foo<T extends ({ unbound }: Foo) => void>() {}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-const foo = ({ unbound }: Foo & { foo: () => 'bar' }) => {};
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+abstract class Bar {
+  abstract foo({ unbound }: Foo);
+}
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
+declare class Bar {
+  foo({ unbound }: Foo);
 }
-const foo = ({ unbound }: (Foo & { foo: () => 'bar' }) | Bar) => {};
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
   unbound = function () {};
 }
-class Bar {
-  unbound = () => {};
+declare function foo({ unbound }: Foo);
+    `,
+    `
+class Foo {
+  unbound = function () {};
 }
-const foo = ({ unbound }: Foo & Bar) => {};
-      `,
-      errors: [
-        {
-          line: 8,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: `
+interface Bar {
+  foo: ({ unbound }: Foo) => void;
+}
+    `,
+    `
 class Foo {
   unbound = function () {};
-
-  other = function () {};
 }
-class Bar {
-  unbound = () => {};
+interface Bar {
+  foo({ unbound }: Foo): void;
 }
-const foo = ({ unbound, ...rest }: Foo & Bar) => {};
-      `,
-      errors: [
-        {
-          line: 10,
-          messageId: 'unbound',
-        },
-      ],
-    },
-    {
-      code: 'const { unbound } = { unbound: function () {} };',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-function foo(
-  { unbound }: { unbound: () => void } = { unbound: function () {} },
-) {}
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
+    `,
+    `
 class Foo {
-  floor = function () {};
+  unbound = function () {};
 }
-
-const { floor } = Math.random() > 0.5 ? new Foo() : Math;
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class CommunicationError {
-  foo() {}
+interface Bar {
+  new ({ unbound }: Foo): Foo;
 }
-const { foo } = CommunicationError.prototype;
-      `,
-      errors: [
-        {
-          line: 5,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-class CommunicationError {
-  foo() {}
+    `,
+    `
+class Foo {
+  unbound = function () {};
 }
-let foo;
-({ foo } = CommunicationError.prototype);
-      `,
-      errors: [
-        {
-          line: 6,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-import { console } from './class';
-const { log } = console;
-      `,
-      errors: [
-        {
-          line: 3,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: 'const { all } = Promise;',
-      errors: [
-        {
-          line: 1,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
+type foo = new ({ unbound }: Foo) => void;
+    `,
+    'const { unbound } = { unbound: () => {} };',
+    'function foo({ unbound }: { unbound: () => void } = { unbound: () => {} }) {}',
     // https://github.com/typescript-eslint/typescript-eslint/issues/1866
-    {
-      code: `
+    `
 class BaseClass {
+  x: number = 42;
   logThis() {}
 }
 class OtherClass extends BaseClass {
+  superLogThis: any;
   constructor() {
     super();
-    const x = super.logThis;
+    this.superLogThis = super.logThis;
   }
 }
-      `,
-      errors: [
-        {
-          column: 15,
-          line: 8,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1866
+const oc = new OtherClass();
+oc.superLogThis();
+    `,
+  ],
+  invalid: [
     {
       code: `
-class BaseClass {
-  logThis() {}
-}
-class OtherClass extends BaseClass {
-  constructor() {
-    super();
-    let x;
-    x = super.logThis;
+class Console {
+  log(str) {
+    process.stdout.write(str);
   }
 }
-      `,
-      errors: [
-        {
-          column: 9,
-          line: 9,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-const values = {
-  a() {},
-  b: () => {},
-};
 
-const { a, b } = values;
-      `,
-      errors: [
-        {
-          column: 9,
-          endColumn: 10,
-          line: 7,
-          messageId: 'unboundWithoutThisAnnotation',
-        },
-      ],
-    },
-    {
-      code: `
-const values = {
-  a() {},
-  b: () => {},
-};
+const console = new Console();
 
-const { a: c } = values;
+Promise.resolve().then(console.log);
       `,
       errors: [
         {
-          column: 9,
-          endColumn: 10,
-          line: 7,
+          line: 10,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
     {
       code: `
-const values = {
-  a() {},
-  b: () => {},
-};
-
-const { b, a } = values;
+import { console } from './class';
+const x = console.log;
       `,
       errors: [
         {
-          column: 12,
-          endColumn: 13,
-          line: 7,
+          line: 3,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
-    // https://github.com/typescript-eslint/typescript-eslint/issues/8636
     {
-      code: `
-const objectLiteral = {
-  f: function () {},
-};
-const f = objectLiteral.f;
-      `,
+      code: addContainsMethodsClass(`
+function foo(arg: ContainsMethods | null) {
+  const unbound = arg?.unbound;
+  arg.unbound += 1;
+  arg?.unbound as any;
+}
+      `),
       errors: [
         {
-          line: 5,
+          line: 20,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+        {
+          line: 21,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+        {
+          line: 22,
           messageId: 'unboundWithoutThisAnnotation',
         },
       ],
     },
-  ],
-  valid: [
-    'Promise.resolve().then(console.log);',
-    "['1', '2', '3'].map(Number.parseInt);",
-    '[5.2, 7.1, 3.6].map(Math.floor);',
-    `
-      const foo = Number;
-      ['1', '2', '3'].map(foo.parseInt);
-    `,
-    `
-      const foo = Math;
-      [5.2, 7.1, 3.6].map(foo.floor);
-    `,
-    "['1', '2', '3'].map(Number['floor']);",
-    'const x = console.log;',
-    'const x = Object.defineProperty;',
-    `
-      const foo = Object;
-      const x = foo.defineProperty;
-    `,
-    'const x = String.fromCharCode;',
-    `
-      const foo = String;
-      const x = foo.fromCharCode;
-    `,
-    'const x = RegExp.prototype;',
-    'const x = Symbol.keyFor;',
-    `
-      const foo = Symbol;
-      const x = foo.keyFor;
-    `,
-    'const x = Array.isArray;',
-    `
-      const foo = Array;
-      const x = foo.isArray;
-    `,
-    `
-      class Foo extends Array {}
-      const x = Foo.isArray;
-    `,
-    'const x = Proxy.revocable;',
-    `
-      const foo = Proxy;
-      const x = foo.revocable;
-    `,
-    'const x = Date.parse;',
-    `
-      const foo = Date;
-      const x = foo.parse;
-    `,
-    'const x = Atomics.load;',
-    `
-      const foo = Atomics;
-      const x = foo.load;
-    `,
-    'const x = Reflect.deleteProperty;',
-    'const x = JSON.stringify;',
-    `
-      const foo = JSON;
-      const x = foo.stringify;
-    `,
-    `
-      const o = {
-        f: function (this: void) {},
-      };
-      const f = o.f;
-    `,
-    `
-      const { alert } = window;
-    `,
-    `
-      let b = window.blur;
-    `,
-    `
-      function foo() {}
-      const fooObject = { foo };
-      const { foo: bar } = fooObject;
-    `,
-    ...[
-      'instance.bound();',
-      'instance.unbound();',
-
-      'ContainsMethods.boundStatic();',
-      'ContainsMethods.unboundStatic();',
-
-      'const bound = instance.bound;',
-      'const boundStatic = ContainsMethods;',
-
-      'const { bound } = instance;',
-      'const { boundStatic } = ContainsMethods;',
-
-      '(instance.bound)();',
-      '(instance.unbound)();',
-
-      '(ContainsMethods.boundStatic)();',
-      '(ContainsMethods.unboundStatic)();',
-
-      'instance.bound``;',
-      'instance.unbound``;',
-
-      'if (instance.bound) { }',
-      'if (instance.unbound) { }',
-
-      'if (instance.bound !== undefined) { }',
-      'if (instance.unbound !== undefined) { }',
-
-      'if (ContainsMethods.boundStatic) { }',
-      'if (ContainsMethods.unboundStatic) { }',
-
-      'if (ContainsMethods.boundStatic !== undefined) { }',
-      'if (ContainsMethods.unboundStatic !== undefined) { }',
-
-      'if (ContainsMethods.boundStatic && instance) { }',
-      'if (ContainsMethods.unboundStatic && instance) { }',
-
-      'if (instance.bound || instance) { }',
-      'if (instance.unbound || instance) { }',
-
-      'ContainsMethods.unboundStatic && 0 || ContainsMethods;',
-
-      '(instance.bound || instance) ? 1 : 0',
-      '(instance.unbound || instance) ? 1 : 0',
-
-      'while (instance.bound) { }',
-      'while (instance.unbound) { }',
-
-      'while (instance.bound !== undefined) { }',
-      'while (instance.unbound !== undefined) { }',
-
-      'while (ContainsMethods.boundStatic) { }',
-      'while (ContainsMethods.unboundStatic) { }',
-
-      'while (ContainsMethods.boundStatic !== undefined) { }',
-      'while (ContainsMethods.unboundStatic !== undefined) { }',
-
-      'instance.bound as any;',
-      'ContainsMethods.boundStatic as any;',
-
-      'instance.bound++;',
-      '+instance.bound;',
-      '++instance.bound;',
-      'instance.bound--;',
-      '-instance.bound;',
-      '--instance.bound;',
-      'instance.bound += 1;',
-      'instance.bound -= 1;',
-      'instance.bound *= 1;',
-      'instance.bound /= 1;',
-
-      'instance.bound || 0;',
-      'instance.bound && 0;',
-
-      'instance.bound ? 1 : 0;',
-      'instance.unbound ? 1 : 0;',
-
-      'ContainsMethods.boundStatic++;',
-      '+ContainsMethods.boundStatic;',
-      '++ContainsMethods.boundStatic;',
-      'ContainsMethods.boundStatic--;',
-      '-ContainsMethods.boundStatic;',
-      '--ContainsMethods.boundStatic;',
-      'ContainsMethods.boundStatic += 1;',
-      'ContainsMethods.boundStatic -= 1;',
-      'ContainsMethods.boundStatic *= 1;',
-      'ContainsMethods.boundStatic /= 1;',
-
-      'ContainsMethods.boundStatic || 0;',
-      'instane.boundStatic && 0;',
-
-      'ContainsMethods.boundStatic ? 1 : 0;',
-      'ContainsMethods.unboundStatic ? 1 : 0;',
-
-      "typeof instance.bound === 'function';",
-      "typeof instance.unbound === 'function';",
-
-      "typeof ContainsMethods.boundStatic === 'function';",
-      "typeof ContainsMethods.unboundStatic === 'function';",
-
-      'instance.unbound = () => {};',
-      'instance.unbound = instance.unbound.bind(instance);',
-      'if (!!instance.unbound) {}',
-      'void instance.unbound',
-      'delete instance.unbound',
+    ...addContainsMethodsClassInvalid([
+      'const unbound = instance.unbound;',
+      'const unboundStatic = ContainsMethods.unboundStatic;',
 
-      'const { double } = arith;',
-    ].map(addContainsMethodsClass),
-    `
-interface RecordA {
-  readonly type: 'A';
-  readonly a: {};
-}
-interface RecordB {
-  readonly type: 'B';
-  readonly b: {};
-}
-type AnyRecord = RecordA | RecordB;
+      'const { unbound } = instance;',
+      'const { unboundStatic } = ContainsMethods;',
 
-function test(obj: AnyRecord) {
-  switch (obj.type) {
-  }
-}
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/496
-    `
-class CommunicationError {
-  constructor() {
-    const x = CommunicationError.prototype;
-  }
-}
-    `,
-    `
-class CommunicationError {}
-const x = CommunicationError.prototype;
-    `,
-    // optional chain
-    `
+      '<any>instance.unbound;',
+      'instance.unbound as any;',
+
+      '<any>ContainsMethods.unboundStatic;',
+      'ContainsMethods.unboundStatic as any;',
+
+      'instance.unbound || 0;',
+      'ContainsMethods.unboundStatic || 0;',
+
+      'instance.unbound ? instance.unbound : null',
+    ]),
+    {
+      code: `
 class ContainsMethods {
-  bound?: () => void;
   unbound?(): void;
 
-  static boundStatic?: () => void;
   static unboundStatic?(): void;
 }
 
-function foo(instance: ContainsMethods | null) {
-  instance?.bound();
-  instance?.unbound();
-
-  if (instance?.bound) {
-  }
-  if (instance?.unbound) {
-  }
+new ContainsMethods().unbound;
 
-  typeof instance?.bound === 'function';
-  typeof instance?.unbound === 'function';
+ContainsMethods.unboundStatic;
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+      options: [
+        {
+          ignoreStatic: true,
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/496
+    {
+      code: `
+class CommunicationError {
+  foo() {}
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1425
-    `
-interface OptionalMethod {
-  mightBeDefined?(): void;
+const x = CommunicationError.prototype.foo;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      // Promise.all is not auto-bound to Promise
+      code: 'const x = Promise.all;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound() {}
 }
+const instance = new Foo();
 
-const x: OptionalMethod = {};
-declare const myCondition: boolean;
-if (myCondition || x.mightBeDefined) {
-  console.log('hello world');
+let x;
+
+x = instance.unbound; // THIS SHOULD ERROR
+instance.unbound = x; // THIS SHOULD NOT
+      `,
+      errors: [
+        {
+          line: 9,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Number {
+  static parseInt = function (string: string, radix?: number): number {};
 }
-    `,
-    // https://github.com/typescript-eslint/typescript-eslint/issues/1256
-    `
-class A {
-  unbound(): void {
-    this.unbound = undefined;
-    this.unbound = this.unbound.bind(this);
-  }
+const foo = Foo;
+['1', '2', '3'].map(foo.parseInt);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Number;
+const x = foo.toFixed;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Object;
+const x = foo.hasOwnProperty;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: String;
+const x = foo.slice;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+declare const foo: Date;
+const x = foo.getTime;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Number {}
+const x = Foo.parseInt;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends String {}
+const x = Foo.fromCharCode;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Object {}
+const x = Foo.defineProperty;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo extends Date {}
+const x = Foo.parse;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
 }
-    `,
-    'const { parseInt } = Number;',
-    'const { log } = console;',
-    `
-let parseInt;
-({ parseInt } = Number);
-    `,
-    `
-let log;
-({ log } = console);
-    `,
-    `
-const foo = {
-  bar: 'bar',
-};
-const { bar } = foo;
-    `,
-    `
+const unbound = new Foo().unbound;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound() {}
+}
+const { unbound } = new Foo();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
+}
+const { unbound } = new Foo();
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  unbnound() {}
-  bar = 4;
+  unbound() {}
 }
-const { bar } = new Foo();
-    `,
-    `
+let unbound;
+({ unbound } = new Foo());
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-const { bound } = new Foo();
-    `,
-    `
+let unbound;
+({ unbound } = new Foo());
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-function foo({ bound } = new Foo()) {}
-    `,
-    `
+function foo({ unbound }: Foo = new Foo()) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
 declare const bar: Foo;
-function foo({ bound }: Foo) {}
-    `,
-    `
+function foo({ unbound }: Foo = bar) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
-}
-class Bar {
-  bound = () => 'bar';
+  unbound = function () {};
 }
-function foo({ bound }: Foo | Bar) {}
-    `,
-    `
+declare const bar: Foo;
+function foo({ unbound }: Foo = { unbound: () => {} }) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-type foo = ({ bound }: Foo) => void;
-    `,
-    `
+declare const bar: Foo;
+function foo({ unbound }: Foo = { unbound: function () {} }) {}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-type foo = ({ unbound }: Foo) => void;
-    `,
-    `
+function foo({ unbound }: Foo) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  bound = () => 'foo';
+  unbound = function () {};
 }
-class Bar {
-  bound = () => 'bar';
+function bar(cb: (arg: Foo) => void) {}
+bar(({ unbound }) => {});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+class Foo {
+  unbound = function () {};
 }
-function foo({ bound }: Foo & Bar) {}
-    `,
-    `
+function bar(cb: (arg: { unbound: () => void }) => void) {}
+bar(({ unbound } = new Foo()) => {});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare const { unbound }: Foo;
-    `,
-    "declare const { unbound } = '***';",
-    `
+for (const { unbound } of [new Foo(), new Foo()]) {
+}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
+
+  foo({ unbound }: Foo) {}
 }
-type foo = (a: (b: (c: ({ unbound }: Foo) => void) => void) => void) => void;
-    `,
-    `
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
 class Bar {
-  property: ({ unbound }: Foo) => void;
+  unbound = function () {};
 }
-    `,
-    `
+function foo({ unbound }: Foo | Bar) {}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-function foo<T extends ({ unbound }: Foo) => void>() {}
-    `,
-    `
+function foo({ unbound }: { unbound: () => string } | Foo) {}
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-abstract class Bar {
-  abstract foo({ unbound }: Foo);
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+function foo({ unbound }: Foo | Bar) {}
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare class Bar {
-  foo({ unbound }: Foo);
-}
-    `,
-    `
+const foo = ({ unbound }: Foo & { foo: () => 'bar' }) => {};
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-declare function foo({ unbound }: Foo);
-    `,
-    `
+class Bar {
+  unbound = () => {};
+}
+const foo = ({ unbound }: (Foo & { foo: () => 'bar' }) | Bar) => {};
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
 }
-interface Bar {
-  foo: ({ unbound }: Foo) => void;
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+const foo = ({ unbound }: Foo & Bar) => {};
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
   unbound = function () {};
+
+  other = function () {};
 }
-interface Bar {
-  foo({ unbound }: Foo): void;
+class Bar {
+  unbound = () => {};
 }
-    `,
-    `
+const foo = ({ unbound, ...rest }: Foo & Bar) => {};
+      `,
+      errors: [
+        {
+          line: 10,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: 'const { unbound } = { unbound: function () {} };',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+function foo(
+  { unbound }: { unbound: () => void } = { unbound: function () {} },
+) {}
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
 class Foo {
-  unbound = function () {};
+  floor = function () {};
 }
-interface Bar {
-  new ({ unbound }: Foo): Foo;
+
+const { floor } = Math.random() > 0.5 ? new Foo() : Math;
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class CommunicationError {
+  foo() {}
 }
-    `,
-    `
-class Foo {
-  unbound = function () {};
+const { foo } = CommunicationError.prototype;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+class CommunicationError {
+  foo() {}
 }
-type foo = new ({ unbound }: Foo) => void;
-    `,
-    'const { unbound } = { unbound: () => {} };',
-    'function foo({ unbound }: { unbound: () => void } = { unbound: () => {} }) {}',
+let foo;
+({ foo } = CommunicationError.prototype);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+import { console } from './class';
+const { log } = console;
+      `,
+      errors: [
+        {
+          line: 3,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: 'const { all } = Promise;',
+      errors: [
+        {
+          line: 1,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
     // https://github.com/typescript-eslint/typescript-eslint/issues/1866
-    `
+    {
+      code: `
 class BaseClass {
-  x: number = 42;
   logThis() {}
 }
 class OtherClass extends BaseClass {
-  superLogThis: any;
   constructor() {
     super();
-    this.superLogThis = super.logThis;
+    const x = super.logThis;
   }
 }
-const oc = new OtherClass();
-oc.superLogThis();
-    `,
+      `,
+      errors: [
+        {
+          column: 15,
+          line: 8,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1866
+    {
+      code: `
+class BaseClass {
+  logThis() {}
+}
+class OtherClass extends BaseClass {
+  constructor() {
+    super();
+    let x;
+    x = super.logThis;
+  }
+}
+      `,
+      errors: [
+        {
+          column: 9,
+          line: 9,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+const values = {
+  a() {},
+  b: () => {},
+};
+
+const { a, b } = values;
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 10,
+          line: 7,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+const values = {
+  a() {},
+  b: () => {},
+};
+
+const { a: c } = values;
+      `,
+      errors: [
+        {
+          column: 9,
+          endColumn: 10,
+          line: 7,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    {
+      code: `
+const values = {
+  a() {},
+  b: () => {},
+};
+
+const { b, a } = values;
+      `,
+      errors: [
+        {
+          column: 12,
+          endColumn: 13,
+          line: 7,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/8636
+    {
+      code: `
+const objectLiteral = {
+  f: function () {},
+};
+const f = objectLiteral.f;
+      `,
+      errors: [
+        {
+          line: 5,
+          messageId: 'unboundWithoutThisAnnotation',
+        },
+      ],
+    },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
index e37768875fc5..0e5ee9219ce7 100644
--- a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
@@ -9,6 +9,218 @@ import rule from '../../src/rules/unified-signatures';
 const ruleTester = new RuleTester();
 
 ruleTester.run('unified-signatures', rule, {
+  valid: [
+    `
+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) {}
+
+  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;
+}
+    `,
+    // No error for different return types.
+    `
+interface I {
+  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;
+}
+    `,
+    // No error if one is a rest parameter and other isn't.
+    `
+interface I {
+  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;
+}
+    `,
+    // No error if one is optional and the other isn't.
+    `
+interface I {
+  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;
+}
+    `,
+    // No conflict between static/non-static members.
+    `
+declare class D {
+  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;
+}
+    `,
+    // Allow signatures if the type is not equal.
+    `
+interface I {
+  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' {
+  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;
+  }
+}
+    `,
+    `
+export interface Foo {
+  bar(baz: string): number[];
+  bar(): string[];
+}
+    `,
+    `
+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;
+}
+    `,
+    `
+interface I {
+  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;
+}
+    `,
+    {
+      code: `
+function f(a: number): void;
+function f(b: string): void;
+function f(a: number | string): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(m: number): void;
+function f(v: number, u: string): void;
+function f(v: number, u?: string): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: boolean): number;
+function f(): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: boolean, u: boolean): number;
+function f(v: boolean): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(v: number, u?: string): void {}
+function f(v: number): void;
+function f(): string;
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+function f(a: boolean, ...c: number[]): void;
+function f(a: boolean, ...d: string[]): void;
+function f(a: boolean, ...c: (number | string)[]): void {}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+    {
+      code: `
+class C {
+  constructor();
+  constructor(a: number, b: number);
+  constructor(c?: number, b?: number) {}
+
+  a(): void;
+  a(a: number, b: number): void;
+  a(a?: number, d?: number): void {}
+}
+      `,
+      options: [{ ignoreDifferentlyNamedParameters: true }],
+    },
+  ],
   invalid: [
     {
       code: `
@@ -560,216 +772,4 @@ export default function (foo: number, bar?: string): string[];
       ],
     },
   ],
-  valid: [
-    `
-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) {}
-
-  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;
-}
-    `,
-    // No error for different return types.
-    `
-interface I {
-  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;
-}
-    `,
-    // No error if one is a rest parameter and other isn't.
-    `
-interface I {
-  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;
-}
-    `,
-    // No error if one is optional and the other isn't.
-    `
-interface I {
-  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;
-}
-    `,
-    // No conflict between static/non-static members.
-    `
-declare class D {
-  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;
-}
-    `,
-    // Allow signatures if the type is not equal.
-    `
-interface I {
-  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' {
-  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;
-  }
-}
-    `,
-    `
-export interface Foo {
-  bar(baz: string): number[];
-  bar(): string[];
-}
-    `,
-    `
-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;
-}
-    `,
-    `
-interface I {
-  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;
-}
-    `,
-    {
-      code: `
-function f(a: number): void;
-function f(b: string): void;
-function f(a: number | string): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(m: number): void;
-function f(v: number, u: string): void;
-function f(v: number, u?: string): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: boolean): number;
-function f(): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: boolean, u: boolean): number;
-function f(v: boolean): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(v: number, u?: string): void {}
-function f(v: number): void;
-function f(): string;
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-function f(a: boolean, ...c: number[]): void;
-function f(a: boolean, ...d: string[]): void;
-function f(a: boolean, ...c: (number | string)[]): void {}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-    {
-      code: `
-class C {
-  constructor();
-  constructor(a: number, b: number);
-  constructor(c?: number, b?: number) {}
-
-  a(): void;
-  a(a: number, b: number): void;
-  a(a?: number, d?: number): void {}
-}
-      `,
-      options: [{ ignoreDifferentlyNamedParameters: true }],
-    },
-  ],
 });
diff --git a/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts b/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
index ea562abf6494..3c99f88ddc21 100644
--- a/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
+++ b/packages/eslint-plugin/tests/rules/use-unknown-in-catch-callback-variable.test.ts
@@ -15,6 +15,155 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('use-unknown-in-catch-callback-variable', rule, {
+  valid: [
+    `
+      Promise.resolve().catch((err: unknown) => {
+        throw err;
+      });
+    `,
+    `
+      let x = Math.random() ? 'ca' + 'tch' : 'catch';
+      Promise.resolve()[x]((err: Error) => {});
+    `,
+    `
+      Promise.resolve().then(
+        () => {},
+        (err: unknown) => {
+          throw err;
+        },
+      );
+    `,
+    `
+      Promise.resolve().catch(() => {
+        throw new Error();
+      });
+    `,
+    `
+      Promise.reject(new Error()).catch("not this rule's problem");
+    `,
+    `
+      declare const crappyHandler: (() => void) | 2;
+      Promise.reject(new Error()).catch(crappyHandler);
+    `,
+
+    `
+      Promise.resolve().catch((...args: [unknown]) => {
+        throw args[0];
+      });
+    `,
+    `
+      Promise.resolve().catch((...args: [a: unknown]) => {
+        const err = args[0];
+      });
+    `,
+
+    `
+      Promise.resolve().catch((...args: readonly unknown[]) => {
+        throw args[0];
+      });
+    `,
+
+    `
+      declare const notAPromise: { catch: (f: Function) => void };
+      notAPromise.catch((...args: [a: string, string]) => {
+        throw args[0];
+      });
+    `,
+    `
+      declare const catchArgs: [(x: unknown) => void];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+
+    `
+      declare const catchArgs: [
+        string | (() => never),
+        (shouldntFlag: string) => void,
+        number,
+      ];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+      declare const catchArgs: ['not callable'];
+      Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+      declare const emptySpread: [];
+      Promise.reject(new Error()).catch(...emptySpread);
+    `,
+    `
+      Promise.resolve().catch(
+        (
+          ...err: [unknown, string | ((number | unknown) & { b: () => void }), string]
+        ) => {
+          throw err;
+        },
+      );
+    `,
+    `
+      declare const notAMemberExpression: (...args: any[]) => {};
+      notAMemberExpression(
+        'This helps get 100% code cov',
+        "but doesn't test anything useful related to the rule.",
+      );
+    `,
+    `
+      Promise.resolve().catch((...[args]: [unknown]) => {
+        console.log(args);
+      });
+    `,
+    `
+      Promise.resolve().catch((...{ find }: [unknown]) => {
+        console.log(find);
+      });
+    `,
+    'Promise.resolve.then();',
+    'Promise.resolve().then(() => {});',
+    `
+      declare const singleTupleArg: [() => void];
+      Promise.resolve().then(...singleTupleArg, (error: unknown) => {});
+    `,
+    `
+      declare const arrayArg: (() => void)[];
+      Promise.resolve().then(...arrayArg, error => {});
+    `,
+    `
+declare let iPromiseImAPromise: Promise<any>;
+declare const catchArgs: [(x: any) => void];
+iPromiseImAPromise.catch(...catchArgs);
+    `,
+    `
+declare const catchArgs: [
+  string | (() => never) | ((x: string) => void),
+  number,
+];
+Promise.reject(new Error()).catch(...catchArgs);
+    `,
+    `
+declare const you: [];
+declare const cannot: [];
+declare const fool: [];
+declare const me: [(x: Error) => void] | undefined;
+Promise.resolve(undefined).catch(...you, ...cannot, ...fool, ...me!);
+    `,
+    `
+declare const really: undefined[];
+declare const dumb: [];
+declare const code: (x: Error) => void;
+Promise.resolve(undefined).catch(...really, ...dumb, code);
+    `,
+    `
+declare const x: ((x: any) => string)[];
+Promise.resolve('string promise').catch(...x);
+    `,
+    `
+declare const x: any;
+Promise.resolve().catch(...x);
+    `,
+    `
+declare const thenArgs: [() => {}, (err: any) => {}];
+Promise.resolve().then(...thenArgs);
+    `,
+  ],
   invalid: [
     {
       code: `
@@ -599,154 +748,4 @@ Promise.resolve().catch((...{ find }: [unknown]) => {
       ],
     },
   ],
-
-  valid: [
-    `
-      Promise.resolve().catch((err: unknown) => {
-        throw err;
-      });
-    `,
-    `
-      let x = Math.random() ? 'ca' + 'tch' : 'catch';
-      Promise.resolve()[x]((err: Error) => {});
-    `,
-    `
-      Promise.resolve().then(
-        () => {},
-        (err: unknown) => {
-          throw err;
-        },
-      );
-    `,
-    `
-      Promise.resolve().catch(() => {
-        throw new Error();
-      });
-    `,
-    `
-      Promise.reject(new Error()).catch("not this rule's problem");
-    `,
-    `
-      declare const crappyHandler: (() => void) | 2;
-      Promise.reject(new Error()).catch(crappyHandler);
-    `,
-
-    `
-      Promise.resolve().catch((...args: [unknown]) => {
-        throw args[0];
-      });
-    `,
-    `
-      Promise.resolve().catch((...args: [a: unknown]) => {
-        const err = args[0];
-      });
-    `,
-
-    `
-      Promise.resolve().catch((...args: readonly unknown[]) => {
-        throw args[0];
-      });
-    `,
-
-    `
-      declare const notAPromise: { catch: (f: Function) => void };
-      notAPromise.catch((...args: [a: string, string]) => {
-        throw args[0];
-      });
-    `,
-    `
-      declare const catchArgs: [(x: unknown) => void];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-
-    `
-      declare const catchArgs: [
-        string | (() => never),
-        (shouldntFlag: string) => void,
-        number,
-      ];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-      declare const catchArgs: ['not callable'];
-      Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-      declare const emptySpread: [];
-      Promise.reject(new Error()).catch(...emptySpread);
-    `,
-    `
-      Promise.resolve().catch(
-        (
-          ...err: [unknown, string | ((number | unknown) & { b: () => void }), string]
-        ) => {
-          throw err;
-        },
-      );
-    `,
-    `
-      declare const notAMemberExpression: (...args: any[]) => {};
-      notAMemberExpression(
-        'This helps get 100% code cov',
-        "but doesn't test anything useful related to the rule.",
-      );
-    `,
-    `
-      Promise.resolve().catch((...[args]: [unknown]) => {
-        console.log(args);
-      });
-    `,
-    `
-      Promise.resolve().catch((...{ find }: [unknown]) => {
-        console.log(find);
-      });
-    `,
-    'Promise.resolve.then();',
-    'Promise.resolve().then(() => {});',
-    `
-      declare const singleTupleArg: [() => void];
-      Promise.resolve().then(...singleTupleArg, (error: unknown) => {});
-    `,
-    `
-      declare const arrayArg: (() => void)[];
-      Promise.resolve().then(...arrayArg, error => {});
-    `,
-    `
-declare let iPromiseImAPromise: Promise<any>;
-declare const catchArgs: [(x: any) => void];
-iPromiseImAPromise.catch(...catchArgs);
-    `,
-    `
-declare const catchArgs: [
-  string | (() => never) | ((x: string) => void),
-  number,
-];
-Promise.reject(new Error()).catch(...catchArgs);
-    `,
-    `
-declare const you: [];
-declare const cannot: [];
-declare const fool: [];
-declare const me: [(x: Error) => void] | undefined;
-Promise.resolve(undefined).catch(...you, ...cannot, ...fool, ...me!);
-    `,
-    `
-declare const really: undefined[];
-declare const dumb: [];
-declare const code: (x: Error) => void;
-Promise.resolve(undefined).catch(...really, ...dumb, code);
-    `,
-    `
-declare const x: ((x: any) => string)[];
-Promise.resolve('string promise').catch(...x);
-    `,
-    `
-declare const x: any;
-Promise.resolve().catch(...x);
-    `,
-    `
-declare const thenArgs: [() => {}, (err: any) => {}];
-Promise.resolve().then(...thenArgs);
-    `,
-  ],
 });

From f8a17068bfade658ba9c8a24e14ee49df0b20b98 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Tue, 17 Sep 2024 14:39:43 -0400
Subject: [PATCH 08/13] Preferences around line and column, and remove enums

---
 eslint.config.mjs                             |  6 +-
 .../src/rules/ban-tslint-comment.ts           |  4 +-
 .../rules/naming-convention-utils/enums.ts    | 62 +++++++++----------
 packages/eslint-plugin/src/rules/no-shadow.ts |  2 +-
 .../src/rules/no-unnecessary-condition.ts     |  4 +-
 .../eslint-plugin/src/rules/no-unused-vars.ts |  2 +-
 .../src/rules/prefer-nullish-coalescing.ts    |  4 +-
 .../src/rules/strict-boolean-expressions.ts   |  4 +-
 8 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 48f042c9fd87..3bce076b973f 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -586,7 +586,7 @@ export default tseslint.config(
     rules: {
       '@typescript-eslint/sort-type-constituents': 'off',
       'perfectionist/sort-classes': 'error',
-      'perfectionist/sort-enums': 'error',
+      'perfectionist/sort-enums': 'off',
       'perfectionist/sort-union-types': [
         'error',
         {
@@ -611,8 +611,8 @@ export default tseslint.config(
         {
           customGroups: {
             primary: ['loc', 'name', 'node', 'type'],
-            secondary: ['meta', 'messageId'],
-            tertiary: ['defaultOptions', 'data'],
+            secondary: ['line', 'meta', 'messageId'],
+            tertiary: ['column', 'defaultOptions', 'data'],
             quaternary: ['fix'],
           },
           groups: ['primary', 'secondary', 'tertiary', 'quaternary', 'unknown'],
diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index 48be960677ca..bf405fd58144 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -42,12 +42,12 @@ export default createRule({
               data: { text: toText(c.value, c.type) },
               fix(fixer) {
                 const rangeStart = context.sourceCode.getIndexFromLoc({
-                  column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0,
                   line: c.loc.start.line,
+                  column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0,
                 });
                 const rangeEnd = context.sourceCode.getIndexFromLoc({
-                  column: c.loc.end.column,
                   line: c.loc.end.line,
+                  column: c.loc.end.column,
                 });
                 return fixer.removeRange([rangeStart, rangeEnd + 1]);
               },
diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
index 7e26a97897ca..539ca50a7810 100644
--- a/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
+++ b/packages/eslint-plugin/src/rules/naming-convention-utils/enums.ts
@@ -22,27 +22,27 @@ type UnderscoreOptionsString = keyof typeof UnderscoreOptions;
 
 enum Selectors {
   // variableLike
+  variable = 1 << 0,
   function = 1 << 1,
   parameter = 1 << 2,
-  variable = 1 << 0,
 
   // memberLike
-  autoAccessor = 1 << 12,
+  parameterProperty = 1 << 3,
   classicAccessor = 1 << 4,
-  classMethod = 1 << 6,
-  classProperty = 1 << 9,
   enumMember = 1 << 5,
+  classMethod = 1 << 6,
   objectLiteralMethod = 1 << 7,
-  objectLiteralProperty = 1 << 10,
-  parameterProperty = 1 << 3,
   typeMethod = 1 << 8,
+  classProperty = 1 << 9,
+  objectLiteralProperty = 1 << 10,
   typeProperty = 1 << 11,
+  autoAccessor = 1 << 12,
 
   // typeLike
   class = 1 << 13,
-  enum = 1 << 16,
   interface = 1 << 14,
   typeAlias = 1 << 15,
+  enum = 1 << 16,
   typeParameter = 1 << 17,
 
   // other
@@ -52,8 +52,11 @@ type SelectorsString = keyof typeof Selectors;
 
 enum MetaSelectors {
   /* eslint-disable @typescript-eslint/prefer-literal-enum-member */
-  accessor = 0 | Selectors.classicAccessor | Selectors.autoAccessor,
   default = -1,
+  variableLike = 0 |
+    Selectors.variable |
+    Selectors.function |
+    Selectors.parameter,
   memberLike = 0 |
     Selectors.classProperty |
     Selectors.objectLiteralProperty |
@@ -65,6 +68,12 @@ enum MetaSelectors {
     Selectors.typeMethod |
     Selectors.classicAccessor |
     Selectors.autoAccessor,
+  typeLike = 0 |
+    Selectors.class |
+    Selectors.interface |
+    Selectors.typeAlias |
+    Selectors.enum |
+    Selectors.typeParameter,
   method = 0 |
     Selectors.classMethod |
     Selectors.objectLiteralMethod |
@@ -73,16 +82,7 @@ enum MetaSelectors {
     Selectors.classProperty |
     Selectors.objectLiteralProperty |
     Selectors.typeProperty,
-  typeLike = 0 |
-    Selectors.class |
-    Selectors.interface |
-    Selectors.typeAlias |
-    Selectors.enum |
-    Selectors.typeParameter,
-  variableLike = 0 |
-    Selectors.variable |
-    Selectors.function |
-    Selectors.parameter,
+  accessor = 0 | Selectors.classicAccessor | Selectors.autoAccessor,
   /* eslint-enable @typescript-eslint/prefer-literal-enum-member */
 }
 type MetaSelectorsString = keyof typeof MetaSelectors;
@@ -96,11 +96,11 @@ enum Modifiers {
   // static members
   static = 1 << 2,
   // member accessibility
+  public = 1 << 3,
+  protected = 1 << 4,
+  private = 1 << 5,
   '#private' = 1 << 6,
   abstract = 1 << 7,
-  private = 1 << 5,
-  protected = 1 << 4,
-  public = 1 << 3,
   // destructured variable
   destructured = 1 << 8,
   // variables declared in the top-level scope
@@ -125,26 +125,26 @@ enum Modifiers {
 type ModifiersString = keyof typeof Modifiers;
 
 enum TypeModifiers {
-  array = 1 << 21,
   boolean = 1 << 17,
-  function = 1 << 20,
-  number = 1 << 19,
   string = 1 << 18,
+  number = 1 << 19,
+  function = 1 << 20,
+  array = 1 << 21,
 }
 type TypeModifiersString = keyof typeof TypeModifiers;
 
 export {
-  IndividualAndMetaSelectorsString,
+  type IndividualAndMetaSelectorsString,
   MetaSelectors,
-  MetaSelectorsString,
+  type MetaSelectorsString,
   Modifiers,
-  ModifiersString,
+  type ModifiersString,
   PredefinedFormats,
-  PredefinedFormatsString,
+  type PredefinedFormatsString,
   Selectors,
-  SelectorsString,
+  type SelectorsString,
   TypeModifiers,
-  TypeModifiersString,
+  type TypeModifiersString,
   UnderscoreOptions,
-  UnderscoreOptionsString,
+  type UnderscoreOptionsString,
 };
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index 1a730f5c1199..bef8f50cc44c 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -520,9 +520,9 @@ export default createRule<Options, MessageIds>({
       const identifier = variable.identifiers.at(0);
       if (identifier) {
         return {
+          line: identifier.loc.start.line,
           column: identifier.loc.start.column + 1,
           global: false,
-          line: identifier.loc.start.line,
         };
       }
       return {
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index d9f104cad880..60943949aa58 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -167,8 +167,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          end: { column: 0, line: 0 },
-          start: { column: 0, line: 0 },
+          end: { line: 0, column: 0 },
+          start: { line: 0, column: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index 59be0e04d4ca..caa600c22b61 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -610,8 +610,8 @@ export default createRule<Options, MessageIds>({
 
             const loc = {
               end: {
-                column: start.column + idLength,
                 line: start.line,
+                column: start.column + idLength,
               },
               start,
             };
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 507441c1715f..5d7c8dbbb5fd 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -140,8 +140,8 @@ export default createRule<Options, MessageIds>({
     ) {
       context.report({
         loc: {
-          end: { column: 0, line: 0 },
-          start: { column: 0, line: 0 },
+          end: { line: 0, column: 0 },
+          start: { line: 0, column: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index 99b8f095071c..1577aa37d93e 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -173,8 +173,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          end: { column: 0, line: 0 },
-          start: { column: 0, line: 0 },
+          end: { line: 0, column: 0 },
+          start: { line: 0, column: 0 },
         },
         messageId: 'noStrictNullCheck',
       });

From b2d62b1906ad748d13896b7bffdf4a5c62adcd74 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Tue, 17 Sep 2024 15:31:42 -0400
Subject: [PATCH 09/13] Preferences around start and end

---
 eslint.config.mjs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 3bce076b973f..8e31c94c9d08 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -611,8 +611,8 @@ export default tseslint.config(
         {
           customGroups: {
             primary: ['loc', 'name', 'node', 'type'],
-            secondary: ['line', 'meta', 'messageId'],
-            tertiary: ['column', 'defaultOptions', 'data'],
+            secondary: ['meta', 'messageId', 'start'],
+            tertiary: ['defaultOptions', 'data', 'end'],
             quaternary: ['fix'],
           },
           groups: ['primary', 'secondary', 'tertiary', 'quaternary', 'unknown'],

From 657b9550f27893f5ec6d2bc16af4ae07e07a0fc9 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Wed, 18 Sep 2024 09:14:54 -0400
Subject: [PATCH 10/13] Preferences around end and start, not line and column

---
 packages/eslint-plugin/src/rules/ban-tslint-comment.ts        | 4 ++--
 .../eslint-plugin/src/rules/explicit-member-accessibility.ts  | 2 +-
 packages/eslint-plugin/src/rules/init-declarations.ts         | 2 +-
 .../eslint-plugin/src/rules/no-duplicate-type-constituents.ts | 2 +-
 packages/eslint-plugin/src/rules/no-shadow.ts                 | 2 +-
 packages/eslint-plugin/src/rules/no-unnecessary-condition.ts  | 4 ++--
 packages/eslint-plugin/src/rules/no-unused-vars.ts            | 4 ++--
 packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts | 4 ++--
 .../eslint-plugin/src/rules/strict-boolean-expressions.ts     | 4 ++--
 9 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
index bf405fd58144..48be960677ca 100644
--- a/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
+++ b/packages/eslint-plugin/src/rules/ban-tslint-comment.ts
@@ -42,12 +42,12 @@ export default createRule({
               data: { text: toText(c.value, c.type) },
               fix(fixer) {
                 const rangeStart = context.sourceCode.getIndexFromLoc({
-                  line: c.loc.start.line,
                   column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0,
+                  line: c.loc.start.line,
                 });
                 const rangeEnd = context.sourceCode.getIndexFromLoc({
-                  line: c.loc.end.line,
                   column: c.loc.end.column,
+                  line: c.loc.end.line,
                 });
                 return fixer.removeRange([rangeStart, rangeEnd + 1]);
               },
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 7d1c2f9aefe1..248039da4a8d 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -394,7 +394,7 @@ function rangeToLoc(
   range: TSESLint.AST.Range,
 ): TSESTree.SourceLocation {
   return {
-    end: sourceCode.getLocFromIndex(range[1]),
     start: sourceCode.getLocFromIndex(range[0]),
+    end: sourceCode.getLocFromIndex(range[1]),
   };
 }
diff --git a/packages/eslint-plugin/src/rules/init-declarations.ts b/packages/eslint-plugin/src/rules/init-declarations.ts
index 0f5b6f03c785..18629283c451 100644
--- a/packages/eslint-plugin/src/rules/init-declarations.ts
+++ b/packages/eslint-plugin/src/rules/init-declarations.ts
@@ -130,7 +130,7 @@ function getReportLoc(
   };
 
   return {
-    end,
     start,
+    end,
   };
 }
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
index 03f5e0422603..76c411c2328a 100644
--- a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
+++ b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -170,11 +170,11 @@ export default createRule<Options, MessageIds>({
         { count: bracketBeforeTokens.length },
       );
       const reportLocation: TSESTree.SourceLocation = {
+        start: duplicateConstituent.duplicated.loc.start,
         end:
           bracketAfterTokens.length > 0
             ? bracketAfterTokens[bracketAfterTokens.length - 1].loc.end
             : duplicateConstituent.duplicated.loc.end,
-        start: duplicateConstituent.duplicated.loc.start,
       };
       context.report({
         loc: reportLocation,
diff --git a/packages/eslint-plugin/src/rules/no-shadow.ts b/packages/eslint-plugin/src/rules/no-shadow.ts
index bef8f50cc44c..1a730f5c1199 100644
--- a/packages/eslint-plugin/src/rules/no-shadow.ts
+++ b/packages/eslint-plugin/src/rules/no-shadow.ts
@@ -520,9 +520,9 @@ export default createRule<Options, MessageIds>({
       const identifier = variable.identifiers.at(0);
       if (identifier) {
         return {
-          line: identifier.loc.start.line,
           column: identifier.loc.start.column + 1,
           global: false,
+          line: identifier.loc.start.line,
         };
       }
       return {
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 60943949aa58..c5332a5e9125 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -167,8 +167,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          end: { line: 0, column: 0 },
-          start: { line: 0, column: 0 },
+          start: { column: 0, line: 0 },
+          end: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
index caa600c22b61..b578b6df8abc 100644
--- a/packages/eslint-plugin/src/rules/no-unused-vars.ts
+++ b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -609,11 +609,11 @@ export default createRule<Options, MessageIds>({
             const idLength = id.name.length;
 
             const loc = {
+              start,
               end: {
-                line: start.line,
                 column: start.column + idLength,
+                line: start.line,
               },
-              start,
             };
 
             context.report({
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index 5d7c8dbbb5fd..6072c40d2f11 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -140,8 +140,8 @@ export default createRule<Options, MessageIds>({
     ) {
       context.report({
         loc: {
-          end: { line: 0, column: 0 },
-          start: { line: 0, column: 0 },
+          start: { column: 0, line: 0 },
+          end: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
index 1577aa37d93e..8743990271ad 100644
--- a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
+++ b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -173,8 +173,8 @@ export default createRule<Options, MessageId>({
     ) {
       context.report({
         loc: {
-          end: { line: 0, column: 0 },
-          start: { line: 0, column: 0 },
+          start: { column: 0, line: 0 },
+          end: { column: 0, line: 0 },
         },
         messageId: 'noStrictNullCheck',
       });

From 532c9c46db80c511f31089cc4b5a5c1c17e3dde7 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Wed, 9 Oct 2024 10:41:55 -0400
Subject: [PATCH 11/13] ignore eslint-plugin/src/configs

---
 eslint.config.mjs                             | 19 ++++---
 packages/eslint-plugin/src/configs/all.ts     | 50 +++++++++----------
 .../src/configs/disable-type-checked.ts       |  2 +-
 .../src/configs/eslint-recommended-raw.ts     |  4 +-
 .../configs/recommended-type-checked-only.ts  |  8 +--
 .../src/configs/recommended-type-checked.ts   | 14 +++---
 .../eslint-plugin/src/configs/recommended.ts  |  6 +--
 .../src/configs/strict-type-checked-only.ts   | 12 ++---
 .../src/configs/strict-type-checked.ts        | 20 ++++----
 packages/eslint-plugin/src/configs/strict.ts  |  8 +--
 .../configs/stylistic-type-checked-only.ts    |  2 +-
 .../src/configs/stylistic-type-checked.ts     |  4 +-
 .../eslint-plugin/src/configs/stylistic.ts    |  2 +-
 13 files changed, 77 insertions(+), 74 deletions(-)

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 040d5c36bd11..a86a5bfed979 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -596,7 +596,10 @@ export default tseslint.config(
   },
   {
     extends: [perfectionistPlugin.configs['recommended-alphabetical']],
-    ignores: ['packages/typescript-eslint/src/configs/*'],
+    ignores: [
+      'packages/eslint-plugin/src/configs/*',
+      'packages/typescript-eslint/src/configs/*',
+    ],
     files: [
       'packages/ast-spec/{src,tests,typings}/**/*.ts',
       'packages/eslint-plugin/{src,tests,tools,typings}/**/*.ts',
@@ -639,9 +642,9 @@ export default tseslint.config(
         'error',
         {
           customGroups: {
-            primary: ['type'],
+            first: ['type'],
           },
-          groups: ['primary', 'unknown'],
+          groups: ['first', 'unknown'],
         },
       ],
     },
@@ -653,12 +656,12 @@ export default tseslint.config(
         'error',
         {
           customGroups: {
-            primary: ['loc', 'name', 'node', 'type'],
-            secondary: ['meta', 'messageId', 'start'],
-            tertiary: ['defaultOptions', 'data', 'end'],
-            quaternary: ['fix'],
+            first: ['loc', 'name', 'node', 'type'],
+            second: ['meta', 'messageId', 'start'],
+            third: ['defaultOptions', 'data', 'end'],
+            fourth: ['fix'],
           },
-          groups: ['primary', 'secondary', 'tertiary', 'quaternary', 'unknown'],
+          groups: ['first', 'second', 'third', 'fourth', 'unknown'],
         },
       ],
     },
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
index 32813df58a78..107f369260ec 100644
--- a/packages/eslint-plugin/src/configs/all.ts
+++ b/packages/eslint-plugin/src/configs/all.ts
@@ -16,34 +16,43 @@ export = {
     '@typescript-eslint/ban-ts-comment': 'error',
     '@typescript-eslint/ban-tslint-comment': 'error',
     '@typescript-eslint/class-literal-property-style': 'error',
+    'class-methods-use-this': 'off',
     '@typescript-eslint/class-methods-use-this': 'error',
     '@typescript-eslint/consistent-generic-constructors': 'error',
     '@typescript-eslint/consistent-indexed-object-style': 'error',
+    'consistent-return': 'off',
     '@typescript-eslint/consistent-return': 'error',
     '@typescript-eslint/consistent-type-assertions': 'error',
     '@typescript-eslint/consistent-type-definitions': 'error',
     '@typescript-eslint/consistent-type-exports': 'error',
     '@typescript-eslint/consistent-type-imports': 'error',
+    'default-param-last': 'off',
     '@typescript-eslint/default-param-last': 'error',
+    'dot-notation': 'off',
     '@typescript-eslint/dot-notation': 'error',
     '@typescript-eslint/explicit-function-return-type': 'error',
     '@typescript-eslint/explicit-member-accessibility': 'error',
     '@typescript-eslint/explicit-module-boundary-types': 'error',
+    'init-declarations': 'off',
     '@typescript-eslint/init-declarations': 'error',
+    'max-params': 'off',
     '@typescript-eslint/max-params': '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',
     '@typescript-eslint/no-array-delete': 'error',
     '@typescript-eslint/no-base-to-string': 'error',
     '@typescript-eslint/no-confusing-non-null-assertion': 'error',
     '@typescript-eslint/no-confusing-void-expression': 'error',
     '@typescript-eslint/no-deprecated': 'error',
+    'no-dupe-class-members': 'off',
     '@typescript-eslint/no-dupe-class-members': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-duplicate-type-constituents': 'error',
     '@typescript-eslint/no-dynamic-delete': 'error',
+    'no-empty-function': 'off',
     '@typescript-eslint/no-empty-function': 'error',
     '@typescript-eslint/no-empty-object-type': 'error',
     '@typescript-eslint/no-explicit-any': 'error',
@@ -51,12 +60,16 @@ export = {
     '@typescript-eslint/no-extraneous-class': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-for-in-array': 'error',
+    'no-implied-eval': 'off',
     '@typescript-eslint/no-implied-eval': 'error',
     '@typescript-eslint/no-import-type-side-effects': 'error',
     '@typescript-eslint/no-inferrable-types': 'error',
+    'no-invalid-this': 'off',
     '@typescript-eslint/no-invalid-this': 'error',
     '@typescript-eslint/no-invalid-void-type': 'error',
+    'no-loop-func': 'off',
     '@typescript-eslint/no-loop-func': 'error',
+    'no-magic-numbers': 'off',
     '@typescript-eslint/no-magic-numbers': 'error',
     '@typescript-eslint/no-meaningless-void-operator': 'error',
     '@typescript-eslint/no-misused-new': 'error',
@@ -66,11 +79,14 @@ export = {
     '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
     '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
     '@typescript-eslint/no-non-null-assertion': 'error',
+    'no-redeclare': 'off',
     '@typescript-eslint/no-redeclare': 'error',
     '@typescript-eslint/no-redundant-type-constituents': 'error',
     '@typescript-eslint/no-require-imports': 'error',
+    'no-restricted-imports': 'off',
     '@typescript-eslint/no-restricted-imports': 'error',
     '@typescript-eslint/no-restricted-types': 'error',
+    'no-shadow': 'off',
     '@typescript-eslint/no-shadow': 'error',
     '@typescript-eslint/no-this-alias': 'error',
     '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
@@ -91,16 +107,22 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
+    'no-use-before-define': 'off',
     '@typescript-eslint/no-use-before-define': 'error',
+    'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'error',
     '@typescript-eslint/no-useless-empty-export': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
     '@typescript-eslint/non-nullable-type-assertion-style': 'error',
+    'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
     '@typescript-eslint/parameter-properties': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
+    'prefer-destructuring': 'off',
     '@typescript-eslint/prefer-destructuring': 'error',
     '@typescript-eslint/prefer-enum-initializers': 'error',
     '@typescript-eslint/prefer-find': 'error',
@@ -111,6 +133,7 @@ export = {
     '@typescript-eslint/prefer-namespace-keyword': 'error',
     '@typescript-eslint/prefer-nullish-coalescing': 'error',
     '@typescript-eslint/prefer-optional-chain': 'error',
+    'prefer-promise-reject-errors': 'off',
     '@typescript-eslint/prefer-promise-reject-errors': 'error',
     '@typescript-eslint/prefer-readonly': 'error',
     '@typescript-eslint/prefer-readonly-parameter-types': 'error',
@@ -120,9 +143,11 @@ export = {
     '@typescript-eslint/prefer-string-starts-ends-with': 'error',
     '@typescript-eslint/promise-function-async': 'error',
     '@typescript-eslint/require-array-sort-compare': 'error',
+    'require-await': 'off',
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/restrict-plus-operands': 'error',
     '@typescript-eslint/restrict-template-expressions': 'error',
+    'no-return-await': 'off',
     '@typescript-eslint/return-await': 'error',
     '@typescript-eslint/strict-boolean-expressions': 'error',
     '@typescript-eslint/switch-exhaustiveness-check': 'error',
@@ -131,30 +156,5 @@ export = {
     '@typescript-eslint/unbound-method': 'error',
     '@typescript-eslint/unified-signatures': 'error',
     '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
-    'class-methods-use-this': 'off',
-    'consistent-return': 'off',
-    'default-param-last': 'off',
-    'dot-notation': 'off',
-    'init-declarations': 'off',
-    'max-params': 'off',
-    'no-array-constructor': 'off',
-    'no-dupe-class-members': 'off',
-    'no-empty-function': 'off',
-    'no-implied-eval': 'off',
-    'no-invalid-this': 'off',
-    'no-loop-func': 'off',
-    'no-magic-numbers': 'off',
-    'no-redeclare': 'off',
-    'no-restricted-imports': 'off',
-    'no-return-await': 'off',
-    'no-shadow': 'off',
-    'no-throw-literal': 'off',
-    'no-unused-expressions': 'off',
-    'no-unused-vars': 'off',
-    'no-use-before-define': 'off',
-    'no-useless-constructor': 'off',
-    'prefer-destructuring': 'off',
-    'prefer-promise-reject-errors': 'off',
-    'require-await': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/disable-type-checked.ts b/packages/eslint-plugin/src/configs/disable-type-checked.ts
index a688a9f37cf1..7cf867b382f2 100644
--- a/packages/eslint-plugin/src/configs/disable-type-checked.ts
+++ b/packages/eslint-plugin/src/configs/disable-type-checked.ts
@@ -8,7 +8,7 @@
 import type { ClassicConfig } from '@typescript-eslint/utils/ts-eslint';
 
 export = {
-  parserOptions: { program: null, project: false, projectService: false },
+  parserOptions: { project: false, program: null, projectService: false },
   rules: {
     '@typescript-eslint/await-thenable': 'off',
     '@typescript-eslint/consistent-return': 'off',
diff --git a/packages/eslint-plugin/src/configs/eslint-recommended-raw.ts b/packages/eslint-plugin/src/configs/eslint-recommended-raw.ts
index b036493a6de9..d42cfb1d8663 100644
--- a/packages/eslint-plugin/src/configs/eslint-recommended-raw.ts
+++ b/packages/eslint-plugin/src/configs/eslint-recommended-raw.ts
@@ -11,7 +11,7 @@ export default (
   style: 'glob' | 'minimatch',
 ): {
   files: string[];
-  rules: Record<string, 'error' | 'off' | 'warn'>;
+  rules: Record<string, 'off' | 'warn' | 'error'>;
 } => ({
   files:
     style === 'glob'
@@ -29,8 +29,8 @@ export default (
     'no-func-assign': 'off', // ts(2630)
     'no-import-assign': 'off', // ts(2632) & ts(2540)
     // TODO - remove this once we no longer support ESLint v8
-    'no-new-native-nonconstructor': 'off', // ts(7009)
     'no-new-symbol': 'off', // ts(7009)
+    'no-new-native-nonconstructor': 'off', // ts(7009)
     'no-obj-calls': 'off', // ts(2349)
     'no-redeclare': 'off', // ts(2451)
     'no-setter-return': 'off', // ts(2408)
diff --git a/packages/eslint-plugin/src/configs/recommended-type-checked-only.ts b/packages/eslint-plugin/src/configs/recommended-type-checked-only.ts
index df02a3e78d8c..c9c0f5cb4368 100644
--- a/packages/eslint-plugin/src/configs/recommended-type-checked-only.ts
+++ b/packages/eslint-plugin/src/configs/recommended-type-checked-only.ts
@@ -16,6 +16,7 @@ export = {
     '@typescript-eslint/no-duplicate-type-constituents': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-for-in-array': 'error',
+    'no-implied-eval': 'off',
     '@typescript-eslint/no-implied-eval': 'error',
     '@typescript-eslint/no-misused-promises': 'error',
     '@typescript-eslint/no-redundant-type-constituents': 'error',
@@ -27,15 +28,14 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
+    'prefer-promise-reject-errors': 'off',
     '@typescript-eslint/prefer-promise-reject-errors': 'error',
+    'require-await': 'off',
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/restrict-plus-operands': 'error',
     '@typescript-eslint/restrict-template-expressions': 'error',
     '@typescript-eslint/unbound-method': 'error',
-    'no-implied-eval': 'off',
-    'no-throw-literal': 'off',
-    'prefer-promise-reject-errors': 'off',
-    'require-await': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/recommended-type-checked.ts b/packages/eslint-plugin/src/configs/recommended-type-checked.ts
index 1968732a2bf9..e8e10a7071a5 100644
--- a/packages/eslint-plugin/src/configs/recommended-type-checked.ts
+++ b/packages/eslint-plugin/src/configs/recommended-type-checked.ts
@@ -12,6 +12,7 @@ export = {
   rules: {
     '@typescript-eslint/await-thenable': 'error',
     '@typescript-eslint/ban-ts-comment': 'error',
+    'no-array-constructor': 'off',
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-array-delete': 'error',
     '@typescript-eslint/no-base-to-string': 'error',
@@ -22,6 +23,7 @@ export = {
     '@typescript-eslint/no-extra-non-null-assertion': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-for-in-array': 'error',
+    'no-implied-eval': 'off',
     '@typescript-eslint/no-implied-eval': 'error',
     '@typescript-eslint/no-misused-new': 'error',
     '@typescript-eslint/no-misused-promises': 'error',
@@ -41,24 +43,22 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
+    'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
     '@typescript-eslint/prefer-namespace-keyword': 'error',
+    'prefer-promise-reject-errors': 'off',
     '@typescript-eslint/prefer-promise-reject-errors': 'error',
+    'require-await': 'off',
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/restrict-plus-operands': 'error',
     '@typescript-eslint/restrict-template-expressions': 'error',
     '@typescript-eslint/triple-slash-reference': 'error',
     '@typescript-eslint/unbound-method': 'error',
-    'no-array-constructor': 'off',
-    'no-implied-eval': 'off',
-    'no-throw-literal': 'off',
-    'no-unused-expressions': 'off',
-    'no-unused-vars': 'off',
-    'prefer-promise-reject-errors': 'off',
-    'require-await': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/recommended.ts b/packages/eslint-plugin/src/configs/recommended.ts
index 6e56ea52593c..487935ee1f23 100644
--- a/packages/eslint-plugin/src/configs/recommended.ts
+++ b/packages/eslint-plugin/src/configs/recommended.ts
@@ -11,6 +11,7 @@ export = {
   extends: ['./configs/base', './configs/eslint-recommended'],
   rules: {
     '@typescript-eslint/ban-ts-comment': 'error',
+    'no-array-constructor': 'off',
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-empty-object-type': 'error',
@@ -24,14 +25,13 @@ export = {
     '@typescript-eslint/no-unnecessary-type-constraint': 'error',
     '@typescript-eslint/no-unsafe-declaration-merging': 'error',
     '@typescript-eslint/no-unsafe-function-type': 'error',
+    'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
     '@typescript-eslint/prefer-namespace-keyword': 'error',
     '@typescript-eslint/triple-slash-reference': 'error',
-    'no-array-constructor': 'off',
-    'no-unused-expressions': 'off',
-    'no-unused-vars': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/strict-type-checked-only.ts b/packages/eslint-plugin/src/configs/strict-type-checked-only.ts
index 4a23d84ebd4f..8bfba2276c9d 100644
--- a/packages/eslint-plugin/src/configs/strict-type-checked-only.ts
+++ b/packages/eslint-plugin/src/configs/strict-type-checked-only.ts
@@ -18,6 +18,7 @@ export = {
     '@typescript-eslint/no-duplicate-type-constituents': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-for-in-array': 'error',
+    'no-implied-eval': 'off',
     '@typescript-eslint/no-implied-eval': 'error',
     '@typescript-eslint/no-meaningless-void-operator': 'error',
     '@typescript-eslint/no-misused-promises': 'error',
@@ -36,10 +37,13 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
+    'prefer-promise-reject-errors': 'off',
     '@typescript-eslint/prefer-promise-reject-errors': 'error',
     '@typescript-eslint/prefer-reduce-type-parameter': 'error',
     '@typescript-eslint/prefer-return-this-type': 'error',
+    'require-await': 'off',
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/restrict-plus-operands': [
       'error',
@@ -56,22 +60,18 @@ export = {
       {
         allowAny: false,
         allowBoolean: false,
-        allowNever: false,
         allowNullish: false,
         allowNumber: false,
         allowRegExp: false,
+        allowNever: false,
       },
     ],
+    'no-return-await': 'off',
     '@typescript-eslint/return-await': [
       'error',
       'error-handling-correctness-only',
     ],
     '@typescript-eslint/unbound-method': 'error',
     '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
-    'no-implied-eval': 'off',
-    'no-return-await': 'off',
-    'no-throw-literal': 'off',
-    'prefer-promise-reject-errors': 'off',
-    'require-await': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/strict-type-checked.ts b/packages/eslint-plugin/src/configs/strict-type-checked.ts
index a15f74494e60..4a5c7adfc93e 100644
--- a/packages/eslint-plugin/src/configs/strict-type-checked.ts
+++ b/packages/eslint-plugin/src/configs/strict-type-checked.ts
@@ -15,6 +15,7 @@ export = {
       'error',
       { minimumDescriptionLength: 10 },
     ],
+    'no-array-constructor': 'off',
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-array-delete': 'error',
     '@typescript-eslint/no-base-to-string': 'error',
@@ -29,6 +30,7 @@ export = {
     '@typescript-eslint/no-extraneous-class': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-for-in-array': 'error',
+    'no-implied-eval': 'off',
     '@typescript-eslint/no-implied-eval': 'error',
     '@typescript-eslint/no-invalid-void-type': 'error',
     '@typescript-eslint/no-meaningless-void-operator': 'error',
@@ -58,17 +60,23 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
+    'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
+    'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
     '@typescript-eslint/prefer-literal-enum-member': 'error',
     '@typescript-eslint/prefer-namespace-keyword': 'error',
+    'prefer-promise-reject-errors': 'off',
     '@typescript-eslint/prefer-promise-reject-errors': 'error',
     '@typescript-eslint/prefer-reduce-type-parameter': 'error',
     '@typescript-eslint/prefer-return-this-type': 'error',
+    'require-await': 'off',
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/restrict-plus-operands': [
       'error',
@@ -85,12 +93,13 @@ export = {
       {
         allowAny: false,
         allowBoolean: false,
-        allowNever: false,
         allowNullish: false,
         allowNumber: false,
         allowRegExp: false,
+        allowNever: false,
       },
     ],
+    'no-return-await': 'off',
     '@typescript-eslint/return-await': [
       'error',
       'error-handling-correctness-only',
@@ -99,14 +108,5 @@ export = {
     '@typescript-eslint/unbound-method': 'error',
     '@typescript-eslint/unified-signatures': 'error',
     '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
-    'no-array-constructor': 'off',
-    'no-implied-eval': 'off',
-    'no-return-await': 'off',
-    'no-throw-literal': 'off',
-    'no-unused-expressions': 'off',
-    'no-unused-vars': 'off',
-    'no-useless-constructor': 'off',
-    'prefer-promise-reject-errors': 'off',
-    'require-await': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/strict.ts b/packages/eslint-plugin/src/configs/strict.ts
index 5153ee11193f..0e655d1464ca 100644
--- a/packages/eslint-plugin/src/configs/strict.ts
+++ b/packages/eslint-plugin/src/configs/strict.ts
@@ -14,6 +14,7 @@ export = {
       'error',
       { minimumDescriptionLength: 10 },
     ],
+    'no-array-constructor': 'off',
     '@typescript-eslint/no-array-constructor': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     '@typescript-eslint/no-dynamic-delete': 'error',
@@ -32,8 +33,11 @@ export = {
     '@typescript-eslint/no-unnecessary-type-constraint': 'error',
     '@typescript-eslint/no-unsafe-declaration-merging': 'error',
     '@typescript-eslint/no-unsafe-function-type': 'error',
+    'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
+    'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
     '@typescript-eslint/prefer-as-const': 'error',
@@ -41,9 +45,5 @@ export = {
     '@typescript-eslint/prefer-namespace-keyword': 'error',
     '@typescript-eslint/triple-slash-reference': 'error',
     '@typescript-eslint/unified-signatures': 'error',
-    'no-array-constructor': 'off',
-    'no-unused-expressions': 'off',
-    'no-unused-vars': 'off',
-    'no-useless-constructor': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/stylistic-type-checked-only.ts b/packages/eslint-plugin/src/configs/stylistic-type-checked-only.ts
index be6096a5eff4..03428e419be5 100644
--- a/packages/eslint-plugin/src/configs/stylistic-type-checked-only.ts
+++ b/packages/eslint-plugin/src/configs/stylistic-type-checked-only.ts
@@ -10,6 +10,7 @@ import type { ClassicConfig } from '@typescript-eslint/utils/ts-eslint';
 export = {
   extends: ['./configs/base', './configs/eslint-recommended'],
   rules: {
+    'dot-notation': 'off',
     '@typescript-eslint/dot-notation': 'error',
     '@typescript-eslint/non-nullable-type-assertion-style': 'error',
     '@typescript-eslint/prefer-find': 'error',
@@ -18,6 +19,5 @@ export = {
     '@typescript-eslint/prefer-optional-chain': 'error',
     '@typescript-eslint/prefer-regexp-exec': 'error',
     '@typescript-eslint/prefer-string-starts-ends-with': 'error',
-    'dot-notation': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/stylistic-type-checked.ts b/packages/eslint-plugin/src/configs/stylistic-type-checked.ts
index 6e61df2f7ae5..f2512877aebe 100644
--- a/packages/eslint-plugin/src/configs/stylistic-type-checked.ts
+++ b/packages/eslint-plugin/src/configs/stylistic-type-checked.ts
@@ -18,8 +18,10 @@ export = {
     '@typescript-eslint/consistent-indexed-object-style': 'error',
     '@typescript-eslint/consistent-type-assertions': 'error',
     '@typescript-eslint/consistent-type-definitions': 'error',
+    'dot-notation': 'off',
     '@typescript-eslint/dot-notation': 'error',
     '@typescript-eslint/no-confusing-non-null-assertion': 'error',
+    'no-empty-function': 'off',
     '@typescript-eslint/no-empty-function': 'error',
     '@typescript-eslint/no-inferrable-types': 'error',
     '@typescript-eslint/non-nullable-type-assertion-style': 'error',
@@ -31,7 +33,5 @@ export = {
     '@typescript-eslint/prefer-optional-chain': 'error',
     '@typescript-eslint/prefer-regexp-exec': 'error',
     '@typescript-eslint/prefer-string-starts-ends-with': 'error',
-    'dot-notation': 'off',
-    'no-empty-function': 'off',
   },
 } satisfies ClassicConfig.Config;
diff --git a/packages/eslint-plugin/src/configs/stylistic.ts b/packages/eslint-plugin/src/configs/stylistic.ts
index 3e27af15426a..02705c56c034 100644
--- a/packages/eslint-plugin/src/configs/stylistic.ts
+++ b/packages/eslint-plugin/src/configs/stylistic.ts
@@ -19,10 +19,10 @@ export = {
     '@typescript-eslint/consistent-type-assertions': 'error',
     '@typescript-eslint/consistent-type-definitions': 'error',
     '@typescript-eslint/no-confusing-non-null-assertion': 'error',
+    'no-empty-function': 'off',
     '@typescript-eslint/no-empty-function': 'error',
     '@typescript-eslint/no-inferrable-types': 'error',
     '@typescript-eslint/prefer-for-of': 'error',
     '@typescript-eslint/prefer-function-type': 'error',
-    'no-empty-function': 'off',
   },
 } satisfies ClassicConfig.Config;

From c23b576fd2836502418201b445941ab09ae05ed2 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Wed, 9 Oct 2024 11:28:06 -0400
Subject: [PATCH 12/13] fix: TSModuleDeclaration/spec.ts global comment

---
 packages/ast-spec/src/declaration/TSModuleDeclaration/spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/ast-spec/src/declaration/TSModuleDeclaration/spec.ts b/packages/ast-spec/src/declaration/TSModuleDeclaration/spec.ts
index 25c93f1ce3c0..b17ae830824c 100644
--- a/packages/ast-spec/src/declaration/TSModuleDeclaration/spec.ts
+++ b/packages/ast-spec/src/declaration/TSModuleDeclaration/spec.ts
@@ -15,7 +15,6 @@ interface TSModuleDeclarationBase extends BaseNode {
    * This can only be `undefined` for the code `declare module 'mod';`
    */
   body?: TSModuleBlock;
-  // TODO - remove this in the next major (we have `.kind` now)
   /**
    * Whether the module is `declare`d
    * @example
@@ -24,6 +23,7 @@ interface TSModuleDeclarationBase extends BaseNode {
    * ```
    */
   declare: boolean;
+  // TODO - remove this in the next major (we have `.kind` now)
   /**
    * Whether this is a global declaration
    * @example

From d79866d09ed515d9df0906a075d24690bed5200a Mon Sep 17 00:00:00 2001
From: Josh Goldberg <git@joshuakgoldberg.com>
Date: Wed, 9 Oct 2024 12:05:18 -0400
Subject: [PATCH 13/13] fix: ajv is order-dependent

---
 .../eslint-plugin/src/rules/member-ordering.ts   | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index 412e62751e33..f845f1f1ae75 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -737,13 +737,6 @@ export default createRule<Options, MessageIds>({
             type: 'string',
             enum: allMemberTypes as string[],
           },
-          baseConfig: {
-            oneOf: [
-              neverConfig,
-              arrayConfig('#/items/0/$defs/allItems'),
-              objectConfig('#/items/0/$defs/allItems'),
-            ],
-          },
           optionalityOrderOptions: {
             type: 'string',
             enum: ['optional-first', 'required-first'],
@@ -758,7 +751,6 @@ export default createRule<Options, MessageIds>({
               'natural-case-insensitive',
             ],
           },
-
           typeItems: {
             type: 'string',
             enum: [
@@ -770,6 +762,14 @@ export default createRule<Options, MessageIds>({
               'constructor',
             ],
           },
+          // ajv is order-dependent; these configs must come last
+          baseConfig: {
+            oneOf: [
+              neverConfig,
+              arrayConfig('#/items/0/$defs/allItems'),
+              objectConfig('#/items/0/$defs/allItems'),
+            ],
+          },
           typesConfig: {
             oneOf: [
               neverConfig,