diff --git a/packages/eslint-plugin-internal/tests/rules/no-poorly-typed-ts-props.test.ts b/packages/eslint-plugin-internal/tests/rules/no-poorly-typed-ts-props.test.ts
index 5e75c5e2b7e5..4e9b2a60ce25 100644
--- a/packages/eslint-plugin-internal/tests/rules/no-poorly-typed-ts-props.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/no-poorly-typed-ts-props.test.ts
@@ -5,11 +5,11 @@ import rule from '../../src/rules/no-poorly-typed-ts-props';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.json',
-    tsconfigRootDir: getFixturesRootDir(),
-    sourceType: 'module',
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
diff --git a/packages/eslint-plugin-internal/tests/rules/no-relative-paths-to-internal-packages.test.ts b/packages/eslint-plugin-internal/tests/rules/no-relative-paths-to-internal-packages.test.ts
index 2e1cbf99e216..0f48ae9a2c45 100644
--- a/packages/eslint-plugin-internal/tests/rules/no-relative-paths-to-internal-packages.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/no-relative-paths-to-internal-packages.test.ts
@@ -5,9 +5,7 @@ import rule, {
   PACKAGES_DIR,
 } from '../../src/rules/no-relative-paths-to-internal-packages';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-relative-paths-to-internal-packages', rule, {
   valid: [
diff --git a/packages/eslint-plugin-internal/tests/rules/no-typescript-default-import.test.ts b/packages/eslint-plugin-internal/tests/rules/no-typescript-default-import.test.ts
index 45590e5012de..94ab1f566266 100644
--- a/packages/eslint-plugin-internal/tests/rules/no-typescript-default-import.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/no-typescript-default-import.test.ts
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-typescript-default-import';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-typescript-default-import', rule, {
   valid: [
diff --git a/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts b/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
index 46eb2edabbe0..8c4bcda6fa82 100644
--- a/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-typescript-estree-import';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-typescript-estree-import', rule, {
   valid: [
diff --git a/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
index 280d3fd67f8e..290673eb56e0 100644
--- a/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
@@ -4,11 +4,11 @@ import rule from '../../src/rules/plugin-test-formatting';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.json',
-    tsconfigRootDir: getFixturesRootDir(),
-    sourceType: 'module',
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
@@ -160,7 +160,7 @@ const test2 = {
 
     // TODO - figure out how to handle this pattern
     `
-import { TSESLint } from '@typescript-eslint/utils';
+import { InvalidTestCase } from '@typescript-eslint/rule-tester';
 
 const test = [
   {
@@ -169,7 +169,7 @@ const test = [
   {
     code: 'const badlyFormatted         = "code2"',
   },
-].map<TSESLint.InvalidTestCase<[]>>(test => ({
+].map<InvalidTestCase<[]>>(test => ({
   code: test.code,
   errors: [],
 }));
@@ -724,9 +724,9 @@ const test: RunTests = {
     },
     {
       code: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { RunTests } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.RunTests<'', []> = {
+const test: RunTests<'', []> = {
   valid: [
     'const badlyFormatted         = "code"',
     {
@@ -742,9 +742,9 @@ const test: TSESLint.RunTests<'', []> = {
 };
       `,
       output: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { RunTests } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.RunTests<'', []> = {
+const test: RunTests<'', []> = {
   valid: [
     "const badlyFormatted = 'code';",
     {
@@ -773,16 +773,16 @@ const test: TSESLint.RunTests<'', []> = {
     },
     {
       code: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { ValidTestCase } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.ValidTestCase<[]> = {
+const test: ValidTestCase<[]> = {
   code: 'const badlyFormatted         = "code"',
 };
       `,
       output: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { ValidTestCase } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.ValidTestCase<[]> = {
+const test: ValidTestCase<[]> = {
   code: "const badlyFormatted = 'code';",
 };
       `,
@@ -794,9 +794,9 @@ const test: TSESLint.ValidTestCase<[]> = {
     },
     {
       code: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { InvalidTestCase } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.InvalidTestCase<'', []> = {
+const test: InvalidTestCase<'', []> = {
   code: 'const badlyFormatted         = "code1"',
   errors: [
     {
@@ -815,9 +815,9 @@ const test: TSESLint.InvalidTestCase<'', []> = {
 };
       `,
       output: `
-import { TSESLint } from '@typescript-eslint/utils';
+import { InvalidTestCase } from '@typescript-eslint/rule-tester';
 
-const test: TSESLint.InvalidTestCase<'', []> = {
+const test: InvalidTestCase<'', []> = {
   code: "const badlyFormatted = 'code1';",
   errors: [
     {
diff --git a/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts b/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
index 44f9f6118bac..78052be73451 100644
--- a/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
@@ -4,12 +4,7 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/prefer-ast-types-enum';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-ast-types-enum', rule, {
   valid: [
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 825eceb29d97..9f27b18b35ec 100644
--- a/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/arrow-parens.test.ts
@@ -4,9 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('arrow-parens');
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('arrow-parens', rule, {
   valid: [
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 054d19140bf7..0050a131761b 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
@@ -4,14 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('no-dupe-args');
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    ecmaFeatures: {},
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-dupe-args', rule, {
   valid: [
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 ba4d5cc1a430..ebac70b7d2f7 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
@@ -3,13 +3,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('no-implicit-globals');
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-implicit-globals', rule, {
   valid: [
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 b015020fa5e1..2958d9d13cfd 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
@@ -4,14 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('no-restricted-globals');
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    ecmaFeatures: {},
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-globals', rule, {
   valid: [
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 a6ce89cc8d24..2180223d1eab 100644
--- a/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/no-undef.test.ts
@@ -4,14 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('no-undef');
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    ecmaFeatures: {},
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-undef', rule, {
   valid: [
@@ -47,8 +40,10 @@ const links = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
 /*globals document, selector */
 const links = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
       `,
-      parserOptions: {
-        lib: ['dom'],
+      languageOptions: {
+        parserOptions: {
+          lib: ['dom'],
+        },
       },
     },
     // https://github.com/eslint/typescript-eslint-parser/issues/437
@@ -155,9 +150,11 @@ let test: unknown;
 function Foo() {}
 <Foo />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -167,9 +164,11 @@ type T = 1;
 function Foo() {}
 <Foo<T> />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -179,9 +178,11 @@ const x = 1;
 function Foo() {}
 <Foo attr={x} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -191,9 +192,11 @@ const x = {};
 function Foo() {}
 <Foo {...x} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -203,9 +206,11 @@ const x = {};
 function Foo() {}
 <Foo>{x}</Foo>;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -214,9 +219,11 @@ function Foo() {}
       code: `
 <div />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -224,9 +231,11 @@ function Foo() {}
       code: `
 <span></span>;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -301,9 +310,11 @@ class Foo {
     },
     {
       code: '<Foo />;',
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -322,9 +333,11 @@ class Foo {
 function Foo() {}
 <Foo attr={x} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -343,9 +356,11 @@ function Foo() {}
 function Foo() {}
 <Foo {...x} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -364,9 +379,11 @@ function Foo() {}
 function Foo() {}
 <Foo<T> />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -385,9 +402,11 @@ function Foo() {}
 function Foo() {}
 <Foo>{x}</Foo>;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
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 e9d8350ff097..5223be374c4a 100644
--- a/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/prefer-const.test.ts
@@ -4,9 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('prefer-const');
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-const', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/eslint-rules/strict.test.ts b/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
index a3146c36d7bd..e25d6f7a44da 100644
--- a/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
+++ b/packages/eslint-plugin/tests/eslint-rules/strict.test.ts
@@ -4,13 +4,7 @@ import { getESLintCoreRule } from '../../src/util/getESLintCoreRule';
 
 const rule = getESLintCoreRule('strict');
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('strict', rule, {
   valid: [
@@ -33,8 +27,10 @@ window.whatevs = {
   },
 };
       `,
-      parserOptions: {
-        sourceType: 'script',
+      languageOptions: {
+        parserOptions: {
+          sourceType: 'script',
+        },
       },
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
index e834112f6ecc..3839469351ce 100644
--- a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/adjacent-overload-signatures';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('adjacent-overload-signatures', rule, {
   valid: [
@@ -15,7 +13,7 @@ function error(b: number);
 function error(ab: string | number) {}
 export { error };
       `,
-      parserOptions: { sourceType: 'module' },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: `
@@ -27,7 +25,7 @@ function mapStateToProps() {}
 function mapDispatchToProps() {}
 export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
       `,
-      parserOptions: { sourceType: 'module' },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     `
 export const foo = 'a',
diff --git a/packages/eslint-plugin/tests/rules/array-type.test.ts b/packages/eslint-plugin/tests/rules/array-type.test.ts
index a9fae5e2be9c..ca71cbdaf15c 100644
--- a/packages/eslint-plugin/tests/rules/array-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/array-type.test.ts
@@ -6,9 +6,7 @@ import type { OptionString } from '../../src/rules/array-type';
 import rule from '../../src/rules/array-type';
 import { areOptionsValid } from '../areOptionsValid';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('array-type', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/await-thenable.test.ts b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
index 27e4309092e8..ebb8c6ef9537 100644
--- a/packages/eslint-plugin/tests/rules/await-thenable.test.ts
+++ b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
@@ -7,12 +7,12 @@ const rootDir = getFixturesRootDir();
 const messageId = 'await';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('await-thenable', rule, {
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 51447bfe6130..8ac62dbb40cb 100644
--- a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/ban-ts-comment';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('ts-expect-error', rule, {
   valid: [
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 01f6ec078a84..062fcd531988 100644
--- a/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-tslint-comment.test.ts
@@ -46,9 +46,7 @@ console.log(woah);
   },
 ]
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('ban-tslint-comment', rule, {
   valid: [
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 9e6519c10db0..902274292572 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/class-literal-property-style';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('class-literal-property-style', rule, {
   valid: [
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 4fba4d557f15..50f527082553 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
@@ -5,97 +5,113 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../../src/rules/class-methods-use-this';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('class-methods-use-this', rule, {
   valid: [
-    { code: 'class A { constructor() {} }', parserOptions: { ecmaVersion: 6 } },
-    { code: 'class A { foo() {this} }', parserOptions: { ecmaVersion: 6 } },
+    {
+      code: 'class A { constructor() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { foo() {this} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
     {
       code: "class A { foo() {this.bar = 'bar';} }",
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() {bar(this);} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A extends B { foo() {super.foo();} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo() { if(true) { return this; } } }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A { static foo() {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: '({ a(){} });',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-    { code: 'class A { static foo() {} }', parserOptions: { ecmaVersion: 6 } },
-    { code: '({ a(){} });', parserOptions: { ecmaVersion: 6 } },
     {
       code: 'class A { foo() { () => this; } }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: '({ a: function () {} });',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-    { code: '({ a: function () {} });', parserOptions: { ecmaVersion: 6 } },
     {
       code: 'class A { foo() {this} bar() {} }',
       options: [{ exceptMethods: ['bar'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { "foo"() { } }',
       options: [{ exceptMethods: ['foo'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { 42() { } }',
       options: [{ exceptMethods: ['42'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'class A { foo = function() {this} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo = () => {this} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo = () => {super.toString} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { static foo = function() {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { static foo = () => {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { #bar() {} }',
       options: [{ exceptMethods: ['#bar'] }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo = function () {} }',
       options: [{ enforceForClassFields: false }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo = () => {} }',
       options: [{ enforceForClassFields: false }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: 'class A { foo() { return class { [this.foo] = 1 }; } }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
+    },
+    {
+      code: 'class A { static {} }',
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
-    { code: 'class A { static {} }', parserOptions: { ecmaVersion: 2022 } },
   ],
   invalid: [
     {
       code: 'class A { foo() {} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -108,7 +124,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo() {/**this**/} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -121,7 +137,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo() {var a = function () {this};} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -134,7 +150,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo() {var a = function () {var b = function(){this}};} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -147,7 +163,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo() {window.this} }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -160,7 +176,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: "class A { foo() {that.this = 'this';} }",
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -173,7 +189,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo() { () => undefined; } }',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -187,7 +203,7 @@ ruleTester.run('class-methods-use-this', rule, {
     {
       code: 'class A { foo() {} bar() {} }',
       options: [{ exceptMethods: ['bar'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -201,7 +217,7 @@ ruleTester.run('class-methods-use-this', rule, {
     {
       code: 'class A { foo() {} hasOwnProperty() {} }',
       options: [{ exceptMethods: ['foo'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -215,7 +231,7 @@ ruleTester.run('class-methods-use-this', rule, {
     {
       code: 'class A { [foo]() {} }',
       options: [{ exceptMethods: ['foo'] }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -229,7 +245,7 @@ ruleTester.run('class-methods-use-this', rule, {
     {
       code: 'class A { #foo() { } foo() {} #bar() {} }',
       options: [{ exceptMethods: ['#foo'] }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           type: AST_NODE_TYPES.FunctionExpression,
@@ -249,7 +265,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: "class A { foo(){} 'bar'(){} 123(){} [`baz`](){} [a](){} [f(a)](){} get quux(){} set[a](b){} *quuux(){} }",
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -309,7 +325,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo = function() {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -321,7 +337,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo = () => {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -333,7 +349,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { #foo = function() {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -345,7 +361,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { #foo = () => {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -357,7 +373,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { #foo() {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -369,7 +385,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { get #foo() {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -381,7 +397,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { set #foo(x) {} }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -393,7 +409,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo () { return class { foo = this }; } }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -405,7 +421,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo () { return function () { foo = this }; } }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
@@ -417,7 +433,7 @@ ruleTester.run('class-methods-use-this', rule, {
     },
     {
       code: 'class A { foo () { return class { static { this; } } } }',
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [
         {
           messageId: 'missingThis',
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 31303569beab..575daef11a8b 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../../src/rules/class-methods-use-this';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('class-methods-use-this', rule, {
   valid: [
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 f21dac8f6399..f7f50ea44524 100644
--- a/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-generic-constructors.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/consistent-generic-constructors';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-generic-constructors', rule, {
   valid: [
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 2b1aa4661a99..30f98f976e5c 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/consistent-indexed-object-style';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-indexed-object-style', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/consistent-return.test.ts b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
index cb74ca29b8c3..b26b70654dee 100644
--- a/packages/eslint-plugin/tests/rules/consistent-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-return.test.ts
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2021,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 fde1ed0d0dd5..29eb3d5297a0 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
@@ -10,7 +10,7 @@ import rule from '../../src/rules/consistent-type-assertions';
 import { dedupeTestCases } from '../dedupeTestCases';
 import { batchedSingleLineTests } from '../RuleTester';
 
-const ruleTester = new RuleTester({ parser: '@typescript-eslint/parser' });
+const ruleTester = new RuleTester();
 
 const ANGLE_BRACKET_TESTS_EXCEPT_CONST_CASE = `
 const x = <Foo>new Generic<int>();
@@ -136,7 +136,7 @@ ruleTester.run('consistent-type-assertions', rule, {
     { code: 'const x = [1] as const;', options: [{ assertionStyle: 'never' }] },
     {
       code: 'const bar = <Foo style={{ bar: 5 } as Bar} />;',
-      parserOptions: { ecmaFeatures: { jsx: true } },
+      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
       options: [
         {
           assertionStyle: 'as',
@@ -533,7 +533,7 @@ ruleTester.run('consistent-type-assertions', rule, {
     {
       code: 'const foo = <Foo style={{ bar: 5 } as Bar} />;',
       output: null,
-      parserOptions: { ecmaFeatures: { jsx: true } },
+      languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
       options: [{ assertionStyle: 'never' }],
       errors: [{ messageId: 'never', line: 1 }],
     },
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 b0a2092994d3..4fa17b04e988 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/consistent-type-definitions';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('consistent-type-definitions', rule, {
   valid: [
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 4d4bb3b5ae1d..209a285c7ee1 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-exports.test.ts
@@ -6,12 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: 'module',
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 a751730cfd34..48d918a6436e 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-imports.test.ts
@@ -19,8 +19,7 @@ const PARSER_OPTION_COMBOS = [
 for (const parserOptions of PARSER_OPTION_COMBOS) {
   describe(`experimentalDecorators: ${parserOptions.experimentalDecorators} + emitDecoratorMetadata: ${parserOptions.emitDecoratorMetadata}`, () => {
     const ruleTester = new RuleTester({
-      parser: '@typescript-eslint/parser',
-      parserOptions,
+      languageOptions: { parserOptions },
     });
 
     ruleTester.run('consistent-type-imports', rule, {
@@ -290,9 +289,11 @@ export const ComponentFoo: React.FC = () => {
   return <div>Foo Foo</div>;
 };
           `,
-          parserOptions: {
-            ecmaFeatures: {
-              jsx: true,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
             },
           },
         },
@@ -304,11 +305,13 @@ export const ComponentFoo: h.FC = () => {
   return <div>Foo Foo</div>;
 };
           `,
-          parserOptions: {
-            ecmaFeatures: {
-              jsx: true,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxPragma: 'h',
             },
-            jsxPragma: 'h',
           },
         },
         {
@@ -319,11 +322,13 @@ export const ComponentFoo: Fragment = () => {
   return <>Foo Foo</>;
 };
           `,
-          parserOptions: {
-            ecmaFeatures: {
-              jsx: true,
+          languageOptions: {
+            parserOptions: {
+              ecmaFeatures: {
+                jsx: true,
+              },
+              jsxFragmentName: 'Fragment',
             },
-            jsxFragmentName: 'Fragment',
           },
         },
         `
@@ -1946,10 +1951,11 @@ function test(foo: Foo) {}
 // the special ignored config case
 describe('experimentalDecorators: true + emitDecoratorMetadata: true', () => {
   const ruleTester = new RuleTester({
-    parser: '@typescript-eslint/parser',
-    parserOptions: {
-      experimentalDecorators: true,
-      emitDecoratorMetadata: true,
+    languageOptions: {
+      parserOptions: {
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+      },
     },
   });
 
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 33be682be7c5..bcad5e8a6d62 100644
--- a/packages/eslint-plugin/tests/rules/default-param-last.test.ts
+++ b/packages/eslint-plugin/tests/rules/default-param-last.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/default-param-last';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('default-param-last', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/dot-notation.test.ts b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
index b799ef3243c3..580ddef5715c 100644
--- a/packages/eslint-plugin/tests/rules/dot-notation.test.ts
+++ b/packages/eslint-plugin/tests/rules/dot-notation.test.ts
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -51,19 +51,28 @@ ruleTester.run('dot-notation', rule, {
       code: "a['lots_of_snake_case'];",
       options: [{ allowPattern: '^[a-z]+(_[a-z]+)+$' }],
     },
-    { code: 'a[`time${range}`];', parserOptions: { ecmaVersion: 6 } },
+    {
+      code: 'a[`time${range}`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
     {
       code: 'a[`while`];',
       options: [{ allowKeywords: false }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'a[`time range`];',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-    { code: 'a[`time range`];', parserOptions: { ecmaVersion: 6 } },
     'a.true;',
     'a.null;',
     'a[undefined];',
     'a[void 0];',
     'a[b()];',
-    { code: 'a[/(?<zero>0)/];', parserOptions: { ecmaVersion: 2018 } },
+    {
+      code: 'a[/(?<zero>0)/];',
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
+    },
 
     {
       code: `
@@ -117,7 +126,7 @@ dingus?.nested.property;
 dingus?.nested['hello'];
       `,
       options: [{ allowIndexSignaturePropertyAccess: true }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
     {
       code: `
@@ -198,7 +207,7 @@ x.pub_prop = 123;
     {
       code: "a['time'];",
       output: 'a.time;',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [{ messageId: 'useDot', data: { key: '"time"' } }],
     },
     {
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 0e8c5182b7d3..ae80f009727b 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/explicit-function-return-type';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-function-return-type', rule, {
   valid: [
@@ -185,45 +183,55 @@ class App {
     {
       code: 'const foo = <button onClick={() => {}} />;',
       options: [{ allowTypedFunctionExpressions: true }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
       options: [{ allowTypedFunctionExpressions: true }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
       options: [{ allowTypedFunctionExpressions: true }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
       options: [{ allowTypedFunctionExpressions: true }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
       options: [{ allowTypedFunctionExpressions: true }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -1177,9 +1185,11 @@ const x: Foo = {
     {
       code: 'const foo = <button onClick={() => {}} />;',
       options: [{ allowTypedFunctionExpressions: false }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -1195,9 +1205,11 @@ const x: Foo = {
     {
       code: 'const foo = <button on={{ click: () => {} }} />;',
       options: [{ allowTypedFunctionExpressions: false }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -1213,9 +1225,11 @@ const x: Foo = {
     {
       code: 'const foo = <Bar>{() => {}}</Bar>;',
       options: [{ allowTypedFunctionExpressions: false }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -1231,9 +1245,11 @@ const x: Foo = {
     {
       code: 'const foo = <Bar>{{ on: () => {} }}</Bar>;',
       options: [{ allowTypedFunctionExpressions: false }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -1249,9 +1265,11 @@ const x: Foo = {
     {
       code: 'const foo = <button {...{ onClick: () => {} }} />;',
       options: [{ allowTypedFunctionExpressions: false }],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
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 4b47ebe7826a..000981497e59 100644
--- a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/explicit-member-accessibility';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-member-accessibility', rule, {
   valid: [
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 b96cb31d74ed..eda213576ff8 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/explicit-module-boundary-types';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('explicit-module-boundary-types', rule, {
   valid: [
@@ -455,8 +453,10 @@ export const Foo: FC = () => (
   <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
 );
       `,
-      parserOptions: {
-        ecmaFeatures: { jsx: true },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
+        },
       },
     },
     {
@@ -465,8 +465,10 @@ export const Foo: JSX.Element = (
   <div a={e => {}} b={function (e) {}} c={function foo(e) {}}></div>
 );
       `,
-      parserOptions: {
-        ecmaFeatures: { jsx: true },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
+        },
       },
     },
     {
diff --git a/packages/eslint-plugin/tests/rules/init-declarations.test.ts b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
index 2667377b2a7e..77ad66e26e8b 100644
--- a/packages/eslint-plugin/tests/rules/init-declarations.test.ts
+++ b/packages/eslint-plugin/tests/rules/init-declarations.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/init-declarations';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('init-declarations', rule, {
   valid: [
@@ -34,17 +32,17 @@ for (var foo in []) {
 for (var foo of []) {
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'let a = true;',
       options: ['always'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'const a = {};',
       options: ['always'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -58,7 +56,7 @@ function foo() {
 }
       `,
       options: ['always'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -72,7 +70,7 @@ function foo() {
 }
       `,
       options: ['always'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -83,17 +81,17 @@ function foo() {
 }
       `,
       options: ['always'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'var foo;',
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'var foo, bar, baz;',
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -103,17 +101,17 @@ function foo() {
 }
       `,
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'let a;',
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'const a = 1;',
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -125,7 +123,7 @@ function foo() {
 }
       `,
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -139,7 +137,7 @@ function foo() {
 }
       `,
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -150,7 +148,7 @@ function foo() {
 }
       `,
       options: ['never'],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'for (var i = 0; i < 1; i++) {}',
@@ -169,7 +167,7 @@ for (var foo of []) {
 }
       `,
       options: ['never', { ignoreForLoopInit: true }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
diff --git a/packages/eslint-plugin/tests/rules/max-params.test.ts b/packages/eslint-plugin/tests/rules/max-params.test.ts
index 054c57363a39..ad6bc8dcdd52 100644
--- a/packages/eslint-plugin/tests/rules/max-params.test.ts
+++ b/packages/eslint-plugin/tests/rules/max-params.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/max-params';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('max-params', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/member-ordering.test.ts b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
index 86abe3784c36..7f04b83b7f3a 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
@@ -4,9 +4,7 @@ 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({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 const grouped: RunTests<MessageIds, Options> = {
   valid: [
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 eb6fff8c1da2..d45c48ee389c 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
@@ -4,9 +4,7 @@ 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({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 const sortedCiWithoutGrouping: RunTests<MessageIds, Options> = {
   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 9146084f2017..7a6f9d2a9d92 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
@@ -4,9 +4,7 @@ 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({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 const sortedWithoutGroupingDefaultOption: RunTests<MessageIds, Options> = {
   valid: [
     // default option + interface + multiple types
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 b876acfd57f8..299f91d05427 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../../src/rules/member-ordering';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('member-ordering-natural-order', rule, {
   valid: [
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 90cc829dc585..af47b390e7e2 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../../src/rules/member-ordering';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('member-ordering-natural-order', rule, {
   valid: [
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 ac4991944e9e..16971f118760 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,14 +1,12 @@
+import type { RunTests } from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import type { MessageIds, Options } from '../../../src/rules/member-ordering';
 import rule from '../../../src/rules/member-ordering';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
-const grouped: TSESLint.RunTests<MessageIds, Options> = {
+const grouped: RunTests<MessageIds, Options> = {
   valid: [
     // optionalityOrder - required-first
     {
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 4651f30ac880..626d6801d696 100644
--- a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/method-signature-style';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('method-signature-style', rule, {
   valid: [
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 7e1207a222d2..3a044a634de2 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention/cases/createTestCases.ts
@@ -1,5 +1,8 @@
+import type {
+  InvalidTestCase,
+  ValidTestCase,
+} from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import type {
   MessageIds,
@@ -80,7 +83,7 @@ const IGNORED_FILTER = {
 type Cases = { code: string[]; options: Omit<Options[0], 'format'> }[];
 
 export function createTestCases(cases: Cases): void {
-  const createValidTestCases = (): TSESLint.ValidTestCase<Options>[] =>
+  const createValidTestCases = (): ValidTestCase<Options>[] =>
     cases.flatMap(test =>
       Object.entries(formatTestNames).flatMap(([formatLoose, names]) =>
         names.valid.flatMap(name => {
@@ -88,7 +91,7 @@ export function createTestCases(cases: Cases): void {
           const createCase = (
             preparedName: string,
             options: Selector,
-          ): TSESLint.ValidTestCase<Options> => ({
+          ): ValidTestCase<Options> => ({
             options: [{ ...options, filter: IGNORED_FILTER }],
             code: `// ${JSON.stringify(options)}\n${test.code
               .map(code => code.replace(REPLACE_REGEX, preparedName))
@@ -230,11 +233,8 @@ export function createTestCases(cases: Cases): void {
       ),
     );
 
-  function createInvalidTestCases(): TSESLint.InvalidTestCase<
-    MessageIds,
-    Options
-  >[] {
-    const newCases: TSESLint.InvalidTestCase<MessageIds, Options>[] = [];
+  function createInvalidTestCases(): InvalidTestCase<MessageIds, Options>[] {
+    const newCases: InvalidTestCase<MessageIds, Options>[] = [];
 
     for (const test of cases) {
       for (const [formatLoose, names] of Object.entries(formatTestNames)) {
@@ -245,7 +245,7 @@ export function createTestCases(cases: Cases): void {
             options: Selector,
             messageId: MessageIds,
             data: Record<string, unknown> = {},
-          ): TSESLint.InvalidTestCase<MessageIds, Options> => {
+          ): InvalidTestCase<MessageIds, Options> => {
             const selectors = Array.isArray(test.options.selector)
               ? test.options.selector
               : [test.options.selector];
@@ -446,9 +446,7 @@ export function createTestCases(cases: Cases): void {
     return newCases;
   }
 
-  const ruleTester = new RuleTester({
-    parser: '@typescript-eslint/parser',
-  });
+  const ruleTester = new RuleTester();
 
   ruleTester.run('naming-convention', rule, {
     invalid: createInvalidTestCases(),
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 0f956df18c07..af3dbc2ba1ee 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
@@ -4,9 +4,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 import rule from '../../../src/rules/naming-convention';
 import { getFixturesRootDir } from '../../RuleTester';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 // only need parserOptions for the `type` option tests
 const rootDir = getFixturesRootDir();
@@ -21,7 +19,7 @@ ruleTester.run('naming-convention', rule, {
       code: `
         const child_process = require('child_process');
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'default',
@@ -58,7 +56,7 @@ ruleTester.run('naming-convention', rule, {
         declare const boolean_camelCase: false | null | undefined;
         declare const boolean_camelCase: true | false | null | undefined;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'variable',
@@ -238,7 +236,7 @@ ruleTester.run('naming-convention', rule, {
           shouldBoo: number;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['variable', 'parameter', 'property', 'accessor'],
@@ -254,7 +252,7 @@ ruleTester.run('naming-convention', rule, {
           private readonly FooBoo: boolean;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['property', 'accessor'],
@@ -286,7 +284,7 @@ ruleTester.run('naming-convention', rule, {
           private VanFooBar: number;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['property', 'accessor'],
@@ -346,7 +344,7 @@ ruleTester.run('naming-convention', rule, {
           readonly FOO: string;
         };
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'typeProperty',
@@ -797,7 +795,7 @@ ruleTester.run('naming-convention', rule, {
           },
         };
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -840,7 +838,7 @@ ruleTester.run('naming-convention', rule, {
           }
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -863,7 +861,7 @@ ruleTester.run('naming-convention', rule, {
         async function async_bar2() {}
         const async_bar3 = async function async_bar4() {};
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -899,7 +897,7 @@ ruleTester.run('naming-convention', rule, {
           public abstract override some_method_override2(): string;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -922,7 +920,7 @@ ruleTester.run('naming-convention', rule, {
           #some_method() {}
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -937,7 +935,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import * as FooBar from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -952,7 +950,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import fooBar from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -967,7 +965,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import { default as fooBar } from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -982,7 +980,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import { foo_bar } from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -1012,7 +1010,7 @@ ruleTester.run('naming-convention', rule, {
       code: `
         const child_process = require('child_process');
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'default',
@@ -1073,7 +1071,7 @@ ruleTester.run('naming-convention', rule, {
           prefix: ['boolean_'],
         },
       ],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: Array(19).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
@@ -1095,7 +1093,7 @@ ruleTester.run('naming-convention', rule, {
           prefix: ['function_'],
         },
       ],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: Array(4).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
@@ -1126,7 +1124,7 @@ ruleTester.run('naming-convention', rule, {
           prefix: ['array_'],
         },
       ],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: Array(8).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
@@ -1336,7 +1334,7 @@ ruleTester.run('naming-convention', rule, {
           prefix: ['my', 'My'],
         },
       ],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: Array(3).fill({ messageId: 'doesNotMatchFormatTrimmed' }),
     },
     {
@@ -1358,7 +1356,7 @@ ruleTester.run('naming-convention', rule, {
       code: `
         function my_foo_bar() {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['variable', 'function'],
@@ -1377,7 +1375,7 @@ ruleTester.run('naming-convention', rule, {
 
         export const { otherConstant } = SomeClass;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         { selector: 'property', format: ['PascalCase'] },
         { selector: 'variable', format: ['camelCase'] },
@@ -1395,7 +1393,7 @@ ruleTester.run('naming-convention', rule, {
           Bar(Baz: string): void;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [{ selector: 'parameter', format: ['camelCase'] }],
       errors: [
         {
@@ -1785,7 +1783,7 @@ ruleTester.run('naming-convention', rule, {
           public abstract async ASYNC_BAR(): number;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -1859,7 +1857,7 @@ ruleTester.run('naming-convention', rule, {
           },
         };
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -1916,7 +1914,7 @@ ruleTester.run('naming-convention', rule, {
         // ❌ error
         const asyncBar5 = async function async_bar6() {};
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'variableLike',
@@ -1961,7 +1959,7 @@ ruleTester.run('naming-convention', rule, {
         // ❌ error
         const async_bar3 = async function ASYNC_BAR4() {};
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'variableLike',
@@ -2001,7 +1999,7 @@ ruleTester.run('naming-convention', rule, {
           public override someAttributeOverride = 1;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -2036,7 +2034,7 @@ ruleTester.run('naming-convention', rule, {
           }
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -2072,7 +2070,7 @@ ruleTester.run('naming-convention', rule, {
           public override set someSetterOverride(val: string);
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -2114,7 +2112,7 @@ ruleTester.run('naming-convention', rule, {
           #second_private_field = 1;
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -2156,7 +2154,7 @@ ruleTester.run('naming-convention', rule, {
           #second_private_method() {}
         }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: 'memberLike',
@@ -2189,7 +2187,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import * as fooBar from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -2214,7 +2212,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import FooBar from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
@@ -2239,7 +2237,7 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: "import { default as foo_bar } from 'foo_bar';",
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [
         {
           selector: ['import'],
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 6bc1d719e976..05d56823bdad 100644
--- a/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
@@ -3,9 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-array-constructor';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 const messageId = 'useLiteral';
 
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 ac803cb5b2f8..ed5a7cba7c65 100644
--- a/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-delete.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 a16b08056bdb..67c2a7ebddaa 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
@@ -5,11 +5,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 ede6c266ad0f..19f3cfec601d 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
@@ -7,9 +7,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-confusing-non-null-assertion';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-confusing-non-null-assertion', rule, {
   valid: [
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 921ee833894c..24301c213bce 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
@@ -5,10 +5,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 9639917baef4..cc8ba8f430f4 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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-dupe-class-members';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-dupe-class-members', rule, {
   valid: [
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 809248f714f9..3273d245e276 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-duplicate-enum-values';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-duplicate-enum-values', rule, {
   valid: [
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 376e3fa22683..cc0f8511951d 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
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 2bab182b7634..c5fcdcf2d888 100644
--- a/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 1f335765c675..0ca7f35b2f2c 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-empty-function';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-function', rule, {
   valid: [
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 50946c80c535..cc87f61409a3 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-empty-interface';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-interface', rule, {
   valid: [
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 8a640f64ceee..5bb17a31f868 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-empty-object-type';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-empty-object-type', rule, {
   valid: [
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 2dc995cb66f0..4b377543cb7d 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -1,15 +1,16 @@
+import type {
+  InvalidTestCase,
+  SuggestionOutput,
+} from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import type { MessageIds, Options } from '../../src/rules/no-explicit-any';
 import rule from '../../src/rules/no-explicit-any';
 
-type InvalidTestCase = TSESLint.InvalidTestCase<MessageIds, Options>;
-type SuggestionOutput = TSESLint.SuggestionOutput<MessageIds>;
+type RuleInvalidTestCase = InvalidTestCase<MessageIds, Options>;
+type RuleSuggestionOutput = SuggestionOutput<MessageIds>;
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-explicit-any', rule, {
   valid: [
@@ -1196,9 +1197,9 @@ const test = <T extends Partial<never>>() => {};
           },
         ],
       },
-    ] as InvalidTestCase[]
-  ).reduce<InvalidTestCase[]>((acc, testCase) => {
-    const suggestions = (code: string): SuggestionOutput[] => [
+    ] as RuleInvalidTestCase[]
+  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
+    const suggestions = (code: string): RuleSuggestionOutput[] => [
       {
         messageId: 'suggestUnknown',
         output: code.replace(/any/, 'unknown'),
@@ -1231,7 +1232,7 @@ const test = <T extends Partial<never>>() => {};
           line: err.line + 1,
           suggestions:
             err.suggestions?.map(
-              (s): SuggestionOutput => ({
+              (s): RuleSuggestionOutput => ({
                 ...s,
                 output: `// fixToUnknown: true\n${s.output}`,
               }),
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 7b9ab5338afe..0569712f9948 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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-extra-non-null-assertion';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-extra-non-null-assertion', rule, {
   valid: [
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 6d661f430fdb..885f03290dc1 100644
--- a/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
@@ -13,9 +13,7 @@ const onlyConstructor = {
   messageId: 'onlyConstructor' as const,
 };
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-extraneous-class', rule, {
   valid: [
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 0b9ec5e46f79..a2d68b073b79 100644
--- a/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-floating-promises', rule, {
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 35b1e1ae23a9..d55ae851c446 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
@@ -5,12 +5,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-for-in-array', rule, {
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 3b6c11c025df..c908df644c81 100644
--- a/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
@@ -5,13 +5,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    tsconfigRootDir: rootDir,
-    ecmaVersion: 2015,
-    sourceType: 'module',
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-implied-eval', rule, {
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 f638d22fafa0..b1d0e3885337 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-import-type-side-effects';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-import-type-side-effects', rule, {
   valid: [
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 fe91490df3e7..fa1b7f4ffa37 100644
--- a/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
@@ -1,5 +1,5 @@
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-inferrable-types';
 import type {
@@ -73,29 +73,26 @@ const testCases = [
 const validTestCases = flatten(
   testCases.map(c => c.code.map(code => `const a = ${code}`)),
 );
-const invalidTestCases: TSESLint.InvalidTestCase<MessageIds, Options>[] =
-  flatten(
-    testCases.map(cas =>
-      cas.code.map(code => ({
-        code: `const a: ${cas.type} = ${code}`,
-        output: `const a = ${code}`,
-        errors: [
-          {
-            messageId: 'noInferrableType',
-            data: {
-              type: cas.type,
-            },
-            line: 1,
-            column: 7,
+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',
+          data: {
+            type: cas.type,
           },
-        ],
-      })),
-    ),
-  );
+          line: 1,
+          column: 7,
+        },
+      ],
+    })),
+  ),
+);
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-inferrable-types', rule, {
   valid: [
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 9e95b2d2dead..b54a0af5fdf8 100644
--- a/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-invalid-this.test.ts
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-invalid-this';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-});
+const ruleTester = new RuleTester();
 
 const errors = [
   { messageId: 'unexpectedThis' as const },
@@ -458,8 +453,10 @@ z(x => console.log(x, this));
 console.log(this);
 z(x => console.log(x, this));
       `,
-      parserOptions: {
-        ecmaFeatures: { globalReturn: true },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
       },
       errors,
     },
@@ -533,8 +530,10 @@ return function () {
   z(x => console.log(x, this));
 };
       `,
-      parserOptions: {
-        ecmaFeatures: { globalReturn: true },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: { globalReturn: true },
+        },
       },
       errors,
     },
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 7252bd3501c2..8eae0f307e81 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-invalid-void-type';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('allowInGenericTypeArguments: false', rule, {
   valid: [
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 29ccaa62b1f0..613af3dc04ec 100644
--- a/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-loop-func.test.ts
@@ -3,9 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-loop-func';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-loop-func', rule, {
   valid: [
@@ -22,8 +20,10 @@ for (let i = 0; i < 10; i += 1) {
   someArray = someArray.filter((item: MyType) => !!item);
 }
       `,
-      globals: {
-        MyType: 'readonly',
+      languageOptions: {
+        globals: {
+          MyType: 'readonly',
+        },
       },
     },
     {
@@ -33,8 +33,10 @@ for (let i = 0; i < 10; i += 1) {
   someArray = someArray.filter((item: MyType) => !!item);
 }
       `,
-      globals: {
-        MyType: 'writable',
+      languageOptions: {
+        globals: {
+          MyType: 'writable',
+        },
       },
     },
     `
@@ -81,7 +83,7 @@ for (var x of xs.filter(function (x) {
 })) {
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // no refers to variables that declared on upper scope.
@@ -101,7 +103,7 @@ for (var i of {}) {
   (function () {});
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // functions which are using unmodified variables are OK.
@@ -113,7 +115,7 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -124,7 +126,7 @@ for (let i in {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -134,7 +136,7 @@ for (const i of {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -143,7 +145,7 @@ for (let i = 0; i < 10; ++i) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -154,7 +156,7 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -165,7 +167,7 @@ for (let i in {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -176,7 +178,7 @@ for (let i of {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -189,7 +191,7 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -202,7 +204,7 @@ for (let i in {}) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -215,7 +217,7 @@ for (let i of {}) {
   };
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -226,7 +228,7 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -237,7 +239,7 @@ for (let i in {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -248,7 +250,7 @@ for (let i of {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: [
@@ -261,13 +263,13 @@ for (let i of {}) {
         '}',
         'result.__default = 6;',
       ].join('\n'),
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: ['while (true) {', '    (function() { a; });', '}', 'let a;'].join(
         '\n',
       ),
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
   ],
   invalid: [
@@ -329,7 +331,7 @@ for (var i of {}) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -346,7 +348,7 @@ for (var i = 0; i < l; i++) {
   };
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -470,7 +472,7 @@ for (let i = 0; i < l; i++) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -489,7 +491,7 @@ for (let i in {}) {
   a = 1;
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -508,7 +510,7 @@ for (let i of {}) {
 }
 a = 1;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -529,7 +531,7 @@ for (let i = 0; i < l; i++) {
   a = 1;
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -550,7 +552,7 @@ for (let i in {}) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -571,7 +573,7 @@ for (let i of {}) {
 }
 a = 1;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -587,7 +589,7 @@ for (var i = 0; i < 10; ++i) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -608,7 +610,7 @@ for (let x of xs) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -627,7 +629,7 @@ for (var x of xs) {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -644,7 +646,7 @@ for (var x of xs) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -663,7 +665,7 @@ for (let x of xs) {
   });
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -682,7 +684,7 @@ for (let x of xs) {
   a = 1;
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -704,7 +706,7 @@ for (let x of xs) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
@@ -726,7 +728,7 @@ function foo() {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'unsafeRefs',
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 9ccfa68ca4cf..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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-loss-of-precision';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-loss-of-precision', rule, {
   valid: [
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 fecfd8b45e5b..b50c25224e01 100644
--- a/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-magic-numbers';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-magic-numbers', rule, {
   valid: [
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 618f05932199..c170f576b577 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
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-meaningless-void-operator', rule, {
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 4e251d7f0477..d6bc3b9210c6 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-misused-new';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-misused-new', rule, {
   valid: [
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 0db6c0831b04..45f608f4a8d5 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-misused-promises', rule, {
@@ -245,9 +245,11 @@ type O = {
 const Component = (obj: O) => null;
 <Component bool func={async () => 10} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -256,9 +258,11 @@ const Component = (obj: O) => null;
 const Component: any = () => null;
 <Component func={async () => 10} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -324,9 +328,11 @@ declare function Component(props: Props): any;
 
 const _ = <Component onEvent={async () => {}} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -493,9 +499,11 @@ foo(bar);
 
         <ASTViewer onSelectNode={onSelectFn} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       options: [{ checksVoidReturn: { attributes: true } }],
@@ -954,9 +962,11 @@ type O = {
 const Component = (obj: O) => null;
 <Component func={async () => 0} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -974,9 +984,11 @@ type O = {
 const Component = (obj: O) => null;
 <Component func={async () => 0} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -996,9 +1008,11 @@ const g = async () => 'foo';
 const Component = (obj: O) => null;
 <Component func={g} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
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 23ffc3568c5e..9a64318705d4 100644
--- a/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-mixed-enums.test.ts
@@ -5,11 +5,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-mixed-enums', rule, {
diff --git a/packages/eslint-plugin/tests/rules/no-namespace.test.ts b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
index a981ca59b3c6..a4e7713413cf 100644
--- a/packages/eslint-plugin/tests/rules/no-namespace.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-namespace';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-namespace', rule, {
   valid: [
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 789fd1a8727a..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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-non-null-asserted-nullish-coalescing';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-nullish-coalescing', rule, {
   valid: [
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 a9fda0210fdf..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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-non-null-asserted-optional-chain';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-asserted-optional-chain', rule, {
   valid: [
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 d1a93c058d12..454a9e4bde51 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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-non-null-assertion';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-non-null-assertion', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
index d53c023c4352..55c263246845 100644
--- a/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-redeclare.test.ts
@@ -4,10 +4,12 @@ import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import rule from '../../src/rules/no-redeclare';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
+  languageOptions: {
+    parserOptions: {
+      ecmaVersion: 6,
+      sourceType: 'script',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-redeclare', rule, {
@@ -30,43 +32,45 @@ if (true) {
   let b = 3;
 }
       `,
-      parserOptions: {
-        ecmaVersion: 6,
+      languageOptions: {
+        parserOptions: {
+          ecmaVersion: 6,
+        },
       },
     },
     { code: 'var Object = 0;', options: [{ builtinGlobals: false }] },
     {
       code: 'var Object = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { sourceType: 'module' },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: 'var Object = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaFeatures: { globalReturn: true } },
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
     },
     {
       code: 'var top = 0;',
-      env: { browser: true },
       options: [{ builtinGlobals: false }],
     },
     { code: 'var top = 0;', options: [{ builtinGlobals: true }] },
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaFeatures: { globalReturn: true } },
-      env: { browser: true },
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
     },
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { sourceType: 'module' },
-      env: { browser: true },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
     },
     {
       code: 'var self = 1;',
       options: [{ builtinGlobals: true }],
-      env: { browser: false },
     },
     // https://github.com/eslint/typescript-eslint-parser/issues/535
     `
@@ -145,7 +149,7 @@ namespace A {}
 var a = 3;
 var a = 10;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'redeclared',
@@ -293,7 +297,7 @@ var a = 15;
 var a;
 var a;
       `,
-      parserOptions: { sourceType: 'module' },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
       errors: [
         {
           messageId: 'redeclared',
@@ -309,7 +313,7 @@ var a;
 export var a;
 var a;
       `,
-      parserOptions: { sourceType: 'module' },
+      languageOptions: { parserOptions: { sourceType: 'module' } },
       errors: [
         {
           messageId: 'redeclared',
@@ -336,6 +340,9 @@ var a;
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
+      languageOptions: {
+        globals: { top: 'readonly' },
+      },
       errors: [
         {
           messageId: 'redeclaredAsBuiltin',
@@ -345,7 +352,6 @@ var a;
           type: AST_NODE_TYPES.Identifier,
         },
       ],
-      env: { browser: true },
     },
     {
       code: `
@@ -353,7 +359,7 @@ var a;
 var { a = 0, b: Object = 0 } = {};
       `,
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'redeclared',
@@ -377,7 +383,9 @@ var a;
 var { a = 0, b: Object = 0 } = {};
       `,
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [
         {
           messageId: 'redeclared',
@@ -394,7 +402,9 @@ var a;
 var { a = 0, b: Object = 0 } = {};
       `,
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaVersion: 6, ecmaFeatures: { globalReturn: true } },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, ecmaFeatures: { globalReturn: true } },
+      },
       errors: [
         {
           messageId: 'redeclared',
@@ -411,7 +421,7 @@ var a;
 var { a = 0, b: Object = 0 } = {};
       `,
       options: [{ builtinGlobals: false }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'redeclared',
@@ -458,8 +468,11 @@ type T = 2;
 type NodeListOf = 1;
       `,
       options: [{ builtinGlobals: true }],
-      parserOptions: {
-        lib: ['dom'],
+      languageOptions: {
+        parserOptions: {
+          lib: ['dom'],
+          sourceType: 'script',
+        },
       },
       errors: [
         {
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 b0a9ca844da9..0e48dbd1c24e 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
@@ -5,12 +5,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2021,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-redundant-type-constituents', rule, {
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 0a9e56fc8520..822456fef3a5 100644
--- a/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-require-imports';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-require-imports', rule, {
   valid: [
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 0345cfa17eca..1c8a93108e5c 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-imports.test.ts
@@ -3,9 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-restricted-imports';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-imports', rule, {
   valid: [
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 28bf5435828a..db4bfdf07f1f 100644
--- a/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-restricted-types.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-restricted-types';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-restricted-types', rule, {
   valid: [
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 1b81df4435a1..a7194566e267 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
@@ -7,9 +7,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../../src/rules/no-shadow';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-shadow', rule, {
   valid: [
@@ -44,9 +42,12 @@ setTimeout(() => {
   b(a);
 }, 0);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
+    },
+    {
+      code: 'class A {}',
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
-    { code: 'class A {}', parserOptions: { ecmaVersion: 6 } },
     {
       code: `
 class A {
@@ -55,7 +56,7 @@ class A {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -63,7 +64,7 @@ class A {
   var A = class A {};
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -72,7 +73,7 @@ class A {
 }
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     }, // this case reports `no-redeclare`, not shadowing.
     {
       code: `
@@ -82,7 +83,7 @@ var a;
 let a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -92,7 +93,7 @@ let a;
 var a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -102,7 +103,7 @@ var a;
 function a() {}
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -112,7 +113,7 @@ function a() {}
 const a = 1;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -122,7 +123,7 @@ const a = 1;
 var a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -132,7 +133,7 @@ var a;
 function a() {}
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -142,7 +143,7 @@ function foo() {
 let a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -152,7 +153,7 @@ function foo() {
 var a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -162,7 +163,7 @@ function foo() {
 function a() {}
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -172,7 +173,7 @@ function foo() {
 let a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -182,7 +183,7 @@ function foo() {
 var a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -192,7 +193,7 @@ function foo() {
 function a() {}
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -200,7 +201,7 @@ function foo(a) {}
 let a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -208,7 +209,7 @@ function foo(a) {}
 var a;
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -216,7 +217,7 @@ function foo(a) {}
 function a() {}
       `,
       options: [{ hoist: 'never' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -225,7 +226,7 @@ function a() {}
 }
 let a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -234,7 +235,7 @@ let a;
 }
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -243,7 +244,7 @@ var a;
 }
 const a = 1;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -252,7 +253,7 @@ const a = 1;
 }
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -261,7 +262,7 @@ function foo() {
 }
 let a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -270,7 +271,7 @@ function foo() {
 }
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -279,7 +280,7 @@ function foo() {
 }
 let a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -288,21 +289,21 @@ function foo() {
 }
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo(a) {}
 let a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 function foo(a) {}
 var a;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     `
 function foo() {
@@ -315,13 +316,10 @@ function foo() {
   var top = 0;
 }
       `,
-      env: { browser: true },
     },
-    { code: 'var Object = 0;', options: [{ builtinGlobals: true }] },
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      env: { browser: true },
     },
     {
       code: `
@@ -363,7 +361,7 @@ var a = x => {
   };
 };
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -495,7 +493,7 @@ var x = 1;
   let x = 2;
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -515,7 +513,7 @@ let x = 1;
   const x = 2;
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -535,7 +533,7 @@ let x = 1;
 }
 function a() {}
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -555,7 +553,7 @@ function a() {}
 }
 function a() {}
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -575,7 +573,7 @@ function foo() {
 }
 function a() {}
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -595,7 +593,7 @@ function foo() {
 }
 function a() {}
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -613,7 +611,7 @@ function a() {}
 function foo(a) {}
 function a() {}
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -634,7 +632,7 @@ function a() {}
 let a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -655,7 +653,7 @@ let a;
 var a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -676,7 +674,7 @@ var a;
 function a() {}
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -697,7 +695,7 @@ function a() {}
 const a = 1;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -718,7 +716,7 @@ const a = 1;
 var a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -739,7 +737,7 @@ var a;
 function a() {}
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -760,7 +758,7 @@ function foo() {
 let a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -781,7 +779,7 @@ function foo() {
 var a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -802,7 +800,7 @@ function foo() {
 function a() {}
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -823,7 +821,7 @@ function foo() {
 let a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -844,7 +842,7 @@ function foo() {
 var a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -865,7 +863,7 @@ function foo() {
 function a() {}
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -884,7 +882,7 @@ function foo(a) {}
 let a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -903,7 +901,7 @@ function foo(a) {}
 var a;
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -922,7 +920,7 @@ function foo(a) {}
 function a() {}
       `,
       options: [{ hoist: 'all' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -959,7 +957,7 @@ function a() {}
   class a {}
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -996,7 +994,7 @@ function a() {}
   (class a {});
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -1055,7 +1053,7 @@ function a() {}
   };
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -1096,7 +1094,7 @@ function a() {}
   };
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -1119,7 +1117,7 @@ function a() {}
   };
 })();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -1140,7 +1138,7 @@ class A {
   }
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           messageId: 'noShadow',
@@ -1206,7 +1204,7 @@ function foo() {
 }
       `,
       options: [{ builtinGlobals: true }],
-      env: { browser: true },
+      languageOptions: { globals: { top: 'readonly' } },
       errors: [
         {
           messageId: 'noShadowGlobal',
@@ -1220,7 +1218,9 @@ function foo() {
     {
       code: 'var Object = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [
         {
           messageId: 'noShadowGlobal',
@@ -1234,8 +1234,10 @@ function foo() {
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      env: { browser: true },
+      languageOptions: {
+        globals: { top: 'readonly' },
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [
         {
           messageId: 'noShadowGlobal',
@@ -1249,7 +1251,9 @@ function foo() {
     {
       code: 'var Object = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaFeatures: { globalReturn: true } },
+      languageOptions: {
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
       errors: [
         {
           messageId: 'noShadowGlobal',
@@ -1263,8 +1267,10 @@ function foo() {
     {
       code: 'var top = 0;',
       options: [{ builtinGlobals: true }],
-      parserOptions: { ecmaFeatures: { globalReturn: true } },
-      env: { browser: true },
+      languageOptions: {
+        globals: { top: 'readonly' },
+        parserOptions: { ecmaFeatures: { globalReturn: true } },
+      },
       errors: [
         {
           messageId: 'noShadowGlobal',
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 2cbacdffb341..571beefd4804 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
@@ -3,12 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../../src/rules/no-shadow';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-shadow TS tests', rule, {
   valid: [
@@ -98,8 +93,10 @@ const x = 1;
 type Foo = 1;
       `,
       options: [{ ignoreTypeValueShadow: true }],
-      globals: {
-        Foo: 'writable',
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
+        },
       },
     },
     {
@@ -112,8 +109,10 @@ type Foo = 1;
           builtinGlobals: false,
         },
       ],
-      globals: {
-        Foo: 'writable',
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
+        },
       },
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/2360
@@ -141,8 +140,10 @@ type Fn = (Foo: string) => typeof Foo;
           builtinGlobals: false,
         },
       ],
-      globals: {
-        Foo: 'writable',
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
+        },
       },
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/6098
@@ -354,7 +355,7 @@ const person = [].find(match);
     {
       code: "const person = { ...people.find(person => person.firstName.startsWith('s')) };",
       options: [{ ignoreOnInitialization: true }],
-      parserOptions: { ecmaVersion: 2021 },
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
@@ -365,7 +366,7 @@ const person = {
 };
       `,
       options: [{ ignoreOnInitialization: true }],
-      parserOptions: { ecmaVersion: 2021 },
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
@@ -502,8 +503,10 @@ type Foo = 1;
           builtinGlobals: true,
         },
       ],
-      globals: {
-        Foo: 'writable',
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
+        },
       },
       errors: [
         {
@@ -542,8 +545,10 @@ type Fn = (Foo: string) => typeof Foo;
           builtinGlobals: true,
         },
       ],
-      globals: {
-        Foo: 'writable',
+      languageOptions: {
+        globals: {
+          Foo: 'writable',
+        },
       },
       errors: [
         {
@@ -805,7 +810,7 @@ declare module 'bar' {
 let x = foo((x, y) => {});
 let y;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       options: [{ hoist: 'all' }],
       errors: [
         {
@@ -838,8 +843,10 @@ function foo<T extends (...args: any[]) => any>(fn: T, args: any[]) {}
           builtinGlobals: true,
         },
       ],
-      globals: {
-        args: 'writable',
+      languageOptions: {
+        globals: {
+          args: 'writable',
+        },
       },
       errors: [
         {
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 6df8dbb38c74..6de32ec853f8 100644
--- a/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
@@ -16,9 +16,7 @@ const arrayDestructureError = {
   type: AST_NODE_TYPES.ArrayPattern,
 };
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-this-alias', rule, {
   valid: [
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 7222cb8b907b..500b9b30d7bc 100644
--- a/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-type-alias';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-type-alias', rule, {
   valid: [
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 897f616fc571..dbac9d751fe9 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
@@ -5,11 +5,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 5b43fab4b275..395fdb4a03d5 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
@@ -1,8 +1,8 @@
-import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 import type {
   InvalidTestCase,
   TestCaseError,
-} from '@typescript-eslint/utils/ts-eslint';
+} from '@typescript-eslint/rule-tester';
+import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 import * as path from 'path';
 
 import type {
@@ -15,10 +15,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -591,10 +592,12 @@ declare const foo: Foo;
 const key = '1' as BrandedKey;
 foo?.[key]?.trim();
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     {
@@ -606,10 +609,12 @@ declare const foo: Foo;
 declare const key: Key;
 foo?.[key].trim();
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     {
@@ -624,10 +629,12 @@ function Foo(outer: Outer, key: BrandedKey): number | undefined {
   return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     {
@@ -643,10 +650,12 @@ function Foo(outer: Outer, key: Foo): number | undefined {
   return outer.inner?.[key]?.charCodeAt(0);
 }
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     {
@@ -658,10 +667,12 @@ declare const foo: Foo;
 declare const key: Key;
 foo?.[key]?.trim();
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     `
@@ -721,8 +732,10 @@ if (x) {
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
         },
       ],
-      parserOptions: {
-        tsconfigRootDir: path.join(rootPath, 'unstrict'),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
       },
     },
     `
@@ -775,14 +788,14 @@ foo[key] ??= 1;
 declare const foo: { bar?: number };
 foo.bar ??= 1;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
 declare const foo: { bar: { baz?: number } };
 foo['bar'].baz ??= 1;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -791,7 +804,7 @@ type Key = 'baz' | 'qux';
 declare const key: Key;
 foo.bar[key] ??= 1;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     `
 declare let foo: number;
@@ -824,10 +837,12 @@ function getElem(dict: Record<string, { foo: string }>, key: string) {
   }
 }
       `,
-      parserOptions: {
-        project: './tsconfig.noUncheckedIndexedAccess.json',
-        projectService: false,
-        tsconfigRootDir: getFixturesRootDir(),
+      languageOptions: {
+        parserOptions: {
+          project: './tsconfig.noUncheckedIndexedAccess.json',
+          projectService: false,
+          tsconfigRootDir: getFixturesRootDir(),
+        },
       },
     },
     `
@@ -853,7 +868,7 @@ declare const foo: Foo;
 foo?.['bar']()?.toExponential();
     `,
     {
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
       code: `
 class ConsistentRand {
   #rand?: number;
@@ -1936,8 +1951,10 @@ if (x) {
           column: 5,
         },
       ],
-      parserOptions: {
-        tsconfigRootDir: path.join(rootPath, 'unstrict'),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
       },
     },
     {
@@ -2136,7 +2153,7 @@ declare const foo: { bar: number };
 foo.bar ??= 1;
       `,
       output: null,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
       errors: [
         {
           messageId: 'neverNullish',
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 68001a622e39..f24a08f9ff6a 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
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-unnecessary-parameter-property-assignment';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-parameter-property-assignment', rule, {
   valid: [
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 d03236ac2189..3bcded433ff4 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
@@ -7,11 +7,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 e7137ada9073..1dd79982f50f 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
@@ -7,10 +7,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 0540957f4db4..81ecfd23060f 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
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 a0d93fce386f..4adcaa2ca7f2 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
@@ -5,13 +5,13 @@ import rule from '../../src/rules/no-unnecessary-type-assertion';
 
 const rootDir = path.resolve(__dirname, '../fixtures/');
 const ruleTester = new RuleTester({
-  parserOptions: {
-    project: './tsconfig.json',
-    projectService: false,
-    sourceType: 'module',
-    tsconfigRootDir: rootDir,
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.json',
+      projectService: false,
+      tsconfigRootDir: rootDir,
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 const optionsWithOnUncheckedIndexedAccess = {
@@ -201,9 +201,11 @@ function Test(props: { id?: null | string | number }) {
   return <div key={props.id!} />;
 }
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -288,7 +290,7 @@ function bar(items: string[]) {
   }
 }
       `,
-      parserOptions: optionsWithOnUncheckedIndexedAccess,
+      languageOptions: { parserOptions: optionsWithOnUncheckedIndexedAccess },
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/8737
     `
@@ -308,7 +310,7 @@ declare const foo: {
 };
 const bar = foo.a as string;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -317,7 +319,7 @@ declare const foo: {
 };
 const bar = foo.a as string;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -326,7 +328,7 @@ declare const foo: {
 };
 const bar = foo.a as string | undefined;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -335,7 +337,7 @@ declare const foo: {
 };
 const bar = foo.a as string | undefined;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -344,7 +346,7 @@ declare const foo: {
 };
 const bar = foo.a as string | undefined | bigint;
       `,
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
   ],
 
@@ -684,9 +686,11 @@ function Test(props: { id?: string | number }) {
           line: 9,
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -1043,7 +1047,7 @@ const bar = foo.a;
           column: 13,
         },
       ],
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
     {
       code: `
@@ -1065,7 +1069,7 @@ const bar = foo.a;
           column: 13,
         },
       ],
-      parserOptions: optionsWithExactOptionalPropertyTypes,
+      languageOptions: { parserOptions: optionsWithExactOptionalPropertyTypes },
     },
   ],
 });
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 2b1f6841f2c1..3ad032bed2ce 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
@@ -2,12 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-unnecessary-type-constraint';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-unnecessary-type-constraint', rule, {
   valid: [
@@ -122,9 +117,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -186,9 +183,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -210,9 +209,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -234,9 +235,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -258,9 +261,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -282,9 +287,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -320,9 +327,11 @@ function data<T extends TODO>() {}
           ],
         },
       ],
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
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 97c29828772b..e5a7558e2f49 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
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 01b97cfb34b1..731bd440879b 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
@@ -4,10 +4,11 @@ import rule from '../../src/rules/no-unsafe-argument';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.json',
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
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 163286853e41..19357a7adf11 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
@@ -1,5 +1,5 @@
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-unsafe-assignment';
 import type {
@@ -10,7 +10,7 @@ import { getFixturesRootDir } from '../RuleTester';
 
 type Options = InferOptionsTypeFromRule<typeof rule>;
 type MessageIds = InferMessageIdsTypeFromRule<typeof rule>;
-type InvalidTest = TSESLint.InvalidTestCase<MessageIds, Options>;
+type InvalidTest = InvalidTestCase<MessageIds, Options>;
 
 function assignmentTest(
   tests: [string, number, number, boolean?][],
@@ -63,11 +63,12 @@ function assignmentTest(
 }
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.noImplicitThis.json',
-    projectService: false,
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.noImplicitThis.json',
+      projectService: false,
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
@@ -124,9 +125,11 @@ type Props = { a: string };
 declare function Foo(props: Props): never;
 <Foo a={'foo'} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -136,9 +139,11 @@ declare function Foo(props: Props): never;
 declare function Foo(props: { a: string }): never;
 <Foo a="foo" />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -147,9 +152,11 @@ declare function Foo(props: { a: string }): never;
 declare function Foo(props: { a: string }): never;
 <Foo a={} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -405,9 +412,11 @@ type Props = { a: string };
 declare function Foo(props: Props): never;
 <Foo a={1 as any} />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
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 c25fb3559a70..1a26a4ef3d33 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -4,11 +4,12 @@ import rule from '../../src/rules/no-unsafe-call';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.noImplicitThis.json',
-    projectService: false,
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.noImplicitThis.json',
+      projectService: false,
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
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 82be9996f209..8d724ef6f1c2 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
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 9a7f49dc3ecc..c50bbbde0a74 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
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('strict-enums-comparison', rule, {
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 88e2d932a07b..75c116a66aa5 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-unsafe-function-type';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-unsafe-function-type', rule, {
   valid: [
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 969385d74c4b..de597dd9ba8e 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
@@ -4,11 +4,12 @@ import rule from '../../src/rules/no-unsafe-member-access';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.noImplicitThis.json',
-    projectService: false,
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.noImplicitThis.json',
+      projectService: false,
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
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 30af0b8e5127..4994ca5dfa8c 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
@@ -4,11 +4,12 @@ import rule from '../../src/rules/no-unsafe-return';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.noImplicitThis.json',
-    projectService: false,
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.noImplicitThis.json',
+      projectService: false,
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
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 d3ea7b067fbc..db0c7d2defa3 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
@@ -5,12 +5,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('no-unsafe-unary-minus', rule, {
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 44476c4c642f..5587aef55183 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
@@ -1,22 +1,21 @@
+import type { TestCaseError } from '@typescript-eslint/rule-tester';
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-unused-expressions';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    ecmaFeatures: {},
+  languageOptions: {
+    parserOptions: {
+      ecmaVersion: 6,
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
-type TestCaseError = Omit<TSESLint.TestCaseError<string>, 'messageId'>;
+type RuleTestCaseError = Omit<TestCaseError<string>, 'messageId'>;
 
 // the base rule doesn't have messageIds
 function error(
-  messages: TestCaseError[],
+  messages: RuleTestCaseError[],
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): any[] {
   return messages.map(message => ({
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 223b9405d4e4..fbc0aaedfe42 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
@@ -2,18 +2,20 @@
 // Original Code: https://github.com/eslint/eslint/blob/eb76282e0a2db8aa10a3d5659f5f9237d9729121/tests/lib/rules/no-unused-vars.js
 // 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 { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
 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({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    // espree defaults to `script`, so we need to mirror it
-    sourceType: 'script',
+  languageOptions: {
+    parserOptions: {
+      // espree defaults to `script`, so we need to mirror it
+      sourceType: 'script',
+    },
   },
 });
 
@@ -48,7 +50,7 @@ ruleTester.defineRule('use-every-a', {
 function definedError(
   varName: string,
   additional = '',
-): TSESLint.TestCaseError<MessageIds> {
+): TestCaseError<MessageIds> {
   return {
     messageId: 'unusedVar',
     data: {
@@ -69,7 +71,7 @@ function definedError(
 function assignedError(
   varName: string,
   additional = '',
-): TSESLint.TestCaseError<MessageIds> {
+): TestCaseError<MessageIds> {
   return {
     messageId: 'unusedVar',
     data: {
@@ -91,7 +93,7 @@ function usedIgnoredError(
   varName: string,
   additional = '',
   type = AST_NODE_TYPES.Identifier,
-): TSESLint.TestCaseError<MessageIds> {
+): TestCaseError<MessageIds> {
   return {
     messageId: 'usedIgnoredVar',
     data: {
@@ -126,7 +128,7 @@ for (let prop in box) {
   box[prop] = parseInt(box[prop]);
 }
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     `
 var box = { a: 2 };
@@ -343,33 +345,41 @@ g();
     `,
     {
       code: ' ',
-      globals: { a: true },
+      languageOptions: { globals: { a: true } },
     },
     {
       code: `
 var who = 'Paul';
 module.exports = \`Hello \${who}!\`;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: 'export var foo = 123;',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: 'export function foo() {}',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: `
 let toUpper = partial => partial.toUpperCase;
 export { toUpper };
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: 'export class foo {}',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     {
       code: `
@@ -377,7 +387,7 @@ class Foo {}
 var x = new Foo();
 x.foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -387,7 +397,7 @@ function bar(foobar = foo) {
 }
 bar();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     `
 function Foo() {}
@@ -424,7 +434,7 @@ function foo() {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -433,7 +443,7 @@ function foo(foo) {
 }
 foo(1);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -445,7 +455,7 @@ function foo() {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -453,7 +463,7 @@ const x = 1;
 const [y = x] = [];
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -461,7 +471,7 @@ const x = 1;
 const { y = x } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -471,7 +481,7 @@ const {
 } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -479,7 +489,7 @@ const x = [];
 const { z: [y] = x } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -488,7 +498,7 @@ let y;
 [y = x] = [];
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -499,7 +509,7 @@ let y;
 } = {});
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -508,7 +518,7 @@ let y;
 ({ z: [y] = x } = {});
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -518,7 +528,7 @@ function foo(y = x) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -528,7 +538,7 @@ function foo({ y = x } = {}) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -542,7 +552,7 @@ function foo(
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -556,7 +566,7 @@ function foo(
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -564,7 +574,7 @@ var x = 1;
 var [y = x] = [];
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -572,7 +582,7 @@ var x = 1;
 var { y = x } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -582,7 +592,7 @@ var {
 } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -590,7 +600,7 @@ var x = [];
 var { z: [y] = x } = {};
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -599,7 +609,7 @@ var x = 1,
 [y = x] = [];
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -610,7 +620,7 @@ var x = 1,
 } = {});
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -619,7 +629,7 @@ var x = [],
 ({ z: [y] = x } = {});
 foo(y);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -629,7 +639,7 @@ function foo(y = x) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -639,7 +649,7 @@ function foo({ y = x } = {}) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -653,7 +663,7 @@ function foo(
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -667,7 +677,7 @@ function foo(
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // exported variables should work
@@ -678,22 +688,22 @@ poster = 0;
     `,
     {
       code: '/*exported x*/ var { x } = y;',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: '/*exported x, y*/ var { x, y } = z;',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // Can mark variables as used via context.markVariableAsUsed()
-    '/*eslint use-every-a:1*/ var a;',
+    '/*eslint @rule-tester/use-every-a:1*/ var a;',
     `
-/*eslint use-every-a:1*/ !function (a) {
+/*eslint @rule-tester/use-every-a:1*/ !function (a) {
   return 1;
 };
     `,
     `
-/*eslint use-every-a:1*/ !function () {
+/*eslint @rule-tester/use-every-a:1*/ !function () {
   var a;
   return 1;
 };
@@ -736,7 +746,7 @@ var [firstItemIgnored, secondItem] = items;
 console.log(secondItem);
       `,
       options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -744,7 +754,7 @@ const [a, _b, c] = items;
 console.log(a + c);
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -752,7 +762,7 @@ const [[a, _b, c]] = items;
 console.log(a + c);
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -762,7 +772,7 @@ const {
 console.log(foo);
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -772,7 +782,7 @@ function baz([_b, foo]) {
 baz();
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -782,7 +792,7 @@ function baz({ x: [_b, foo] }) {
 baz();
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -796,7 +806,7 @@ function baz([
 baz();
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -807,7 +817,7 @@ foo.forEach(item => {
 });
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -824,7 +834,7 @@ _a = 1;
 b;
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
     {
       code: `
@@ -843,7 +853,7 @@ b;
       options: [
         { destructuredArrayIgnorePattern: '^_', ignoreRestSiblings: true },
       ],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
 
     // for-in loops (see #2342)
@@ -881,7 +891,7 @@ b;
   for (name in obj) return;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -892,7 +902,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -902,7 +912,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -910,7 +920,7 @@ b;
   for (let name in obj) return true;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     {
@@ -921,7 +931,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -929,7 +939,7 @@ b;
   for (const name in obj) return true;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // For-of loops
@@ -940,7 +950,7 @@ b;
   for (name of iter) return;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -951,7 +961,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -961,7 +971,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -969,7 +979,7 @@ b;
   for (let name of iter) return true;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     {
@@ -980,7 +990,7 @@ b;
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -988,7 +998,7 @@ b;
   for (const name of iter) return true;
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // Sequence Expressions (See https://github.com/eslint/eslint/issues/14325)
@@ -997,21 +1007,21 @@ b;
 let x = 0;
 foo = (0, x++);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 let x = 0;
 foo = (0, (x += 1));
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
 let x = 0;
 foo = (0, (x = x + 1));
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // caughtErrors
@@ -1063,7 +1073,7 @@ const { type, ...coords } = data;
 console.log(coords);
       `,
       options: [{ ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
 
     // https://github.com/eslint/eslint/issues/6348
@@ -1149,7 +1159,7 @@ function* foo(cb) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -1160,7 +1170,7 @@ function foo(cb) {
 }
 foo();
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     `
 function foo(cb) {
@@ -1193,7 +1203,7 @@ someFunction();
 });
       `,
       options: [{ argsIgnorePattern: 'c' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -1202,7 +1212,7 @@ someFunction();
 });
       `,
       options: [{ argsIgnorePattern: 'd' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // https://github.com/eslint/eslint/issues/7250
@@ -1221,7 +1231,7 @@ someFunction();
 });
       `,
       options: [{ argsIgnorePattern: '[cd]' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // https://github.com/eslint/eslint/issues/7351
@@ -1231,7 +1241,7 @@ someFunction();
   set foo(UNUSED) {}
 });
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -1240,14 +1250,14 @@ class Foo {
 }
 console.log(Foo);
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
 
     // https://github.com/eslint/eslint/issues/8119
     {
       code: '({ a, ...rest }) => rest;',
       options: [{ args: 'all', ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
     },
 
     // https://github.com/eslint/eslint/issues/14163
@@ -1258,12 +1268,12 @@ let foo, rest;
 console.log(rest);
       `,
       options: [{ ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
     },
 
     // https://github.com/eslint/eslint/issues/10952
     `
-/*eslint use-every-a:1*/ !function (b, a) {
+/*eslint @rule-tester/use-every-a:1*/ !function (b, a) {
   return 1;
 };
     `,
@@ -1290,7 +1300,7 @@ const a = () => {
 };
 a();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
     {
       code: `
@@ -1299,19 +1309,23 @@ const a = () => () => {
 };
 a();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
     },
 
     // export * as ns from "source"
     {
       code: "export * as ns from 'source';",
-      parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      },
     },
 
     // import.meta
     {
       code: 'import.meta;',
-      parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+      },
     },
 
     // https://github.com/eslint/eslint/issues/17299
@@ -1320,21 +1334,21 @@ a();
 var a;
 a ||= 1;
       `,
-      parserOptions: { ecmaVersion: 2021 },
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
 var a;
 a &&= 1;
       `,
-      parserOptions: { ecmaVersion: 2021 },
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
     {
       code: `
 var a;
 a ??= 1;
       `,
-      parserOptions: { ecmaVersion: 2021 },
+      languageOptions: { parserOptions: { ecmaVersion: 2021 } },
     },
 
     // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
@@ -1345,7 +1359,7 @@ class Foo {
 }
       `,
       options: [{ ignoreClassWithStaticInitBlock: true }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: `
@@ -1356,7 +1370,7 @@ class Foo {
       options: [
         { ignoreClassWithStaticInitBlock: true, varsIgnorePattern: '^_' },
       ],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
     {
       code: `
@@ -1367,7 +1381,7 @@ class Foo {
       options: [
         { ignoreClassWithStaticInitBlock: false, varsIgnorePattern: '^Foo' },
       ],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
     },
 
     // https://github.com/eslint/eslint/issues/17568
@@ -1379,7 +1393,7 @@ const _c = a + 5;
       options: [
         { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
     {
       code: `
@@ -1399,7 +1413,7 @@ console.log(a + c);
       options: [
         { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
     },
   ],
   invalid: [
@@ -1680,7 +1694,9 @@ function f() {
     },
     {
       code: "import x from 'y';",
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('x')],
     },
     {
@@ -1689,7 +1705,9 @@ export function fn2({ x, y }) {
   console.log(x);
 }
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('y')],
     },
     {
@@ -1698,7 +1716,9 @@ export function fn2(x, y) {
   console.log(x);
 }
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('y')],
     },
 
@@ -1712,7 +1732,7 @@ export function fn2(x, y) {
     },
     {
       code: '/*exported x*/ var { x, y } = z;',
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [assignedError('y')],
     },
 
@@ -1821,7 +1841,7 @@ foo();
     {
       code: 'var [firstItemIgnored, secondItem] = items;',
       options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           line: 1,
@@ -1844,7 +1864,7 @@ const [a, _b, c] = array;
 const newArray = [a, c];
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         // should report only `newArray`
         { ...assignedError('newArray'), line: 4, column: 7 },
@@ -1856,7 +1876,7 @@ const array = ['a', 'b', 'c', 'd', 'e'];
 const [a, _b, c] = array;
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...assignedError(
@@ -1887,7 +1907,7 @@ const ignoreArray = ['ignore'];
       options: [
         { destructuredArrayIgnorePattern: '^_', varsIgnorePattern: 'ignore' },
       ],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...assignedError(
@@ -1930,7 +1950,7 @@ const [{ _a, foo }] = array;
 console.log(foo);
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...assignedError('_a'),
@@ -1947,7 +1967,7 @@ function foo([{ _a, bar }]) {
 foo();
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...definedError('_a'),
@@ -1965,7 +1985,7 @@ foo.forEach(item => {
 });
       `,
       options: [{ destructuredArrayIgnorePattern: '^_' }],
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...definedError('_a'),
@@ -2057,7 +2077,7 @@ foo.forEach(item => {
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           line: 4,
@@ -2079,7 +2099,7 @@ foo.forEach(item => {
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           line: 4,
@@ -2100,7 +2120,7 @@ foo.forEach(item => {
   }
 })({});
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           line: 3,
@@ -2191,7 +2211,7 @@ const data = { type: 'coords', x: 1, y: 2 };
 const { type, ...coords } = data;
 console.log(coords);
       `,
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 3,
@@ -2214,7 +2234,7 @@ const { type, ...coords } = data;
 console.log(type);
       `,
       options: [{ ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 3,
@@ -2235,7 +2255,7 @@ let type, coords;
 console.log(type);
       `,
       options: [{ ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 3,
@@ -2257,7 +2277,7 @@ const data = { type: 'coords', x: 3, y: 2 };
 const { type, ...coords } = data;
 console.log(type);
       `,
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 3,
@@ -2282,7 +2302,7 @@ const {
 } = data;
 console.log(coords);
       `,
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 4,
@@ -2307,7 +2327,7 @@ const {
 } = data;
 console.log(coords);
       `,
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [
         {
           line: 4,
@@ -2326,7 +2346,7 @@ console.log(coords);
     {
       code: '({ a, ...rest }) => {};',
       options: [{ args: 'all', ignoreRestSiblings: true }],
-      parserOptions: { ecmaVersion: 2018 },
+      languageOptions: { parserOptions: { ecmaVersion: 2018 } },
       errors: [definedError('rest')],
     },
 
@@ -2452,7 +2472,7 @@ a$fooz;
 /*global 𠮷𩸽, 𠮷*/
 𠮷𩸽;
       `,
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         {
           line: 2,
@@ -2472,7 +2492,9 @@ a$fooz;
     // https://github.com/eslint/eslint/issues/4047
     {
       code: 'export default function (a) {}',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('a')],
     },
     {
@@ -2481,12 +2503,16 @@ export default function (a, b) {
   console.log(a);
 }
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('b')],
     },
     {
       code: 'export default (function (a) {});',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('a')],
     },
     {
@@ -2495,12 +2521,16 @@ export default (function (a, b) {
   console.log(a);
 });
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('b')],
     },
     {
       code: 'export default a => {};',
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('a')],
     },
     {
@@ -2509,7 +2539,9 @@ export default (a, b) => {
   console.log(a);
 };
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
       errors: [definedError('b')],
     },
 
@@ -2760,7 +2792,7 @@ while (a) {
     {
       code: '(function (a, b, { c, d }) {});',
       options: [{ argsIgnorePattern: '[cd]' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         definedError('a', '. Allowed unused args must match /[cd]/u'),
         definedError('b', '. Allowed unused args must match /[cd]/u'),
@@ -2769,7 +2801,7 @@ while (a) {
     {
       code: '(function (a, b, { c, d }) {});',
       options: [{ argsIgnorePattern: 'c' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         definedError('a', '. Allowed unused args must match /c/u'),
         definedError('b', '. Allowed unused args must match /c/u'),
@@ -2779,7 +2811,7 @@ while (a) {
     {
       code: '(function (a, b, { c, d }) {});',
       options: [{ argsIgnorePattern: 'd' }],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         definedError('a', '. Allowed unused args must match /d/u'),
         definedError('b', '. Allowed unused args must match /d/u'),
@@ -2814,7 +2846,7 @@ foo*/
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a')],
     },
     {
@@ -2823,7 +2855,7 @@ foo*/
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a'), definedError('c')],
     },
 
@@ -2833,7 +2865,7 @@ foo*/
 let x = 0;
 x++, (x = 0);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 7 }],
     },
     {
@@ -2842,7 +2874,7 @@ let x = 0;
 x++, (x = 0);
 x = 3;
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 4, column: 1 }],
     },
     {
@@ -2850,7 +2882,7 @@ x = 3;
 let x = 0;
 x++, 0;
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 1 }],
     },
     {
@@ -2858,7 +2890,7 @@ x++, 0;
 let x = 0;
 0, x++;
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 4 }],
     },
     {
@@ -2866,7 +2898,7 @@ let x = 0;
 let x = 0;
 0, (1, x++);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 8 }],
     },
     {
@@ -2874,7 +2906,7 @@ let x = 0;
 let x = 0;
 foo = (x++, 0);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 8 }],
     },
     {
@@ -2882,7 +2914,7 @@ foo = (x++, 0);
 let x = 0;
 foo = ((0, x++), 0);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 12 }],
     },
     {
@@ -2890,7 +2922,7 @@ foo = ((0, x++), 0);
 let x = 0;
 (x += 1), 0;
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 2 }],
     },
     {
@@ -2898,7 +2930,7 @@ let x = 0;
 let x = 0;
 0, (x += 1);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 5 }],
     },
     {
@@ -2906,7 +2938,7 @@ let x = 0;
 let x = 0;
 0, (1, (x += 1));
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 9 }],
     },
     {
@@ -2914,7 +2946,7 @@ let x = 0;
 let x = 0;
 foo = ((x += 1), 0);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 9 }],
     },
     {
@@ -2922,7 +2954,7 @@ foo = ((x += 1), 0);
 let x = 0;
 foo = ((0, (x += 1)), 0);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 13 }],
     },
 
@@ -2932,7 +2964,7 @@ foo = ((0, (x += 1)), 0);
 let z = 0;
 (z = z + 1), (z = 2);
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('z'), line: 3, column: 15 }],
     },
     {
@@ -2941,7 +2973,7 @@ let z = 0;
 (z = z + 1), (z = 2);
 z = 3;
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('z'), line: 4, column: 1 }],
     },
     {
@@ -2950,7 +2982,7 @@ let z = 0;
 (z = z + 1), (z = 2);
 z = z + 3;
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('z'), line: 4, column: 1 }],
     },
     {
@@ -2958,7 +2990,7 @@ z = z + 3;
 let x = 0;
 0, (x = x + 1);
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('x'), line: 3, column: 5 }],
     },
     {
@@ -2966,7 +2998,7 @@ let x = 0;
 let x = 0;
 (x = x + 1), 0;
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('x'), line: 3, column: 2 }],
     },
     {
@@ -2974,7 +3006,7 @@ let x = 0;
 let x = 0;
 foo = ((0, (x = x + 1)), 0);
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('x'), line: 3, column: 13 }],
     },
     {
@@ -2982,7 +3014,7 @@ foo = ((0, (x = x + 1)), 0);
 let x = 0;
 foo = ((x = x + 1), 0);
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('x'), line: 3, column: 9 }],
     },
     {
@@ -2990,7 +3022,7 @@ foo = ((x = x + 1), 0);
 let x = 0;
 0, (1, (x = x + 1));
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('x'), line: 3, column: 9 }],
     },
     {
@@ -2999,7 +3031,7 @@ let x = 0;
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a'), definedError('c')],
     },
     {
@@ -3008,7 +3040,7 @@ let x = 0;
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a')],
     },
     {
@@ -3017,7 +3049,7 @@ let x = 0;
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a'), definedError('c')],
     },
     {
@@ -3026,7 +3058,7 @@ let x = 0;
   return b;
 })();
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [definedError('a'), definedError('c')],
     },
 
@@ -3067,7 +3099,7 @@ const a = () => () => {
   a();
 };
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('a'), line: 2, column: 7 }],
     },
     {
@@ -3075,7 +3107,7 @@ const a = () => () => {
 let myArray = [1, 2, 3, 4].filter(x => x == 0);
 myArray = myArray.filter(x => x == 1);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('myArray'), line: 3, column: 1 }],
     },
     {
@@ -3083,7 +3115,7 @@ myArray = myArray.filter(x => x == 1);
 const a = 1;
 a += 1;
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('a'), line: 3, column: 1 }],
     },
     {
@@ -3092,7 +3124,7 @@ const a = () => {
   a();
 };
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('a'), line: 2, column: 7 }],
     },
 
@@ -3102,7 +3134,7 @@ const a = () => {
 let x = [];
 x = x.concat(x);
       `,
-      parserOptions: { ecmaVersion: 2015 },
+      languageOptions: { parserOptions: { ecmaVersion: 2015 } },
       errors: [{ ...assignedError('x'), line: 3, column: 1 }],
     },
     {
@@ -3116,7 +3148,7 @@ function foo() {
   };
 }
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [
         {
           ...assignedError('a'),
@@ -3139,7 +3171,7 @@ function init() {
   foo = 1;
 }
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('foo'), line: 4, column: 1 }],
     },
     {
@@ -3149,7 +3181,7 @@ function foo(n) {
   return n * foo(n - 1);
 }
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...definedError('foo'), line: 2, column: 10 }],
     },
     {
@@ -3165,7 +3197,7 @@ function foo1() {
 
 c = foo1;
       `,
-      parserOptions: { ecmaVersion: 2020 },
+      languageOptions: { parserOptions: { ecmaVersion: 2020 } },
       errors: [{ ...assignedError('c'), line: 11, column: 1 }],
     },
 
@@ -3177,7 +3209,7 @@ class Foo {
 }
       `,
       options: [{ ignoreClassWithStaticInitBlock: false }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
     },
     {
@@ -3186,7 +3218,7 @@ class Foo {
   static {}
 }
       `,
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
     },
     {
@@ -3198,13 +3230,13 @@ class Foo {
 }
       `,
       options: [{ ignoreClassWithStaticInitBlock: true }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('bar'), line: 4, column: 9 }],
     },
     {
       code: 'class Foo {}',
       options: [{ ignoreClassWithStaticInitBlock: true }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('Foo'), line: 1, column: 7 }],
     },
     {
@@ -3214,7 +3246,7 @@ class Foo {
 }
       `,
       options: [{ ignoreClassWithStaticInitBlock: true }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
     },
     {
@@ -3224,7 +3256,7 @@ class Foo {
 }
       `,
       options: [{ ignoreClassWithStaticInitBlock: true }],
-      parserOptions: { ecmaVersion: 2022 },
+      languageOptions: { parserOptions: { ecmaVersion: 2022 } },
       errors: [{ ...definedError('Foo'), line: 2, column: 7 }],
     },
 
@@ -3237,7 +3269,7 @@ const _b = _a + 5;
       options: [
         { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
     },
     {
@@ -3248,7 +3280,7 @@ foo(() => _a);
       options: [
         { args: 'all', varsIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [usedIgnoredError('_a', '. Used vars must not match /^_/u')],
     },
     {
@@ -3270,7 +3302,7 @@ console.log(a + _b);
       options: [
         { destructuredArrayIgnorePattern: '^_', reportUsedIgnorePattern: true },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         usedIgnoredError(
           '_b',
@@ -3291,7 +3323,7 @@ foo(_x);
           varsIgnorePattern: '[iI]gnored',
         },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         usedIgnoredError(
           '_x',
@@ -3311,7 +3343,7 @@ foo(ignored);
           varsIgnorePattern: '[iI]gnored',
         },
       ],
-      parserOptions: { ecmaVersion: 6 },
+      languageOptions: { parserOptions: { ecmaVersion: 6 } },
       errors: [
         usedIgnoredError('ignored', '. Used vars must not match /[iI]gnored/u'),
       ],
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 81d92d8e4194..c67a48b7d104 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
@@ -5,12 +5,13 @@ import { collectVariables } from '../../../src/util';
 import { getFixturesRootDir } from '../../RuleTester';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    ecmaFeatures: {},
+  languageOptions: {
+    parserOptions: {
+      ecmaVersion: 6,
+      sourceType: 'module',
+      ecmaFeatures: {},
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 const withMetaParserOptions = {
@@ -604,9 +605,11 @@ export interface Bar extends foo.i18n<bar> {}
 import { TypeA } from './interface';
 export const a = <GenericComponent<TypeA> />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -622,9 +625,11 @@ export function Foo() {
   );
 }
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -881,9 +886,11 @@ export type Test<U> = U extends (arg: {
           return <div>Foo Foo</div>;
         };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -895,11 +902,13 @@ export type Test<U> = U extends (arg: {
           return <div>Foo Foo</div>;
         };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: 'h',
         },
-        jsxPragma: 'h',
       },
     },
     {
@@ -910,11 +919,13 @@ export type Test<U> = U extends (arg: {
           return <>Foo Foo</>;
         };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxFragmentName: 'Fragment',
         },
-        jsxFragmentName: 'Fragment',
       },
     },
     `
@@ -1035,7 +1046,7 @@ interface _Foo {
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/2844
     `
-/* eslint collect-unused-vars: "error" */
+/* eslint @rule-tester/collect-unused-vars: "error" */
 declare module 'next-auth' {
   interface User {
     id: string;
@@ -1055,7 +1066,7 @@ export class TestClass {
   public test(): TestGeneric<Test> {}
 }
       `,
-      parserOptions: withMetaParserOptions,
+      languageOptions: { parserOptions: withMetaParserOptions },
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/5577
     `
@@ -1698,9 +1709,11 @@ export const ComponentFoo = () => {
   return <div>Foo Foo</div>;
 };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
       errors: [
@@ -1725,11 +1738,13 @@ export const ComponentFoo = () => {
   return <div>Foo Foo</div>;
 };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: 'h',
         },
-        jsxPragma: 'h',
       },
       errors: [
         {
@@ -1753,11 +1768,13 @@ export const ComponentFoo = () => {
   return <div>Foo Foo</div>;
 };
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
+          jsxPragma: null,
         },
-        jsxPragma: null,
       },
       errors: [
         {
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 38efe428dd1a..be7cd2ac7730 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
@@ -3,9 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-use-before-define';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 const parserOptions = { ecmaVersion: 6 as const };
 
@@ -71,7 +69,7 @@ function a() {
   alert(a);
 })();
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     `
 a();
@@ -84,14 +82,14 @@ try {
 class A {}
 new A();
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     `
 var a = 0,
   b = a;
     `,
-    { code: 'var { a = 0, b = a } = {};', parserOptions },
-    { code: 'var [a = 0, b = a] = {};', parserOptions },
+    { code: 'var { a = 0, b = a } = {};', languageOptions: { parserOptions } },
+    { code: 'var [a = 0, b = a] = {};', languageOptions: { parserOptions } },
     `
 function foo() {
   foo();
@@ -113,7 +111,7 @@ var a;
 for (a of a) {
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
 
     // Block-level bindings
@@ -125,7 +123,7 @@ a();
   function a() {}
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -136,7 +134,7 @@ a();
 }
       `,
       options: ['nofunc'],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -149,7 +147,7 @@ switch (foo) {
   }
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -158,7 +156,7 @@ a();
   let a = function () {};
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
     },
 
     // object style options
@@ -180,7 +178,7 @@ function a() {
 }
       `,
       options: [{ functions: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -190,7 +188,7 @@ function foo() {
 class A {}
       `,
       options: [{ classes: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
 
     // "variables" option
@@ -209,7 +207,7 @@ var foo = () => bar;
 var bar;
       `,
       options: [{ variables: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
 
     // "typedefs" option
@@ -274,7 +272,9 @@ export namespace Third {
   export let third = () => console.log('third');
 }
       `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      },
     },
     // https://github.com/eslint/typescript-eslint-parser/issues/550
     `
@@ -335,7 +335,7 @@ export { a };
 const a = 1;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -343,7 +343,7 @@ export { a as b };
 const a = 1;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -351,7 +351,7 @@ export { a, b };
 let a, b;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -359,7 +359,7 @@ export { a };
 var a;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -367,7 +367,7 @@ export { f };
 function f() {}
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -375,7 +375,7 @@ export { C };
 class C {}
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -386,7 +386,7 @@ enum Foo {
 }
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -397,7 +397,7 @@ namespace Foo {
 }
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     {
       code: `
@@ -411,7 +411,7 @@ let baz: Enum;
 enum Enum {}
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/2502
     {
@@ -420,10 +420,12 @@ import * as React from 'react';
 
 <div />;
       `,
-      parserOptions: {
-        sourceType: 'module',
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          sourceType: 'module',
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -433,10 +435,12 @@ import React from 'react';
 
 <div />;
       `,
-      parserOptions: {
-        sourceType: 'module',
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          sourceType: 'module',
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -446,11 +450,13 @@ import { h } from 'preact';
 
 <div />;
       `,
-      parserOptions: {
-        sourceType: 'module',
-        jsxPragma: 'h',
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          sourceType: 'module',
+          jsxPragma: 'h',
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -460,9 +466,11 @@ const React = require('react');
 
 <div />;
       `,
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true,
+          },
         },
       },
     },
@@ -582,7 +590,9 @@ const baz = '';
 a++;
 var a = 19;
       `,
-      parserOptions: { sourceType: 'module' },
+      languageOptions: {
+        parserOptions: { sourceType: 'module' },
+      },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -596,7 +606,7 @@ var a = 19;
 a++;
 var a = 19;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -687,7 +697,7 @@ var a = function () {};
   var a = 42;
 })();
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -701,7 +711,7 @@ var a = function () {};
 (() => a())();
 function a() {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -718,7 +728,14 @@ a();
   function a() {}
 }
       `,
-      parser: require.resolve('espree'),
+      languageOptions: {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        parser: require('espree'),
+        parserOptions: {
+          ecmaVersion: 6,
+          sourceType: 'script',
+        },
+      },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -749,7 +766,7 @@ try {
 var f = () => a;
 var a;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -763,7 +780,7 @@ var a;
 new A();
 class A {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -779,7 +796,7 @@ function foo() {
 }
 class A {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -793,7 +810,7 @@ class A {}
 new A();
 var A = class {};
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -809,7 +826,7 @@ function foo() {
 }
 var A = class {};
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -827,7 +844,7 @@ a++;
   var a;
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -844,7 +861,7 @@ a++;
   function a() {}
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -860,7 +877,7 @@ a++;
   let a = 1;
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -878,7 +895,7 @@ switch (foo) {
     let a;
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -896,7 +913,7 @@ if (true) {
   let a;
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -927,7 +944,7 @@ new A();
 var A = class {};
       `,
       options: [{ classes: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -944,7 +961,7 @@ function foo() {
 var A = class {};
       `,
       options: [{ classes: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -967,7 +984,7 @@ var A = class {};
     },
     {
       code: 'let a = a + b;',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -978,7 +995,7 @@ var A = class {};
     },
     {
       code: 'const a = foo(a);',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -989,7 +1006,7 @@ var A = class {};
     },
     {
       code: 'function foo(a = a) {}',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1000,7 +1017,7 @@ var A = class {};
     },
     {
       code: 'var { a = a } = [];',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1011,7 +1028,7 @@ var A = class {};
     },
     {
       code: 'var [a = a] = [];',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1022,7 +1039,7 @@ var A = class {};
     },
     {
       code: 'var { b = a, a } = {};',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1033,7 +1050,7 @@ var A = class {};
     },
     {
       code: 'var [b = a, a] = {};',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1044,7 +1061,7 @@ var A = class {};
     },
     {
       code: 'var { a = 0 } = a;',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1055,7 +1072,7 @@ var A = class {};
     },
     {
       code: 'var [a = 0] = a;',
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1082,7 +1099,7 @@ for (var a in a) {
 for (var a of a) {
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1179,7 +1196,7 @@ function foo() {
 }
 var bar;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       options: [{ variables: false }],
       errors: [
         {
@@ -1252,7 +1269,7 @@ enum Foo {
 export { a };
 const a = 1;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1266,7 +1283,7 @@ export { a };
 const a = 1;
       `,
       options: [{}],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1280,7 +1297,7 @@ export { a };
 const a = 1;
       `,
       options: [{ allowNamedExports: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1294,7 +1311,7 @@ export { a };
 const a = 1;
       `,
       options: ['nofunc'],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1307,7 +1324,7 @@ const a = 1;
 export { a as b };
 const a = 1;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1320,7 +1337,7 @@ const a = 1;
 export { a, b };
 let a, b;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1337,7 +1354,7 @@ let a, b;
 export { a };
 var a;
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1350,7 +1367,7 @@ var a;
 export { f };
 function f() {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1363,7 +1380,7 @@ function f() {}
 export { C };
 class C {}
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1377,7 +1394,7 @@ export const foo = a;
 const a = 1;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1393,8 +1410,7 @@ export function foo() {
 const a = 1;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
-
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1412,8 +1428,7 @@ export class C {
 const a = 1;
       `,
       options: [{ allowNamedExports: true }],
-      parserOptions,
-
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1429,7 +1444,7 @@ enum Foo {
   BAR,
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1445,7 +1460,7 @@ namespace Foo {
   export let bar = () => console.log('bar');
 }
       `,
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -1465,7 +1480,7 @@ let baz: Enum;
 enum Enum {}
       `,
       options: [{ ignoreTypeReferences: true, allowNamedExports: false }],
-      parserOptions,
+      languageOptions: { parserOptions },
       errors: [
         {
           messageId: 'noUseBeforeDefine',
diff --git a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
index a68ee56fb8fb..a49055b6c0d9 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
@@ -3,13 +3,7 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/no-useless-constructor';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 const error = {
   messageId: 'noUselessConstructor' as const,
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 caef56622cbc..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
@@ -7,11 +7,12 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 import rule from '../../src/rules/no-useless-empty-export';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: 'module',
+  languageOptions: {
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 const error = {
diff --git a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
index 2720475b3b8d..ef61110d83a0 100644
--- a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-var-requires';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-var-requires', rule, {
   valid: [
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 73613259cc22..b98ef17bc9e9 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
@@ -3,9 +3,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/no-wrapper-object-types';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('no-wrapper-object-types', rule, {
   valid: [
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 f0c5da6ab9d7..f8f8bbea79d9 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
@@ -4,12 +4,12 @@ import rule from '../../src/rules/non-nullable-type-assertion-style';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: getFixturesRootDir(),
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: getFixturesRootDir(),
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('non-nullable-type-assertion-style', rule, {
@@ -245,13 +245,14 @@ const b = (a || undefined)!;
 });
 
 const ruleTesterWithNoUncheckedIndexAccess = new RuleTester({
-  parserOptions: {
-    project: './tsconfig.noUncheckedIndexedAccess.json',
-    projectService: false,
-    sourceType: 'module',
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.noUncheckedIndexedAccess.json',
+      projectService: false,
+      sourceType: 'module',
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTesterWithNoUncheckedIndexAccess.run(
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 57fa09d86b55..0ae3f0e00769 100644
--- a/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
+++ b/packages/eslint-plugin/tests/rules/only-throw-error.test.ts
@@ -4,13 +4,12 @@ import rule from '../../src/rules/only-throw-error';
 import { getFixturesRootDir } from '../RuleTester';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    sourceType: 'module',
-    tsconfigRootDir: getFixturesRootDir(),
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: getFixturesRootDir(),
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('only-throw-error', rule, {
diff --git a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
index 6323a5858bba..72cccf1180ec 100644
--- a/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
+++ b/packages/eslint-plugin/tests/rules/parameter-properties.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/parameter-properties';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('parameter-properties', rule, {
   valid: [
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 e0c917c88f21..eb56e9b22871 100644
--- a/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-as-const';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-as-const', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
index d38c151d1000..b4486e06ec7d 100644
--- a/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-destructuring.test.ts
@@ -7,11 +7,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 7e64015641f9..f1d15c548e42 100644
--- a/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-enum-initializers.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-enum-initializers';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-enum-initializers', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/prefer-find.test.ts b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
index b4773b19182d..f3c6ba1bb869 100644
--- a/packages/eslint-plugin/tests/rules/prefer-find.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-find.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 a370ee57a785..781020b933e5 100644
--- a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-for-of';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-for-of', rule, {
   valid: [
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 31f707601a0d..3312f54970f9 100644
--- a/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
@@ -3,12 +3,8 @@ import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 import rule, { phrases } from '../../src/rules/prefer-function-type';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
+
 ruleTester.run('prefer-function-type', rule, {
   valid: [
     `
diff --git a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
index cf71c7e4581c..e22cd65be1aa 100644
--- a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 26cd20d868ba..48a181618bed 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
@@ -2,9 +2,7 @@ import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-literal-enum-member';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-literal-enum-member', rule, {
   valid: [
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 34fc80b2ef75..46ed3c4b7f4e 100644
--- a/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-namespace-keyword';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-namespace-keyword', rule, {
   valid: [
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 1afa16ca9341..3b77c067e7a0 100644
--- a/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts
@@ -1,5 +1,8 @@
+import type {
+  InvalidTestCase,
+  ValidTestCase,
+} from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 import * as path from 'path';
 
 import type {
@@ -12,10 +15,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -24,17 +28,14 @@ const nullishTypes = ['null', 'undefined', 'null | undefined'];
 const ignorablePrimitiveTypes = ['string', 'number', 'boolean', 'bigint'];
 
 function typeValidTest(
-  cb: (type: string) => TSESLint.ValidTestCase<Options> | string,
-): (TSESLint.ValidTestCase<Options> | string)[] {
+  cb: (type: string) => ValidTestCase<Options> | string,
+): (ValidTestCase<Options> | string)[] {
   return types.map(type => cb(type));
 }
 function nullishTypeValidTest(
-  cb: (
-    nullish: string,
-    type: string,
-  ) => TSESLint.ValidTestCase<Options> | string,
-): (TSESLint.ValidTestCase<Options> | string)[] {
-  return nullishTypes.reduce<(TSESLint.ValidTestCase<Options> | string)[]>(
+  cb: (nullish: string, type: string) => ValidTestCase<Options> | string,
+): (ValidTestCase<Options> | string)[] {
+  return nullishTypes.reduce<(ValidTestCase<Options> | string)[]>(
     (acc, nullish) => {
       types.forEach(type => {
         acc.push(cb(nullish, type));
@@ -45,12 +46,9 @@ function nullishTypeValidTest(
   );
 }
 function nullishTypeInvalidTest(
-  cb: (
-    nullish: string,
-    type: string,
-  ) => TSESLint.InvalidTestCase<MessageIds, Options>,
-): TSESLint.InvalidTestCase<MessageIds, Options>[] {
-  return nullishTypes.reduce<TSESLint.InvalidTestCase<MessageIds, Options>[]>(
+  cb: (nullish: string, type: string) => InvalidTestCase<MessageIds, Options>,
+): InvalidTestCase<MessageIds, Options>[] {
+  return nullishTypes.reduce<InvalidTestCase<MessageIds, Options>[]>(
     (acc, nullish) => {
       types.forEach(type => {
         acc.push(cb(nullish, type));
@@ -199,28 +197,28 @@ a && b || c || d;
       `,
       options: [{ ignoreMixedLogicalExpressions: true }],
     })),
-    ...ignorablePrimitiveTypes.map<TSESLint.ValidTestCase<Options>>(type => ({
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
       code: `
 declare const x: ${type} | undefined;
 x || y;
       `,
       options: [{ ignorePrimitives: { [type]: true } }],
     })),
-    ...ignorablePrimitiveTypes.map<TSESLint.ValidTestCase<Options>>(type => ({
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
       code: `
 declare const x: ${type} | undefined;
 x || y;
       `,
       options: [{ ignorePrimitives: true }],
     })),
-    ...ignorablePrimitiveTypes.map<TSESLint.ValidTestCase<Options>>(type => ({
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
       code: `
 declare const x: (${type} & { __brand?: any }) | undefined;
 x || y;
       `,
       options: [{ ignorePrimitives: { [type]: true } }],
     })),
-    ...ignorablePrimitiveTypes.map<TSESLint.ValidTestCase<Options>>(type => ({
+    ...ignorablePrimitiveTypes.map<ValidTestCase<Options>>(type => ({
       code: `
 declare const x: (${type} & { __brand?: any }) | undefined;
 x || y;
@@ -589,8 +587,10 @@ if (x) {
           column: 1,
         },
       ],
-      parserOptions: {
-        tsconfigRootDir: path.join(rootPath, 'unstrict'),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
       },
     },
 
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 4ea5f6cc087b..6cd8dd1a6945 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
@@ -1,4 +1,4 @@
-import type { InvalidTestCase } from '@typescript-eslint/utils/ts-eslint';
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 
 import type {
   PreferOptionalChainMessageIds,
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 a55b54572f55..65022d5f1ce1 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
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../../RuleTester';
 import { BaseCases, identity } from './base-cases';
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: './tsconfig.json',
-    tsconfigRootDir: getFixturesRootDir(),
+  languageOptions: {
+    parserOptions: {
+      project: './tsconfig.json',
+      tsconfigRootDir: getFixturesRootDir(),
+    },
   },
 });
 
@@ -759,12 +760,12 @@ describe('hand-crafted cases', () => {
       'data && data.value !== null;',
       {
         code: '<div /> && (<div />).wtf;',
-        parserOptions: { ecmaFeatures: { jsx: true } },
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
       },
       {
         code: '<></> && (<></>).wtf;',
-        parserOptions: { ecmaFeatures: { jsx: true } },
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
       },
       'foo[x++] && foo[x++].bar;',
@@ -956,7 +957,7 @@ describe('hand-crafted cases', () => {
         code: 'foo && foo.bar(baz => <This Requires Spaces />);',
         output: 'foo?.bar(baz => <This Requires Spaces />);',
         errors: [{ messageId: 'preferOptionalChain', suggestions: null }],
-        parserOptions: { ecmaFeatures: { jsx: true } },
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
       },
       {
@@ -1075,7 +1076,7 @@ describe('hand-crafted cases', () => {
             suggestions: null,
           },
         ],
-        parserOptions: { ecmaFeatures: { jsx: true } },
+        languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
         filename: 'react.tsx',
       },
       // case with this keyword at the start of expression
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 69eed002ebf7..d890886eff15 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
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('prefer-promise-reject-errors', rule, {
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 4a563263d51b..11029c639086 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,5 +1,5 @@
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import rule from '../../src/rules/prefer-readonly-parameter-types';
 import type {
@@ -16,10 +16,11 @@ type Options = InferOptionsTypeFromRule<typeof rule>;
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -477,7 +478,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     // arrays
     // Removing readonly causes duplicates
     ...dedupeTestCases(
-      arrays.map<TSESLint.InvalidTestCase<MessageIds, Options>>(baseType => {
+      arrays.map<InvalidTestCase<MessageIds, Options>>(baseType => {
         const type = baseType
           .replace(/readonly /g, '')
           .replace(/Readonly<(.+?)>/g, '$1')
@@ -527,7 +528,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     },
 
     // objects
-    ...objects.map<TSESLint.InvalidTestCase<MessageIds, Options>>(type => {
+    ...objects.map<InvalidTestCase<MessageIds, Options>>(type => {
       return {
         code: `function foo(arg: ${type}) {}`,
         errors: [
@@ -588,7 +589,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     },
 
     // weird intersections
-    ...weirdIntersections.map<TSESLint.InvalidTestCase<MessageIds, Options>>(
+    ...weirdIntersections.map<InvalidTestCase<MessageIds, Options>>(
       baseCode => {
         const code = baseCode.replace(/readonly /g, '');
         return {
diff --git a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
index 31e134788601..82c7324be605 100644
--- a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
@@ -5,11 +5,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 d93212ae43f3..e5a86ccda41f 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
@@ -6,11 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 cca411a362da..0cb2e346ee71 100644
--- a/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 bc571b26cc23..2a89eddb4255 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
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 3e198c6bd32a..d1e2f3b680fe 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
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 7937dc3fc6e2..4abbd9733e84 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
@@ -2,9 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/prefer-ts-expect-error';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('prefer-ts-expect-error', rule, {
   valid: [
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 adf3dc6568fa..b89b60878949 100644
--- a/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
+++ b/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
@@ -7,12 +7,12 @@ const rootDir = getFixturesRootDir();
 const messageId = 'missingAsync';
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('promise-function-async', rule, {
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 3d544d7f2ce9..3efc6d8e91ab 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
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/eslint-plugin/tests/rules/require-await.test.ts b/packages/eslint-plugin/tests/rules/require-await.test.ts
index f8f9624e26c8..d4b0d6c6d2f1 100644
--- a/packages/eslint-plugin/tests/rules/require-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-await.test.ts
@@ -6,12 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('require-await', rule, {
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 f98f6c187509..769edd44f11e 100644
--- a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 7a69ff34cbc9..c60c2be4b0aa 100644
--- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/eslint-plugin/tests/rules/return-await.test.ts b/packages/eslint-plugin/tests/rules/return-await.test.ts
index 98175766e733..adde6284a2f3 100644
--- a/packages/eslint-plugin/tests/rules/return-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/return-await.test.ts
@@ -1,5 +1,5 @@
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
-import type { InvalidTestCase } from '@typescript-eslint/utils/ts-eslint';
 
 import rule from '../../src/rules/return-await';
 import { getFixturesRootDir } from '../RuleTester';
@@ -7,12 +7,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2018,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 // default rule is in-try-catch
@@ -65,7 +65,7 @@ ruleTester.run('return-await', rule, {
           } else if (Math.random() < 0.5) {
             return Promise.resolve(2);
           }
-        
+
           try {
           } catch (e) {
             return await Promise.resolve(3);
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 c020f5a18d39..ef03e4a900c5 100644
--- a/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
+++ b/packages/eslint-plugin/tests/rules/sort-type-constituents.test.ts
@@ -1,5 +1,8 @@
+import type {
+  InvalidTestCase,
+  ValidTestCase,
+} from '@typescript-eslint/rule-tester';
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import type {
   MessageIds,
@@ -7,11 +10,9 @@ import type {
 } from '../../src/rules/sort-type-constituents';
 import rule from '../../src/rules/sort-type-constituents';
 
-const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
-const valid = (operator: '&' | '|'): TSESLint.ValidTestCase<Options>[] => [
+const valid = (operator: '&' | '|'): ValidTestCase<Options>[] => [
   {
     code: `type T = A ${operator} B;`,
   },
@@ -87,7 +88,7 @@ type T =
 ];
 const invalid = (
   operator: '&' | '|',
-): TSESLint.InvalidTestCase<MessageIds, Options>[] => {
+): InvalidTestCase<MessageIds, Options>[] => {
   const type = operator === '|' ? 'Union' : 'Intersection';
   return [
     {
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 640c9a212cd1..263f7858b1b7 100644
--- a/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
@@ -12,10 +12,11 @@ import { batchedSingleLineTests, getFixturesRootDir } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -341,8 +342,10 @@ if (x) {
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
         },
       ],
-      parserOptions: {
-        tsconfigRootDir: path.join(rootPath, 'unstrict'),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
       },
     },
 
@@ -2190,8 +2193,10 @@ if (x) {
           column: 5,
         },
       ],
-      parserOptions: {
-        tsconfigRootDir: path.join(rootPath, 'unstrict'),
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootPath, 'unstrict'),
+        },
       },
     },
 
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 792533c9c2b3..c89bea0e7d36 100644
--- a/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
+++ b/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
@@ -6,10 +6,11 @@ import switchExhaustivenessCheck from '../../src/rules/switch-exhaustiveness-che
 const rootPath = path.join(process.cwd(), 'tests/fixtures/');
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
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 5c0c7d482cc8..2ed79fe7a4dc 100644
--- a/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
+++ b/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
@@ -2,12 +2,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester';
 
 import rule from '../../src/rules/triple-slash-reference';
 
-const ruleTester = new RuleTester({
-  parserOptions: {
-    sourceType: 'module',
-  },
-  parser: '@typescript-eslint/parser',
-});
+const ruleTester = new RuleTester();
 
 ruleTester.run('triple-slash-reference', rule, {
   valid: [
diff --git a/packages/eslint-plugin/tests/rules/typedef.test.ts b/packages/eslint-plugin/tests/rules/typedef.test.ts
index 79dcaa9b193b..c3d588bc2c1e 100644
--- a/packages/eslint-plugin/tests/rules/typedef.test.ts
+++ b/packages/eslint-plugin/tests/rules/typedef.test.ts
@@ -5,11 +5,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootDir = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2015,
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
index 81f4f126fd32..d862bab13d8c 100644
--- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -1,5 +1,5 @@
+import type { InvalidTestCase } from '@typescript-eslint/rule-tester';
 import { RuleTester } from '@typescript-eslint/rule-tester';
-import type { TSESLint } from '@typescript-eslint/utils';
 
 import type { MessageIds, Options } from '../../src/rules/unbound-method';
 import rule from '../../src/rules/unbound-method';
@@ -8,11 +8,11 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootPath = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
@@ -39,7 +39,7 @@ ${code}
 }
 function addContainsMethodsClassInvalid(
   code: string[],
-): TSESLint.InvalidTestCase<MessageIds, Options>[] {
+): InvalidTestCase<MessageIds, Options>[] {
   return code.map(c => ({
     code: addContainsMethodsClass(c),
     errors: [
diff --git a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
index dcc16c7a196e..39a95fa53e39 100644
--- a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
@@ -6,7 +6,7 @@ import rule from '../../src/rules/unified-signatures';
 // Tests
 //------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester({ parser: '@typescript-eslint/parser' });
+const ruleTester = new RuleTester();
 
 ruleTester.run('unified-signatures', rule, {
   valid: [
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 80fe9e3cee9b..ee589eeb4f97 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
@@ -6,11 +6,12 @@ import { getFixturesRootDir } from '../RuleTester';
 const rootDir = getFixturesRootDir();
 
 const ruleTester = new RuleTester({
-  parserOptions: {
-    tsconfigRootDir: rootDir,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootDir,
+      project: './tsconfig.json',
+    },
   },
-  parser: '@typescript-eslint/parser',
 });
 
 ruleTester.run('use-unknown-in-catch-callback-variable', rule, {
diff --git a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
index 69e337694b06..aa1083a4d4e8 100644
--- a/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappedCode.test.ts
@@ -12,10 +12,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
index 621e8e3b4d5a..68c433715d5d 100644
--- a/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
+++ b/packages/eslint-plugin/tests/util/getWrappingFixer.test.ts
@@ -6,10 +6,11 @@ import { getFixturesRootDir } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
index 2e42192090ca..3a92f8d28c37 100644
--- a/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
+++ b/packages/eslint-plugin/tests/util/isNodeEqual.test.ts
@@ -44,10 +44,11 @@ const rule = createRule({
 
 const rootPath = getFixturesRootDir();
 const ruleTester = new RuleTester({
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    tsconfigRootDir: rootPath,
-    project: './tsconfig.json',
+  languageOptions: {
+    parserOptions: {
+      tsconfigRootDir: rootPath,
+      project: './tsconfig.json',
+    },
   },
 });
 
diff --git a/packages/rule-tester/src/RuleTester.ts b/packages/rule-tester/src/RuleTester.ts
index 85ed874bafdd..07c95b83c23e 100644
--- a/packages/rule-tester/src/RuleTester.ts
+++ b/packages/rule-tester/src/RuleTester.ts
@@ -6,14 +6,14 @@ import path from 'node:path';
 import util from 'node:util';
 
 import type * as ParserType from '@typescript-eslint/parser';
+import * as parser from '@typescript-eslint/parser';
 import type { TSESTree } from '@typescript-eslint/utils';
 import { deepMerge } from '@typescript-eslint/utils/eslint-utils';
 import type {
   AnyRuleCreateFunction,
   AnyRuleModule,
-  Parser,
   ParserOptions,
-  RuleContext,
+  RuleListener,
   RuleModule,
 } from '@typescript-eslint/utils/ts-eslint';
 import { Linter } from '@typescript-eslint/utils/ts-eslint';
@@ -41,15 +41,13 @@ import { freezeDeeply } from './utils/freezeDeeply';
 import { getRuleOptionsSchema } from './utils/getRuleOptionsSchema';
 import { hasOwnProperty } from './utils/hasOwnProperty';
 import { getPlaceholderMatcher, interpolate } from './utils/interpolate';
+import { omitCustomConfigProperties } from './utils/omitCustomConfigProperties';
 import { isSerializable } from './utils/serialization';
 import * as SourceCodeFixer from './utils/SourceCodeFixer';
 import {
-  emitLegacyRuleAPIWarning,
-  emitMissingSchemaWarning,
   ERROR_OBJECT_PARAMETERS,
   FRIENDLY_ERROR_OBJECT_PARAMETER_LIST,
   FRIENDLY_SUGGESTION_OBJECT_PARAMETER_LIST,
-  getCommentsDeprecation,
   REQUIRED_SCENARIOS,
   RULE_TESTER_PARAMETERS,
   sanitize,
@@ -58,23 +56,75 @@ import {
 } from './utils/validationHelpers';
 
 const ajv = ajvBuilder({ strictDefaults: true });
+const RULE_TESTER_PLUGIN = '@rule-tester';
+const RULE_TESTER_PLUGIN_PREFIX = `${RULE_TESTER_PLUGIN}/`;
 const TYPESCRIPT_ESLINT_PARSER = '@typescript-eslint/parser';
 const DUPLICATE_PARSER_ERROR_MESSAGE = `Do not set the parser at the test level unless you want to use a parser other than "${TYPESCRIPT_ESLINT_PARSER}"`;
 
+// instead of creating a hard dependency, just use a soft require
+// a bit weird, but if they're using this tooling, it'll be installed
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const defaultParser = require(TYPESCRIPT_ESLINT_PARSER) as typeof ParserType;
+
 /*
  * testerDefaultConfig must not be modified as it allows to reset the tester to
  * the initial default configuration
  */
 const testerDefaultConfig: Readonly<TesterConfigWithDefaults> = {
-  parser: TYPESCRIPT_ESLINT_PARSER,
-  rules: {},
   defaultFilenames: { ts: 'file.ts', tsx: 'react.tsx' },
+  languageOptions: {
+    parser: defaultParser,
+  },
+  rules: {},
 };
+
 let defaultConfig = deepMerge(
   {},
   testerDefaultConfig,
 ) as TesterConfigWithDefaults;
 
+type ForbiddenFunction = (this: WeakKey, ...args: never[]) => unknown;
+
+const forbiddenMethods = [
+  'applyInlineConfig',
+  'applyLanguageOptions',
+  'finalize',
+] as const;
+
+type ForbiddenMethodName = (typeof forbiddenMethods)[number];
+
+const forbiddenMethodCalls = new Map(
+  forbiddenMethods.map(methodName => [methodName, new WeakSet()]),
+);
+
+/**
+ * Function to replace forbidden `SourceCode` methods. Allows just one call per method.
+ * @param methodName The name of the method to forbid.
+ * @param prototype The prototype with the original method to call.
+ * @returns The function that throws the error.
+ */
+function throwForbiddenMethodError<
+  MethodName extends ForbiddenMethodName,
+  Prototype extends Record<MethodName, ForbiddenFunction>,
+>(methodName: MethodName, prototype: Prototype): Prototype[MethodName] {
+  const original = prototype[methodName];
+
+  return function (this: WeakKey, ...args: Parameters<Prototype[MethodName]>) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const called = forbiddenMethodCalls.get(methodName)!;
+
+    if (!called.has(this)) {
+      called.add(this);
+
+      return original.apply(this, args);
+    }
+
+    throw new Error(
+      `\`SourceCode#${methodName}()\` cannot be called inside a rule.`,
+    );
+  } as Prototype[MethodName];
+}
+
 /**
  * Extracts names of {{ placeholders }} from the reported message.
  * @param message Reported message
@@ -117,9 +167,7 @@ function getUnsubstitutedMessagePlaceholders(
 export class RuleTester extends TestFramework {
   readonly #testerConfig: TesterConfigWithDefaults;
   readonly #rules: Record<string, AnyRuleCreateFunction | AnyRuleModule> = {};
-  // `configType` is hardcoded to eslintrc until switch to flat config is complete
-  // We should look to support both eslintrc and flat config for consumers of RuleTester.
-  readonly #linter: Linter = new Linter({ configType: 'eslintrc' });
+  readonly #linter: Linter = new Linter({ configType: 'flat' });
 
   /**
    * Creates a new instance of RuleTester.
@@ -132,11 +180,7 @@ export class RuleTester extends TestFramework {
      * configuration and the default configuration.
      */
     this.#testerConfig = merge({}, defaultConfig, testerConfig, {
-      rules: { 'rule-tester/validate-ast': 'error' },
-      // as of eslint 6 you have to provide an absolute path to the parser
-      // but that's not as clean to type, this saves us trying to manually enforce
-      // that contributors require.resolve everything
-      parser: require.resolve(testerConfig?.parser ?? defaultConfig.parser),
+      rules: { [`${RULE_TESTER_PLUGIN_PREFIX}validate-ast`]: 'error' },
     });
 
     // make sure that the parser doesn't hold onto file handles between tests
@@ -144,11 +188,7 @@ export class RuleTester extends TestFramework {
     const constructor = this.constructor as typeof RuleTester;
     constructor.afterAll(() => {
       try {
-        // instead of creating a hard dependency, just use a soft require
-        // a bit weird, but if they're using this tooling, it'll be installed
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const parser = require(TYPESCRIPT_ESLINT_PARSER) as typeof ParserType;
-        parser.clearCaches();
+        defaultParser.clearCaches();
       } catch {
         // ignored on purpose
       }
@@ -215,8 +255,18 @@ export class RuleTester extends TestFramework {
   /**
    * Define a rule for one particular run of tests.
    */
-  defineRule(name: string, rule: AnyRuleCreateFunction | AnyRuleModule): void {
-    this.#rules[name] = rule;
+  defineRule(name: string, rule: AnyRuleModule): void {
+    this.#rules[name] = {
+      ...rule,
+      // Create a wrapper rule that freezes the `context` properties.
+      create(context): RuleListener {
+        freezeDeeply(context.options);
+        freezeDeeply(context.settings);
+        freezeDeeply(context.parserOptions);
+
+        return (typeof rule === 'function' ? rule : rule.create)(context);
+      },
+    };
   }
 
   #normalizeTests<
@@ -234,7 +284,7 @@ export class RuleTester extends TestFramework {
     */
     const getFilename = (testOptions?: ParserOptions): string => {
       const resolvedOptions = deepMerge(
-        this.#testerConfig.parserOptions,
+        this.#testerConfig.languageOptions.parserOptions,
         testOptions,
       ) as ParserOptions;
       const filename = resolvedOptions.ecmaFeatures?.jsx
@@ -255,18 +305,22 @@ export class RuleTester extends TestFramework {
     >(
       test: T,
     ): T => {
-      if (test.parser === TYPESCRIPT_ESLINT_PARSER) {
+      const { languageOptions = {} } = test;
+      if (languageOptions.parser === parser) {
         throw new Error(DUPLICATE_PARSER_ERROR_MESSAGE);
       }
       if (!test.filename) {
         return {
           ...test,
-          filename: getFilename(test.parserOptions),
-          parserOptions: {
-            // Re-running simulates --fix mode, which implies an isolated program
-            // (i.e. parseAndGenerateServicesCalls[test.filename] > 1).
-            disallowAutomaticSingleRunInference: true,
-            ...test.parserOptions,
+          filename: getFilename(languageOptions.parserOptions),
+          languageOptions: {
+            ...languageOptions,
+            parserOptions: {
+              // Re-running simulates --fix mode, which implies an isolated program
+              // (i.e. parseAndGenerateServicesCalls[test.filename] > 1).
+              disallowAutomaticSingleRunInference: true,
+              ...languageOptions.parserOptions,
+            },
           },
         };
       }
@@ -406,25 +460,6 @@ export class RuleTester extends TestFramework {
 
     const seenValidTestCases = new Set<string>();
     const seenInvalidTestCases = new Set<string>();
-
-    if (typeof rule === 'function') {
-      emitLegacyRuleAPIWarning(ruleName);
-    }
-
-    this.#linter.defineRule(ruleName, {
-      ...rule,
-      // Create a wrapper rule that freezes the `context` properties.
-      create(context: RuleContext<MessageIds, Options>) {
-        freezeDeeply(context.options);
-        freezeDeeply(context.settings);
-        freezeDeeply(context.parserOptions);
-
-        return (typeof rule === 'function' ? rule : rule.create)(context);
-      },
-    });
-
-    this.#linter.defineRules(this.#rules);
-
     const normalizedTests = this.#normalizeTests(test);
 
     function getTestMethod(
@@ -508,7 +543,40 @@ export class RuleTester extends TestFramework {
     config: RuleTesterConfig;
     filename?: string;
   } {
-    let config: TesterConfigWithDefaults = merge({}, this.#testerConfig);
+    this.defineRule(ruleName, rule);
+
+    let config: TesterConfigWithDefaults = merge({}, this.#testerConfig, {
+      files: ['**'],
+      plugins: {
+        [RULE_TESTER_PLUGIN]: {
+          rules: {
+            /**
+             * Setup AST getters.
+             * The goal is to check whether or not AST was modified when
+             * running the rule under test.
+             */
+            'validate-ast': {
+              create(): RuleListener {
+                return {
+                  Program(node: TSESTree.Program): void {
+                    beforeAST = cloneDeeplyExcludesParent(node);
+                  },
+                  'Program:exit'(node: TSESTree.Program): void {
+                    afterAST = node;
+                  },
+                };
+              },
+            },
+            ...this.#rules,
+          },
+        },
+      },
+    });
+
+    // Unlike other properties, we don't want to spread props between different parsers.
+    config.languageOptions.parser =
+      item.languageOptions?.parser ?? this.#testerConfig.languageOptions.parser;
+
     let code;
     let filename;
     let beforeAST: TSESTree.Program;
@@ -551,54 +619,20 @@ export class RuleTester extends TestFramework {
       filename = item.filename;
     }
 
+    const prefixedRuleName = `${RULE_TESTER_PLUGIN_PREFIX}${ruleName}`;
+
     if (hasOwnProperty(item, 'options')) {
       assert(Array.isArray(item.options), 'options must be an array');
-      if (
-        item.options.length > 0 &&
-        typeof rule === 'object' &&
-        (!rule.meta || (rule.meta && rule.meta.schema == null))
-      ) {
-        emitMissingSchemaWarning(ruleName);
-      }
-      config.rules[ruleName] = ['error', ...item.options];
+      config.rules[prefixedRuleName] = ['error', ...item.options];
     } else {
-      config.rules[ruleName] = 'error';
+      config.rules[prefixedRuleName] = 'error';
     }
 
-    const schema = getRuleOptionsSchema(rule);
-
-    /*
-     * Setup AST getters.
-     * The goal is to check whether or not AST was modified when
-     * running the rule under test.
-     */
-    this.#linter.defineRule('rule-tester/validate-ast', {
-      create() {
-        return {
-          Program(node): void {
-            beforeAST = cloneDeeplyExcludesParent(node);
-          },
-          'Program:exit'(node): void {
-            afterAST = node;
-          },
-        };
-      },
-    });
-
-    if (typeof config.parser === 'string') {
-      assert(
-        path.isAbsolute(config.parser),
-        'Parsers provided as strings to RuleTester must be absolute paths',
-      );
-    } else {
-      config.parser = require.resolve(TYPESCRIPT_ESLINT_PARSER);
-    }
+    config.languageOptions ??= {};
+    config.languageOptions.parser ??= defaultParser;
+    config.languageOptions.parser = wrapParser(config.languageOptions.parser);
 
-    this.#linter.defineParser(
-      config.parser,
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      wrapParser(require(config.parser) as Parser.ParserModule),
-    );
+    const schema = getRuleOptionsSchema(rule);
 
     if (schema) {
       ajv.validateSchema(schema);
@@ -638,32 +672,59 @@ export class RuleTester extends TestFramework {
       }
     }
 
-    validate(config, 'rule-tester', id => (id === ruleName ? rule : null));
+    validate(config, RULE_TESTER_PLUGIN, id => (id === ruleName ? rule : null));
 
     // Verify the code.
-    // @ts-expect-error -- we don't define deprecated members on our types
-    const { getComments } = SourceCode.prototype as { getComments: unknown };
-
     let initialMessages: Linter.LintMessage[] | null = null;
     let messages: Linter.LintMessage[] | null = null;
     let fixedResult: SourceCodeFixer.AppliedFixes | null = null;
     let passNumber = 0;
     const outputs: string[] = [];
+    const configWithoutCustomKeys = omitCustomConfigProperties(config);
 
     do {
       passNumber++;
 
+      const { applyLanguageOptions, applyInlineConfig, finalize } =
+        SourceCode.prototype;
+
       try {
-        // @ts-expect-error -- we don't define deprecated members on our types
-        SourceCode.prototype.getComments = getCommentsDeprecation;
-        messages = this.#linter.verify(code, config, filename);
-        if (!initialMessages) {
-          initialMessages = messages;
-        }
+        forbiddenMethods.forEach(methodName => {
+          SourceCode.prototype[methodName] = throwForbiddenMethodError(
+            methodName,
+            SourceCode.prototype,
+          );
+        });
+
+        const actualConfig = merge(configWithoutCustomKeys, {
+          linterOptions: { reportUnusedDisableDirectives: 1 },
+          languageOptions: {
+            ...configWithoutCustomKeys.languageOptions,
+            parserOptions: {
+              ecmaVersion: 'latest',
+              sourceType: 'module',
+              ...configWithoutCustomKeys.languageOptions?.parserOptions,
+            },
+          },
+        });
+        messages = this.#linter.verify(
+          code,
+          // ESLint uses an internal FlatConfigArray that extends @humanwhocodes/config-array.
+          // Linter uses a typeof getConfig === "function" check.
+          // We mock out that check here to force it not to use Linter's cwd as basePath.
+          Object.assign([], {
+            getConfig: () => actualConfig,
+          }),
+          filename,
+        );
       } finally {
-        // @ts-expect-error -- we don't define deprecated members on our types
-        SourceCode.prototype.getComments = getComments;
+        SourceCode.prototype.applyInlineConfig = applyInlineConfig;
+        SourceCode.prototype.applyLanguageOptions = applyLanguageOptions;
+        SourceCode.prototype.finalize = finalize;
       }
+
+      initialMessages ??= messages;
+
       if (messages.length === 0) {
         break;
       }
@@ -683,7 +744,7 @@ export class RuleTester extends TestFramework {
 
       // Verify if autofix makes a syntax error or not.
       const errorMessageInFix = this.#linter
-        .verify(fixedResult.output, config, filename)
+        .verify(fixedResult.output, configWithoutCustomKeys, filename)
         .find(m => m.fatal);
 
       assert(
@@ -702,10 +763,10 @@ export class RuleTester extends TestFramework {
       filename,
       messages: initialMessages,
       outputs,
-      // is definitely assigned within the `rule-tester/validate-ast` rule
+      // is definitely assigned within the `@rule-tester/validate-ast` rule
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       beforeAST: beforeAST!,
-      // is definitely assigned within the `rule-tester/validate-ast` rule
+      // is definitely assigned within the `@rule-tester/validate-ast` rule
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       afterAST: cloneDeeplyExcludesParent(afterAST!),
     };
@@ -799,7 +860,14 @@ export class RuleTester extends TestFramework {
       : null;
 
     const result = this.runRuleForItem(ruleName, rule, item);
-    const messages = result.messages;
+    const messages = result.messages.map(message => ({
+      ...message,
+      ...(message.ruleId && {
+        ruleId: message.ruleId.startsWith(RULE_TESTER_PLUGIN_PREFIX)
+          ? message.ruleId.slice(RULE_TESTER_PLUGIN_PREFIX.length)
+          : message.ruleId,
+      }),
+    }));
 
     for (const message of messages) {
       if (hasOwnProperty(message, 'suggestions')) {
@@ -1130,7 +1198,7 @@ export class RuleTester extends TestFramework {
                     const errorMessageInSuggestion = this.#linter
                       .verify(
                         codeWithAppliedSuggestion,
-                        result.config,
+                        omitCustomConfigProperties(result.config),
                         result.filename,
                       )
                       .find(m => m.fatal);
diff --git a/packages/rule-tester/src/types/RuleTesterConfig.ts b/packages/rule-tester/src/types/RuleTesterConfig.ts
index a51f1a4e0167..1829a0cb48d8 100644
--- a/packages/rule-tester/src/types/RuleTesterConfig.ts
+++ b/packages/rule-tester/src/types/RuleTesterConfig.ts
@@ -1,24 +1,11 @@
-import type {
-  ClassicConfig,
-  ParserOptions,
-} from '@typescript-eslint/utils/ts-eslint';
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
 
 import type { DependencyConstraint } from './DependencyConstraint';
 
-export interface RuleTesterConfig extends ClassicConfig.Config {
-  /**
-   * The default parser to use for tests.
-   * @default '@typescript-eslint/parser'
-   */
-  readonly parser: string;
-  /**
-   * The default parser options to use for tests.
-   */
-  readonly parserOptions?: Readonly<ParserOptions>;
-  /**
-   * Constraints that must pass in the current environment for any tests to run.
-   */
-  readonly dependencyConstraints?: DependencyConstraint;
+/**
+ * Additional configuration options specific to @typescript-eslint/rule-tester.
+ */
+export interface RuleTesterConfig extends FlatConfig.Config {
   /**
    * The default filenames to use for type-aware tests.
    * @default { ts: 'file.ts', tsx: 'react.tsx' }
@@ -27,4 +14,8 @@ export interface RuleTesterConfig extends ClassicConfig.Config {
     ts: string;
     tsx: string;
   }>;
+  /**
+   * Constraints that must pass in the current environment for any tests to run.
+   */
+  readonly dependencyConstraints?: DependencyConstraint;
 }
diff --git a/packages/rule-tester/src/types/ValidTestCase.ts b/packages/rule-tester/src/types/ValidTestCase.ts
index c4aa40456a6a..4f1633b32fef 100644
--- a/packages/rule-tester/src/types/ValidTestCase.ts
+++ b/packages/rule-tester/src/types/ValidTestCase.ts
@@ -1,11 +1,31 @@
 import type {
   Linter,
+  Parser,
   ParserOptions,
   SharedConfigurationSettings,
 } from '@typescript-eslint/utils/ts-eslint';
 
 import type { DependencyConstraint } from './DependencyConstraint';
 
+export interface TestLanguageOptions {
+  /**
+   * Environments for the test case.
+   */
+  readonly env?: Readonly<Linter.EnvironmentConfig>;
+  /**
+   * The additional global variables.
+   */
+  readonly globals?: Readonly<Linter.GlobalsConfig>;
+  /**
+   * The absolute path for the parser.
+   */
+  readonly parser?: Readonly<Parser.LooseParserModule>;
+  /**
+   * Options for the parser.
+   */
+  readonly parserOptions?: Readonly<ParserOptions>;
+}
+
 export interface ValidTestCase<Options extends readonly unknown[]> {
   /**
    * Name for the test case.
@@ -15,30 +35,18 @@ export interface ValidTestCase<Options extends readonly unknown[]> {
    * Code for the test case.
    */
   readonly code: string;
-  /**
-   * Environments for the test case.
-   */
-  readonly env?: Readonly<Linter.EnvironmentConfig>;
   /**
    * The fake filename for the test case. Useful for rules that make assertion about filenames.
    */
   readonly filename?: string;
   /**
-   * The additional global variables.
+   * Language options for the test case.
    */
-  readonly globals?: Readonly<Linter.GlobalsConfig>;
+  readonly languageOptions?: TestLanguageOptions;
   /**
    * Options for the test case.
    */
   readonly options?: Readonly<Options>;
-  /**
-   * The absolute path for the parser.
-   */
-  readonly parser?: string;
-  /**
-   * Options for the parser.
-   */
-  readonly parserOptions?: Readonly<ParserOptions>;
   /**
    * Settings for the test case.
    */
diff --git a/packages/rule-tester/src/types/index.ts b/packages/rule-tester/src/types/index.ts
index 93dad319d936..bd04d11e050c 100644
--- a/packages/rule-tester/src/types/index.ts
+++ b/packages/rule-tester/src/types/index.ts
@@ -6,7 +6,9 @@ type Mutable<T> = {
   -readonly [P in keyof T]: T[P];
 };
 export type TesterConfigWithDefaults = Mutable<
-  Required<Pick<RuleTesterConfig, 'defaultFilenames' | 'parser' | 'rules'>> &
+  Required<
+    Pick<RuleTesterConfig, 'defaultFilenames' | 'languageOptions' | 'rules'>
+  > &
     RuleTesterConfig
 >;
 
diff --git a/packages/rule-tester/src/utils/config-schema.ts b/packages/rule-tester/src/utils/config-schema.ts
deleted file mode 100644
index 8aaa46d4cace..000000000000
--- a/packages/rule-tester/src/utils/config-schema.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-// Forked from https://github.com/eslint/eslint/blob/ad9dd6a933fd098a0d99c6a9aa059850535c23ee/conf/config-schema.js
-
-import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
-
-const baseConfigProperties: Record<string, JSONSchema4> = {
-  $schema: { type: 'string' },
-  defaultFilenames: {
-    type: 'object',
-    properties: {
-      ts: { type: 'string' },
-      tsx: { type: 'string' },
-    },
-    required: ['ts', 'tsx'],
-    additionalProperties: false,
-  },
-  dependencyConstraints: {
-    type: 'object',
-    additionalProperties: {
-      type: 'string',
-    },
-  },
-  env: { type: 'object' },
-  extends: { $ref: '#/definitions/stringOrStrings' },
-  globals: { type: 'object' },
-  noInlineConfig: { type: 'boolean' },
-  overrides: {
-    type: 'array',
-    items: { $ref: '#/definitions/overrideConfig' },
-    additionalItems: false,
-  },
-  parser: { type: ['string', 'null'] },
-  parserOptions: { type: 'object' },
-  plugins: { type: 'array' },
-  processor: { type: 'string' },
-  reportUnusedDisableDirectives: { type: 'boolean' },
-  rules: { type: 'object' },
-  settings: { type: 'object' },
-
-  ecmaFeatures: { type: 'object' }, // deprecated; logs a warning when used
-};
-
-export const configSchema: JSONSchema4 = {
-  definitions: {
-    stringOrStrings: {
-      oneOf: [
-        { type: 'string' },
-        {
-          type: 'array',
-          items: { type: 'string' },
-          additionalItems: false,
-        },
-      ],
-    },
-    stringOrStringsRequired: {
-      oneOf: [
-        { type: 'string' },
-        {
-          type: 'array',
-          items: { type: 'string' },
-          additionalItems: false,
-          minItems: 1,
-        },
-      ],
-    },
-
-    // Config at top-level.
-    objectConfig: {
-      type: 'object',
-      properties: {
-        root: { type: 'boolean' },
-        ignorePatterns: { $ref: '#/definitions/stringOrStrings' },
-        ...baseConfigProperties,
-      },
-      additionalProperties: false,
-    },
-
-    // Config in `overrides`.
-    overrideConfig: {
-      type: 'object',
-      properties: {
-        excludedFiles: { $ref: '#/definitions/stringOrStrings' },
-        files: { $ref: '#/definitions/stringOrStringsRequired' },
-        ...baseConfigProperties,
-      },
-      required: ['files'],
-      additionalProperties: false,
-    },
-  },
-
-  $ref: '#/definitions/objectConfig',
-};
diff --git a/packages/rule-tester/src/utils/config-validator.ts b/packages/rule-tester/src/utils/config-validator.ts
index ac90b8c21eea..3a400d48a5ca 100644
--- a/packages/rule-tester/src/utils/config-validator.ts
+++ b/packages/rule-tester/src/utils/config-validator.ts
@@ -2,7 +2,6 @@
 
 import util from 'node:util';
 
-import { Legacy } from '@eslint/eslintrc';
 import type { AnyRuleModule, Linter } from '@typescript-eslint/utils/ts-eslint';
 import type {
   AdditionalPropertiesParams,
@@ -13,14 +12,13 @@ import { builtinRules } from 'eslint/use-at-your-own-risk';
 
 import type { TesterConfigWithDefaults } from '../types';
 import { ajvBuilder } from './ajv';
-import { configSchema } from './config-schema';
 import { emitDeprecationWarning } from './deprecation-warnings';
+import { flatConfigSchema } from './flat-config-schema';
 import { getRuleOptionsSchema } from './getRuleOptionsSchema';
 import { hasOwnProperty } from './hasOwnProperty';
 
 type GetAdditionalRule = (ruleId: string) => AnyRuleModule | null;
 
-const { ConfigOps, environments: BuiltInEnvironments } = Legacy;
 const ajv = ajvBuilder();
 const ruleValidators = new WeakMap<AnyRuleModule, ValidateFunction>();
 
@@ -126,31 +124,6 @@ function validateRuleOptions(
   }
 }
 
-/**
- * Validates an environment object
- * @param environment The environment config object to validate.
- * @param source The name of the configuration source to report in any errors.
- */
-function validateEnvironment(
-  environment: Linter.EnvironmentConfig | undefined,
-  source: string,
-): void {
-  // not having an environment is ok
-  if (!environment) {
-    return;
-  }
-
-  Object.keys(environment).forEach(id => {
-    const env = BuiltInEnvironments.get(id) ?? null;
-
-    if (!env) {
-      const message = `${source}:\n\tEnvironment key "${id}" is unknown\n`;
-
-      throw new Error(message);
-    }
-  });
-}
-
 /**
  * Validates a rules config object
  * @param rulesConfig The rules config object to validate.
@@ -177,34 +150,6 @@ function validateRules(
   });
 }
 
-/**
- * Validates a `globals` section of a config file
- * @param globalsConfig The `globals` section
- * @param source The name of the configuration source to report in the event of an error.
- */
-function validateGlobals(
-  globalsConfig: Linter.GlobalsConfig | undefined,
-  source: string | null = null,
-): void {
-  if (!globalsConfig) {
-    return;
-  }
-
-  Object.entries(globalsConfig).forEach(
-    ([configuredGlobal, configuredValue]) => {
-      try {
-        ConfigOps.normalizeConfigGlobal(configuredValue);
-      } catch (err) {
-        throw new Error(
-          `ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\n${
-            (err as Error).message
-          }`,
-        );
-      }
-    },
-  );
-}
-
 /**
  * Formats an array of schema validation errors.
  */
@@ -251,7 +196,7 @@ function validateConfigSchema(
   config: TesterConfigWithDefaults,
   source: string,
 ): void {
-  validateSchema ||= ajv.compile(configSchema);
+  validateSchema ||= ajv.compile(flatConfigSchema);
 
   if (!validateSchema(config)) {
     throw new Error(
@@ -281,12 +226,4 @@ export function validate(
 ): void {
   validateConfigSchema(config, source);
   validateRules(config.rules, source, getAdditionalRule);
-  validateEnvironment(config.env, source);
-  validateGlobals(config.globals, source);
-
-  for (const override of config.overrides ?? []) {
-    validateRules(override.rules, source, getAdditionalRule);
-    validateEnvironment(override.env, source);
-    validateGlobals(config.globals, source);
-  }
 }
diff --git a/packages/rule-tester/src/utils/flat-config-schema.ts b/packages/rule-tester/src/utils/flat-config-schema.ts
new file mode 100644
index 000000000000..89a1e18fad71
--- /dev/null
+++ b/packages/rule-tester/src/utils/flat-config-schema.ts
@@ -0,0 +1,583 @@
+// Forked from https://github.com/eslint/eslint/blob/4b23ffd6454cfb1a269430f5fe28e7d1c37b9d3e/lib/config/flat-config-schema.js
+
+import type {
+  Processor,
+  SharedConfig,
+} from '@typescript-eslint/utils/ts-eslint';
+
+import { normalizeSeverityToNumber } from './severity';
+
+type PluginMemberName = `${string}/${string}`;
+
+interface ObjectPropertySchema<T = unknown> {
+  merge: string | ((a: T, b: T) => T);
+  validate: string | ((value: unknown) => asserts value is T);
+}
+
+const ruleSeverities = new Map<SharedConfig.RuleLevel, SharedConfig.Severity>([
+  [0, 0],
+  ['off', 0],
+  [1, 1],
+  ['warn', 1],
+  [2, 2],
+  ['error', 2],
+]);
+
+/**
+ * Check if a value is a non-null object.
+ * @param value The value to check.
+ * @returns `true` if the value is a non-null object.
+ */
+function isNonNullObject(value: unknown): boolean {
+  // eslint-disable-next-line eqeqeq
+  return typeof value === 'object' && value !== null;
+}
+
+/**
+ * Check if a value is a non-null non-array object.
+ * @param value The value to check.
+ * @returns `true` if the value is a non-null non-array object.
+ */
+function isNonArrayObject(value: unknown): boolean {
+  return isNonNullObject(value) && !Array.isArray(value);
+}
+
+/**
+ * Deeply merges two non-array objects.
+ * @param first The base object.
+ * @param second The overrides object.
+ * @param mergeMap Maps the combination of first and second arguments to a merged result.
+ * @returns An object with properties from both first and second.
+ */
+function deepMerge<First extends object, Second extends object>(
+  first: First,
+  second: Second,
+  mergeMap = new Map<First | Second, Map<First | Second, First & Second>>(),
+): First & Second {
+  let secondMergeMap = mergeMap.get(first);
+
+  if (secondMergeMap) {
+    const result = secondMergeMap.get(second);
+
+    if (result) {
+      // If this combination of first and second arguments has been already visited, return the previously created result.
+      return result;
+    }
+  } else {
+    secondMergeMap = new Map();
+    mergeMap.set(first, secondMergeMap);
+  }
+
+  /*
+   * First create a result object where properties from the second object
+   * overwrite properties from the first. This sets up a baseline to use
+   * later rather than needing to inspect and change every property
+   * individually.
+   */
+  const result = {
+    ...first,
+    ...second,
+  } as First & Second & ObjectLike;
+
+  delete (result as ObjectLike).__proto__; // don't merge own property "__proto__"
+
+  // Store the pending result for this combination of first and second arguments.
+  secondMergeMap.set(second, result);
+
+  for (const key of Object.keys(second)) {
+    // avoid hairy edge case
+    if (
+      key === '__proto__' ||
+      !Object.prototype.propertyIsEnumerable.call(first, key)
+    ) {
+      continue;
+    }
+
+    const firstValue = (first as ObjectLike)[key] as object | undefined;
+    const secondValue = (second as ObjectLike)[key] as object | undefined;
+
+    if (isNonArrayObject(firstValue) && isNonArrayObject(secondValue)) {
+      (result as ObjectLike)[key] = deepMerge(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        firstValue!,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        secondValue!,
+        mergeMap,
+      );
+    } else if (secondValue === undefined) {
+      (result as ObjectLike)[key] = firstValue;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Normalizes the rule options config for a given rule by ensuring that
+ * it is an array and that the first item is 0, 1, or 2.
+ * @param ruleOptions The rule options config.
+ * @returns An array of rule options.
+ */
+function normalizeRuleOptions(
+  ruleOptions: SharedConfig.RuleLevel | SharedConfig.RuleLevelAndOptions,
+): SharedConfig.RuleLevelAndOptions {
+  const finalOptions = Array.isArray(ruleOptions)
+    ? ruleOptions.slice(0)
+    : [ruleOptions];
+
+  finalOptions[0] = ruleSeverities.get(
+    finalOptions[0] as SharedConfig.RuleLevel,
+  );
+
+  return structuredClone(finalOptions as SharedConfig.RuleLevelAndOptions);
+}
+
+/**
+ * Determines if an object has any methods.
+ * @param object The object to check.
+ * @returns `true` if the object has any methods.
+ */
+function hasMethod(object: Record<string, unknown>): boolean {
+  for (const key of Object.keys(object)) {
+    if (typeof object[key] === 'function') {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * The error type when a rule's options are configured with an invalid type.
+ */
+class InvalidRuleOptionsError extends Error {
+  readonly messageTemplate: string;
+  readonly messageData: { ruleId: string; value: unknown };
+
+  constructor(ruleId: string, value: unknown) {
+    super(
+      `Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`,
+    );
+    this.messageTemplate = 'invalid-rule-options';
+    this.messageData = { ruleId, value };
+  }
+}
+
+/**
+ * Validates that a value is a valid rule options entry.
+ * @param ruleId Rule name being configured.
+ * @param value The value to check.
+ * @throws {InvalidRuleOptionsError} If the value isn't a valid rule options.
+ */
+function assertIsRuleOptions(ruleId: string, value: unknown): void {
+  if (
+    typeof value !== 'string' &&
+    typeof value !== 'number' &&
+    !Array.isArray(value)
+  ) {
+    throw new InvalidRuleOptionsError(ruleId, value);
+  }
+}
+
+/**
+ * The error type when a rule's severity is invalid.
+ */
+class InvalidRuleSeverityError extends Error {
+  readonly messageTemplate: string;
+  readonly messageData: { ruleId: string; value: unknown };
+
+  constructor(ruleId: string, value: unknown) {
+    super(
+      `Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`,
+    );
+    this.messageTemplate = 'invalid-rule-severity';
+    this.messageData = { ruleId, value };
+  }
+}
+
+/**
+ * Validates that a value is valid rule severity.
+ * @param ruleId Rule name being configured.
+ * @param value The value to check.
+ * @throws {InvalidRuleSeverityError} If the value isn't a valid rule severity.
+ */
+function assertIsRuleSeverity(ruleId: string, value: unknown): void {
+  const severity = ruleSeverities.get(value as SharedConfig.RuleLevel);
+
+  if (severity === undefined) {
+    throw new InvalidRuleSeverityError(ruleId, value);
+  }
+}
+
+/**
+ * Validates that a given string is the form pluginName/objectName.
+ * @param value The string to check.
+ */
+function assertIsPluginMemberName(
+  value: unknown,
+): asserts value is PluginMemberName {
+  if (
+    typeof value !== 'string' ||
+    !/[@a-z0-9-_$]+(?:\/(?:[a-z0-9-_$]+))+$/iu.test(value)
+  ) {
+    throw new TypeError(
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Expected string in the form "pluginName/objectName" but found "${value}".`,
+    );
+  }
+}
+
+/**
+ * Validates that a value is an object.
+ * @param value The value to check.
+ */
+function assertIsObject(value: unknown): void {
+  if (!isNonNullObject(value)) {
+    throw new TypeError('Expected an object.');
+  }
+}
+
+/**
+ * The error type when there's an eslintrc-style options in a flat config.
+ */
+class IncompatibleKeyError extends Error {
+  readonly messageTemplate: string;
+  readonly messageData: { key: string };
+
+  /**
+   * @param key The invalid key.
+   */
+  constructor(key: string) {
+    super(
+      'This appears to be in eslintrc format rather than flat config format.',
+    );
+    this.messageTemplate = 'eslintrc-incompat';
+    this.messageData = { key };
+  }
+}
+
+/**
+ * The error type when there's an eslintrc-style plugins array found.
+ */
+class IncompatiblePluginsError extends Error {
+  readonly messageTemplate: string;
+  readonly messageData: { plugins: string[] };
+
+  constructor(plugins: string[]) {
+    super(
+      'This appears to be in eslintrc format (array of strings) rather than flat config format (object).',
+    );
+    this.messageTemplate = 'eslintrc-plugins';
+    this.messageData = { plugins };
+  }
+}
+
+const booleanSchema = {
+  merge: 'replace',
+  validate: 'boolean',
+} satisfies ObjectPropertySchema;
+
+const ALLOWED_SEVERITIES = new Set(['error', 'warn', 'off', 2, 1, 0]);
+
+const disableDirectiveSeveritySchema: ObjectPropertySchema<SharedConfig.RuleLevel> =
+  {
+    merge(
+      first: SharedConfig.RuleLevel | boolean | undefined,
+      second: SharedConfig.RuleLevel | boolean | undefined,
+    ): SharedConfig.RuleLevel {
+      const value = second ?? first;
+
+      if (typeof value === 'boolean') {
+        return value ? 'warn' : 'off';
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return normalizeSeverityToNumber(value!);
+    },
+    validate(value: unknown) {
+      if (
+        !(
+          ALLOWED_SEVERITIES.has(value as string | number) ||
+          typeof value === 'boolean'
+        )
+      ) {
+        throw new TypeError(
+          'Expected one of: "error", "warn", "off", 0, 1, 2, or a boolean.',
+        );
+      }
+    },
+  };
+
+const deepObjectAssignSchema = {
+  merge<First extends ObjectLike, Second extends ObjectLike>(
+    first = {} as First,
+    second = {} as Second,
+  ): First & Second {
+    return deepMerge(first, second);
+  },
+  validate: 'object',
+};
+
+export type ObjectLike = Record<string, unknown>;
+
+const languageOptionsSchema = {
+  merge(first: ObjectLike = {}, second: ObjectLike = {}): object {
+    const result = deepMerge(first, second);
+
+    for (const [key, value] of Object.entries(result)) {
+      /*
+       * Special case: Because the `parser` property is an object, it should
+       * not be deep merged. Instead, it should be replaced if it exists in
+       * the second object. To make this more generic, we just check for
+       * objects with methods and replace them if they exist in the second
+       * object.
+       */
+      if (isNonArrayObject(value)) {
+        if (hasMethod(value as ObjectLike)) {
+          result[key] = second[key] ?? first[key];
+          continue;
+        }
+
+        // for other objects, make sure we aren't reusing the same object
+        result[key] = { ...(result[key] as ObjectLike) };
+        continue;
+      }
+    }
+
+    return result;
+  },
+  validate: 'object',
+};
+
+const languageSchema: ObjectPropertySchema<PluginMemberName> = {
+  merge: 'replace',
+  validate: assertIsPluginMemberName,
+};
+
+const pluginsSchema = {
+  merge(first: ObjectLike = {}, second: ObjectLike = {}): object {
+    const keys = new Set([...Object.keys(first), ...Object.keys(second)]);
+    const result: ObjectLike = {};
+
+    // manually validate that plugins are not redefined
+    for (const key of keys) {
+      // avoid hairy edge case
+      if (key === '__proto__') {
+        continue;
+      }
+
+      if (key in first && key in second && first[key] !== second[key]) {
+        throw new TypeError(`Cannot redefine plugin "${key}".`);
+      }
+
+      result[key] = second[key] || first[key];
+    }
+
+    return result;
+  },
+  validate(value: unknown): void {
+    // first check the value to be sure it's an object
+    if (value == null || typeof value !== 'object') {
+      throw new TypeError('Expected an object.');
+    }
+
+    // make sure it's not an array, which would mean eslintrc-style is used
+    if (Array.isArray(value)) {
+      throw new IncompatiblePluginsError(value as string[]);
+    }
+
+    // second check the keys to make sure they are objects
+    for (const key of Object.keys(value)) {
+      // avoid hairy edge case
+      if (key === '__proto__') {
+        continue;
+      }
+
+      if (
+        (value as ObjectLike)[key] == null ||
+        typeof (value as ObjectLike)[key] !== 'object'
+      ) {
+        throw new TypeError(`Key "${key}": Expected an object.`);
+      }
+    }
+  },
+};
+
+const processorSchema: ObjectPropertySchema<Processor.LooseProcessorModule> = {
+  merge: 'replace',
+  validate(value: unknown) {
+    if (typeof value === 'string') {
+      assertIsPluginMemberName(value);
+    } else if (value && typeof value === 'object') {
+      if (
+        typeof (value as Processor.LooseProcessorModule).preprocess !==
+          'function' ||
+        typeof (value as Processor.LooseProcessorModule).postprocess !==
+          'function'
+      ) {
+        throw new TypeError(
+          'Object must have a preprocess() and a postprocess() method.',
+        );
+      }
+    } else {
+      throw new TypeError('Expected an object or a string.');
+    }
+  },
+};
+
+type ConfigRules = Record<string, SharedConfig.RuleLevelAndOptions>;
+
+const rulesSchema = {
+  merge(first: ConfigRules = {}, second: ConfigRules = {}): ConfigRules {
+    const result: ConfigRules = {
+      ...first,
+      ...second,
+    };
+
+    for (const ruleId of Object.keys(result)) {
+      try {
+        // avoid hairy edge case
+        if (ruleId === '__proto__') {
+          delete result.__proto__;
+          continue;
+        }
+
+        result[ruleId] = normalizeRuleOptions(result[ruleId]);
+
+        /*
+         * If either rule config is missing, then the correct
+         * config is already present and we just need to normalize
+         * the severity.
+         */
+        if (!(ruleId in first) || !(ruleId in second)) {
+          continue;
+        }
+
+        const firstRuleOptions = normalizeRuleOptions(first[ruleId]);
+        const secondRuleOptions = normalizeRuleOptions(second[ruleId]);
+
+        /*
+         * If the second rule config only has a severity (length of 1),
+         * then use that severity and keep the rest of the options from
+         * the first rule config.
+         */
+        if (secondRuleOptions.length === 1) {
+          result[ruleId] = [secondRuleOptions[0], ...firstRuleOptions.slice(1)];
+          continue;
+        }
+
+        /*
+         * In any other situation, then the second rule config takes
+         * precedence. That means the value at `result[ruleId]` is
+         * already correct and no further work is necessary.
+         */
+      } catch (ex) {
+        throw new Error(`Key "${ruleId}": ${(ex as Error).message}`, {
+          cause: ex,
+        });
+      }
+    }
+
+    return result;
+  },
+
+  validate(value: ConfigRules): void {
+    assertIsObject(value);
+
+    /*
+     * We are not checking the rule schema here because there is no
+     * guarantee that the rule definition is present at this point. Instead
+     * we wait and check the rule schema during the finalization step
+     * of calculating a config.
+     */
+    for (const ruleId of Object.keys(value)) {
+      // avoid hairy edge case
+      if (ruleId === '__proto__') {
+        continue;
+      }
+
+      const ruleOptions = value[ruleId];
+
+      assertIsRuleOptions(ruleId, ruleOptions);
+
+      if (Array.isArray(ruleOptions)) {
+        assertIsRuleSeverity(ruleId, ruleOptions[0]);
+      } else {
+        assertIsRuleSeverity(ruleId, ruleOptions);
+      }
+    }
+  },
+};
+
+/**
+ * Creates a schema that always throws an error. Useful for warning
+ * about eslintrc-style keys.
+ * @param key The eslintrc key to create a schema for.
+ */
+function createEslintrcErrorSchema(key: string): ObjectPropertySchema {
+  return {
+    merge: 'replace',
+    validate(): void {
+      throw new IncompatibleKeyError(key);
+    },
+  };
+}
+
+const eslintrcKeys = [
+  'env',
+  'extends',
+  'globals',
+  'ignorePatterns',
+  'noInlineConfig',
+  'overrides',
+  'parser',
+  'parserOptions',
+  'reportUnusedDisableDirectives',
+  'root',
+];
+
+export const flatConfigSchema = {
+  $schema: { type: 'string' },
+
+  // Original ESLint schemas from flat-config-schema.js
+
+  // eslintrc-style keys that should always error
+  ...Object.fromEntries(
+    eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)]),
+  ),
+
+  // flat config keys
+  settings: deepObjectAssignSchema,
+  linterOptions: {
+    schema: {
+      noInlineConfig: booleanSchema,
+      reportUnusedDisableDirectives: disableDirectiveSeveritySchema,
+    },
+  },
+  language: languageSchema,
+  languageOptions: languageOptionsSchema,
+  processor: processorSchema,
+  plugins: pluginsSchema,
+  rules: rulesSchema,
+
+  // not in ESLint source, but seemingly relevant?
+  files: { type: 'array', items: { type: 'string' } },
+
+  // @typescript-eslint/rule-tester extensions
+
+  defaultFilenames: {
+    type: 'object',
+    properties: {
+      ts: { type: 'string' },
+      tsx: { type: 'string' },
+    },
+    required: ['ts', 'tsx'],
+    additionalProperties: false,
+  },
+  dependencyConstraints: {
+    type: 'object',
+    additionalProperties: {
+      type: 'string',
+    },
+  },
+};
diff --git a/packages/rule-tester/src/utils/omitCustomConfigProperties.ts b/packages/rule-tester/src/utils/omitCustomConfigProperties.ts
new file mode 100644
index 000000000000..711540cfbcba
--- /dev/null
+++ b/packages/rule-tester/src/utils/omitCustomConfigProperties.ts
@@ -0,0 +1,12 @@
+import type { RuleTesterConfig } from '../types/RuleTesterConfig';
+
+export function omitCustomConfigProperties(
+  config: Partial<RuleTesterConfig>,
+): Omit<typeof config, 'defaultFilenames'> {
+  const copy = { ...config };
+
+  delete copy.defaultFilenames;
+  delete copy.dependencyConstraints;
+
+  return copy;
+}
diff --git a/packages/rule-tester/src/utils/severity.ts b/packages/rule-tester/src/utils/severity.ts
new file mode 100644
index 000000000000..899bcee2bbe2
--- /dev/null
+++ b/packages/rule-tester/src/utils/severity.ts
@@ -0,0 +1,43 @@
+// Forked from: https://github.com/eslint/eslint/blob/0dd9704c4751e1cd02039f7d6485fee09bbccbf6/lib/shared/severity.js
+
+import type { SharedConfig } from '@typescript-eslint/utils/ts-eslint';
+
+/**
+ * Convert severity value of different types to a string.
+ * @param  severity severity value
+ * @throws error if severity is invalid
+ */
+export function normalizeSeverityToString(
+  severity: SharedConfig.RuleLevel,
+): SharedConfig.SeverityString {
+  if ([2, '2', 'error'].includes(severity)) {
+    return 'error';
+  }
+  if ([1, '1', 'warn'].includes(severity)) {
+    return 'warn';
+  }
+  if ([0, '0', 'off'].includes(severity)) {
+    return 'off';
+  }
+  throw new Error(`Invalid severity value: ${severity}`);
+}
+
+/**
+ * Convert severity value of different types to a number.
+ * @param  severity severity value
+ * @throws error if severity is invalid
+ */
+export function normalizeSeverityToNumber(
+  severity: SharedConfig.RuleLevel,
+): SharedConfig.Severity {
+  if ([2, '2', 'error'].includes(severity)) {
+    return 2;
+  }
+  if ([1, '1', 'warn'].includes(severity)) {
+    return 1;
+  }
+  if ([0, '0', 'off'].includes(severity)) {
+    return 0;
+  }
+  throw new Error(`Invalid severity value: ${severity}`);
+}
diff --git a/packages/rule-tester/src/utils/validationHelpers.ts b/packages/rule-tester/src/utils/validationHelpers.ts
index 34b0bac1b4dd..fe054ad5b256 100644
--- a/packages/rule-tester/src/utils/validationHelpers.ts
+++ b/packages/rule-tester/src/utils/validationHelpers.ts
@@ -76,7 +76,9 @@ const parserSymbol = Symbol.for('eslint.RuleTester.parser');
  * Wraps the given parser in order to intercept and modify return values from the `parse` and `parseForESLint` methods, for test purposes.
  * In particular, to modify ast nodes, tokens and comments to throw on access to their `start` and `end` properties.
  */
-export function wrapParser(parser: Parser.ParserModule): Parser.ParserModule {
+export function wrapParser(
+  parser: Parser.LooseParserModule,
+): Parser.LooseParserModule {
   /**
    * Define `start`/`end` properties of all nodes of the given AST as throwing error.
    */
@@ -123,10 +125,10 @@ export function wrapParser(parser: Parser.ParserModule): Parser.ParserModule {
       // @ts-expect-error -- see above
       [parserSymbol]: parser,
       parseForESLint(...args): Parser.ParseResult {
-        const ret = parser.parseForESLint(...args);
+        const parsed = parser.parseForESLint(...args) as Parser.ParseResult;
 
-        defineStartEndAsErrorInTree(ret.ast, ret.visitorKeys);
-        return ret;
+        defineStartEndAsErrorInTree(parsed.ast, parsed.visitorKeys);
+        return parsed;
       },
     };
   }
@@ -135,7 +137,7 @@ export function wrapParser(parser: Parser.ParserModule): Parser.ParserModule {
     // @ts-expect-error -- see above
     [parserSymbol]: parser,
     parse(...args): TSESTree.Program {
-      const ast = parser.parse(...args);
+      const ast = parser.parse(...args) as TSESTree.Program;
 
       defineStartEndAsErrorInTree(ast);
       return ast;
@@ -143,41 +145,4 @@ export function wrapParser(parser: Parser.ParserModule): Parser.ParserModule {
   };
 }
 
-/**
- * Function to replace `SourceCode.prototype.getComments`.
- */
-export function getCommentsDeprecation(): never {
-  throw new Error(
-    '`SourceCode#getComments()` is deprecated and will be removed in a future major version. Use `getCommentsBefore()`, `getCommentsAfter()`, and `getCommentsInside()` instead.',
-  );
-}
-
-const EMIT_LEGACY_RULE_API_WARNING: Record<string, boolean> = {};
-/**
- * Emit a deprecation warning if function-style format is being used.
- */
-export function emitLegacyRuleAPIWarning(ruleName: string): void {
-  if (!EMIT_LEGACY_RULE_API_WARNING[`warned-${ruleName}`]) {
-    EMIT_LEGACY_RULE_API_WARNING[`warned-${ruleName}`] = true;
-    process.emitWarning(
-      `"${ruleName}" rule is using the deprecated function-style format and will stop working in ESLint v9. Please use object-style format: https://eslint.org/docs/latest/extend/custom-rules`,
-      'DeprecationWarning',
-    );
-  }
-}
-
-const EMIT_MISSING_SCHEMA_WARNING: Record<string, boolean> = {};
-/**
- * Emit a deprecation warning if rule has options but is missing the "meta.schema" property
- */
-export function emitMissingSchemaWarning(ruleName: string): void {
-  if (!EMIT_MISSING_SCHEMA_WARNING[`warned-${ruleName}`]) {
-    EMIT_MISSING_SCHEMA_WARNING[`warned-${ruleName}`] = true;
-    process.emitWarning(
-      `"${ruleName}" rule has options but is missing the "meta.schema" property and will stop working in ESLint v9. Please add a schema: https://eslint.org/docs/latest/extend/custom-rules#options-schemas`,
-      'DeprecationWarning',
-    );
-  }
-}
-
 export const REQUIRED_SCENARIOS = ['valid', 'invalid'] as const;
diff --git a/packages/rule-tester/tests/RuleTester.test.ts b/packages/rule-tester/tests/RuleTester.test.ts
index fe765a5fd024..169f7aa3a346 100644
--- a/packages/rule-tester/tests/RuleTester.test.ts
+++ b/packages/rule-tester/tests/RuleTester.test.ts
@@ -131,7 +131,7 @@ describe('RuleTester', () => {
       outputs: [testCase.code],
       afterAST: EMPTY_PROGRAM,
       beforeAST: EMPTY_PROGRAM,
-      config: { parser: '' },
+      config: {},
     };
   });
 
@@ -144,10 +144,12 @@ describe('RuleTester', () => {
   describe('filenames', () => {
     it('automatically sets the filename for tests', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
-        parserOptions: {
-          project: 'tsconfig.json',
-          tsconfigRootDir: '/some/path/that/totally/exists/',
+        languageOptions: {
+          parser,
+          parserOptions: {
+            project: 'tsconfig.json',
+            tsconfigRootDir: '/some/path/that/totally/exists/',
+          },
         },
       });
 
@@ -163,17 +165,21 @@ describe('RuleTester', () => {
           },
           {
             code: 'jsx should have the correct filename',
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
+            languageOptions: {
+              parserOptions: {
+                ecmaFeatures: {
+                  jsx: true,
+                },
               },
             },
           },
           {
             code: 'type-aware parser options should override the constructor config',
-            parserOptions: {
-              project: 'tsconfig.test-specific.json',
-              tsconfigRootDir: '/set/in/the/test/',
+            languageOptions: {
+              parserOptions: {
+                project: 'tsconfig.test-specific.json',
+                tsconfigRootDir: '/set/in/the/test/',
+              },
             },
           },
         ],
@@ -190,15 +196,19 @@ describe('RuleTester', () => {
           {
             "code": "string based valid test",
             "filename": "/some/path/that/totally/exists/file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
           },
           {
             "code": "object based valid test",
             "filename": "/some/path/that/totally/exists/file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
           },
           {
@@ -208,20 +218,24 @@ describe('RuleTester', () => {
           {
             "code": "jsx should have the correct filename",
             "filename": "/some/path/that/totally/exists/react.tsx",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
-              "ecmaFeatures": {
-                "jsx": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+                "ecmaFeatures": {
+                  "jsx": true,
+                },
               },
             },
           },
           {
             "code": "type-aware parser options should override the constructor config",
             "filename": "/set/in/the/test/file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
-              "project": "tsconfig.test-specific.json",
-              "tsconfigRootDir": "/set/in/the/test/",
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+                "project": "tsconfig.test-specific.json",
+                "tsconfigRootDir": "/set/in/the/test/",
+              },
             },
           },
           {
@@ -232,8 +246,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "/some/path/that/totally/exists/file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
           },
         ]
@@ -242,10 +258,12 @@ describe('RuleTester', () => {
 
     it('allows the automated filenames to be overridden in the constructor', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
-        parserOptions: {
-          project: 'tsconfig.json',
-          tsconfigRootDir: '/some/path/that/totally/exists/',
+        languageOptions: {
+          parser,
+          parserOptions: {
+            project: 'tsconfig.json',
+            tsconfigRootDir: '/some/path/that/totally/exists/',
+          },
         },
         defaultFilenames: {
           ts: 'set-in-constructor.ts',
@@ -260,9 +278,11 @@ describe('RuleTester', () => {
           },
           {
             code: 'jsx',
-            parserOptions: {
-              ecmaFeatures: {
-                jsx: true,
+            languageOptions: {
+              parserOptions: {
+                ecmaFeatures: {
+                  jsx: true,
+                },
               },
             },
           },
@@ -275,17 +295,21 @@ describe('RuleTester', () => {
           {
             "code": "normal",
             "filename": "/some/path/that/totally/exists/set-in-constructor.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
           },
           {
             "code": "jsx",
             "filename": "/some/path/that/totally/exists/react-set-in-constructor.tsx",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
-              "ecmaFeatures": {
-                "jsx": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+                "ecmaFeatures": {
+                  "jsx": true,
+                },
               },
             },
           },
@@ -297,11 +321,13 @@ describe('RuleTester', () => {
   it('schedules the parser caches to be cleared afterAll', () => {
     // it should schedule the afterAll
     expect(mockedAfterAll).toHaveBeenCalledTimes(0);
-    const _ruleTester = new RuleTester({
-      parser: '@typescript-eslint/parser',
-      parserOptions: {
-        project: 'tsconfig.json',
-        tsconfigRootDir: '/some/path/that/totally/exists/',
+    new RuleTester({
+      languageOptions: {
+        parser,
+        parserOptions: {
+          project: 'tsconfig.json',
+          tsconfigRootDir: '/some/path/that/totally/exists/',
+        },
       },
     });
     expect(mockedAfterAll).toHaveBeenCalledTimes(1);
@@ -316,10 +342,12 @@ describe('RuleTester', () => {
 
   it('throws an error if you attempt to set the parser to ts-eslint at the test level', () => {
     const ruleTester = new RuleTester({
-      parser: '@typescript-eslint/parser',
-      parserOptions: {
-        project: 'tsconfig.json',
-        tsconfigRootDir: '/some/path/that/totally/exists/',
+      languageOptions: {
+        parser,
+        parserOptions: {
+          project: 'tsconfig.json',
+          tsconfigRootDir: '/some/path/that/totally/exists/',
+        },
       },
     });
 
@@ -328,7 +356,7 @@ describe('RuleTester', () => {
         valid: [
           {
             code: 'object based valid test',
-            parser: '@typescript-eslint/parser',
+            languageOptions: { parser },
           },
         ],
 
@@ -342,7 +370,7 @@ describe('RuleTester', () => {
   describe('checks dependencies as specified', () => {
     it('does not check dependencies if there are no dependency constraints', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
+        languageOptions: { parser },
       });
 
       ruleTester.run('my-rule', NOOP_RULE, {
@@ -361,7 +389,7 @@ describe('RuleTester', () => {
     describe('does not check dependencies if is an "only" manually set', () => {
       it('in the valid section', () => {
         const ruleTester = new RuleTester({
-          parser: '@typescript-eslint/parser',
+          languageOptions: { parser },
         });
 
         ruleTester.run('my-rule', NOOP_RULE, {
@@ -387,7 +415,7 @@ describe('RuleTester', () => {
 
       it('in the invalid section', () => {
         const ruleTester = new RuleTester({
-          parser: '@typescript-eslint/parser',
+          languageOptions: { parser },
         });
 
         ruleTester.run('my-rule', NOOP_RULE, {
@@ -416,7 +444,7 @@ describe('RuleTester', () => {
 
     it('correctly handles string-based at-least', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
+        languageOptions: { parser },
       });
 
       ruleTester.run('my-rule', NOOP_RULE, {
@@ -473,8 +501,10 @@ describe('RuleTester', () => {
               "totally-real-dependency": "10",
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -484,8 +514,10 @@ describe('RuleTester', () => {
               "totally-real-dependency": "10.0",
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -495,8 +527,10 @@ describe('RuleTester', () => {
               "totally-real-dependency": "10.0.0",
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -511,8 +545,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -527,8 +563,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -543,8 +581,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -554,7 +594,7 @@ describe('RuleTester', () => {
 
     it('correctly handles object-based semver', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
+        languageOptions: { parser },
       });
 
       ruleTester.run('my-rule', NOOP_RULE, {
@@ -621,8 +661,10 @@ describe('RuleTester', () => {
               },
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -634,8 +676,10 @@ describe('RuleTester', () => {
               },
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -652,8 +696,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -670,8 +716,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -691,8 +739,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -702,7 +752,7 @@ describe('RuleTester', () => {
 
     it('tests without versions should always be run', () => {
       const ruleTester = new RuleTester({
-        parser: '@typescript-eslint/parser',
+        languageOptions: { parser },
       });
 
       ruleTester.run('my-rule', NOOP_RULE, {
@@ -747,16 +797,20 @@ describe('RuleTester', () => {
           {
             "code": "string based is always run",
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
           {
             "code": "no constraints is always run",
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -764,8 +818,10 @@ describe('RuleTester', () => {
             "code": "empty object is always run",
             "dependencyConstraints": {},
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -775,8 +831,10 @@ describe('RuleTester', () => {
               "totally-real-dependency": "10",
             },
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -788,8 +846,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -802,8 +862,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": false,
           },
@@ -818,8 +880,10 @@ describe('RuleTester', () => {
               },
             ],
             "filename": "file.ts",
-            "parserOptions": {
-              "disallowAutomaticSingleRunInference": true,
+            "languageOptions": {
+              "parserOptions": {
+                "disallowAutomaticSingleRunInference": true,
+              },
             },
             "skip": true,
           },
@@ -830,10 +894,10 @@ describe('RuleTester', () => {
     describe('constructor constraints', () => {
       it('skips all tests if a constructor constraint is not satisifed', () => {
         const ruleTester = new RuleTester({
-          parser: '@typescript-eslint/parser',
           dependencyConstraints: {
             'totally-real-dependency': '999',
           },
+          languageOptions: { parser },
         });
 
         ruleTester.run('my-rule', NOOP_RULE, {
@@ -862,10 +926,10 @@ describe('RuleTester', () => {
 
       it('does not skip all tests if a constructor constraint is satisifed', () => {
         const ruleTester = new RuleTester({
-          parser: '@typescript-eslint/parser',
           dependencyConstraints: {
             'totally-real-dependency': '10',
           },
+          languageOptions: { parser },
         });
 
         ruleTester.run('my-rule', NOOP_RULE, {
diff --git a/packages/rule-tester/tests/flat-config-schema.test.ts b/packages/rule-tester/tests/flat-config-schema.test.ts
new file mode 100644
index 000000000000..b52a2b8cc31d
--- /dev/null
+++ b/packages/rule-tester/tests/flat-config-schema.test.ts
@@ -0,0 +1,301 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+// Forked from: https://github.com/eslint/eslint/blob/f182114144ae0bb7187de34a1661f31fb70f1357/tests/lib/config/flat-config-schema.js
+
+import type { ObjectLike } from '../src/utils/flat-config-schema';
+import { flatConfigSchema } from '../src/utils/flat-config-schema';
+
+describe('merge', () => {
+  const { merge } = flatConfigSchema.settings;
+
+  it('merges two objects', () => {
+    const first = { foo: 42 };
+    const second = { bar: 'baz' };
+    const result = merge(first, second);
+
+    expect(result).toEqual({ ...first, ...second });
+  });
+
+  it('returns an emtpy object if both values are undefined', () => {
+    const result = merge(undefined, undefined);
+
+    expect(result).toEqual({});
+  });
+
+  it('returns an object equal to the first one if the second one is undefined', () => {
+    const first = { foo: 42, bar: 'baz' };
+    const result = merge(first, undefined);
+
+    expect(result).toEqual(first);
+    expect(result).not.toBe(first);
+  });
+
+  it('returns an object equal to the second one if the first one is undefined', () => {
+    const second = { foo: 42, bar: 'baz' };
+    const result = merge(undefined, second);
+
+    expect(result).toEqual(second);
+    expect(result).not.toBe(second);
+  });
+
+  it('does not preserve the type of merged objects', () => {
+    const first = new Set(['foo', 'bar']);
+    const second = new Set(['baz']);
+    const result = merge(
+      first as unknown as ObjectLike,
+      second as unknown as ObjectLike,
+    );
+
+    expect(result).toEqual({});
+  });
+
+  it('merges two objects in a property', () => {
+    const first = { foo: { bar: 'baz' } };
+    const second = { foo: { qux: 42 } };
+    const result = merge(first, second);
+
+    expect(result).toEqual({ foo: { bar: 'baz', qux: 42 } });
+  });
+
+  it('overwrites an object in a property with an array', () => {
+    const first = { someProperty: { 1: 'foo', bar: 'baz' } };
+    const second = { someProperty: ['qux'] };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result.someProperty).toEqual(second.someProperty);
+  });
+
+  it('overwrites an array in a property with another array', () => {
+    const first = { someProperty: ['foo', 'bar', undefined, 'baz'] };
+    const second = { someProperty: ['qux', undefined, 42] };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result.someProperty).toEqual(second.someProperty);
+  });
+
+  it('overwrites an array in a property with an object', () => {
+    const first = { foo: ['foobar'] };
+    const second = { foo: { 1: 'qux', bar: 'baz' } };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result.foo).toEqual(second.foo);
+  });
+
+  it('does not override a value in a property with undefined', () => {
+    const first: ObjectLike = { foo: { bar: 'baz' } };
+    const second: ObjectLike = { foo: undefined };
+    const result = merge(first, second);
+
+    expect(result).toEqual(first);
+    expect(result).not.toBe(first);
+  });
+
+  it('does not change the prototype of a merged object', () => {
+    const first = { foo: 42 };
+    const second = { bar: 'baz', ['__proto__']: { qux: true } };
+    const result = merge(first, second);
+
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+  });
+
+  it("does not merge the '__proto__' property", () => {
+    const first = { ['__proto__']: { foo: 42 } };
+    const second = { ['__proto__']: { bar: 'baz' } };
+    const result = merge(first, second);
+
+    expect(result).toEqual({});
+  });
+
+  it('overrides a value in a property with null', () => {
+    const first = { foo: { bar: 'baz' } };
+    const second = { foo: null };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result).not.toBe(second);
+  });
+
+  it('overrides a value in a property with a non-nullish primitive', () => {
+    const first = { foo: { bar: 'baz' } };
+    const second = { foo: 42 };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result).not.toBe(second);
+  });
+
+  it('overrides an object in a property with a string', () => {
+    const first = { foo: { bar: 'baz' } };
+    const second = { foo: 'qux' };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result).not.toEqual(first);
+  });
+
+  it('overrides a value in a property with a function', () => {
+    const first = { someProperty: { foo: 42 } };
+    const second = { someProperty(): void {} };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result.someProperty).not.toHaveProperty('foo');
+  });
+
+  it('overrides a function in a property with an object', () => {
+    const first = { someProperty: Object.assign(() => {}, { foo: 'bar' }) };
+    const second = { someProperty: { baz: 'qux' } };
+    const result = merge(first, second);
+
+    expect(result).toEqual(second);
+    expect(result.someProperty).not.toHaveProperty('foo');
+  });
+
+  it('sets properties to undefined', () => {
+    const first = { foo: undefined, bar: undefined };
+    const second = { foo: undefined, baz: undefined };
+    const result = merge(first, second);
+
+    expect(result).toEqual({ foo: undefined, bar: undefined, baz: undefined });
+  });
+
+  it('considers only own enumerable properties', () => {
+    const first = {
+      __proto__: { inherited1: 'A' }, // non-own properties are not considered
+      included1: 'B',
+      notMerged1: { first: true },
+    };
+    const second = {
+      __proto__: { inherited2: 'C' }, // non-own properties are not considered
+      included2: 'D',
+      notMerged2: { second: true },
+    };
+
+    // non-enumerable properties are not considered
+    Object.defineProperty(first, 'notMerged2', {
+      enumerable: false,
+      value: { first: true },
+    });
+    Object.defineProperty(second, 'notMerged1', {
+      enumerable: false,
+      value: { second: true },
+    });
+
+    const result = merge(first, second);
+
+    expect(result).toEqual({
+      included1: 'B',
+      included2: 'D',
+      notMerged1: { first: true },
+      notMerged2: { second: true },
+    });
+  });
+
+  it('merges objects with self-references', () => {
+    const first: ObjectLike = { foo: 42 };
+
+    first.first = first;
+    const second: ObjectLike = { bar: 'baz' };
+
+    second.second = second;
+    const result = merge(first, second);
+
+    expect(result.first).toEqual(first);
+    expect(result.second).toEqual(second);
+
+    const expected: ObjectLike = { foo: 42, bar: 'baz' };
+
+    expected.first = first;
+    expected.second = second;
+    expect(result).toEqual(expected);
+  });
+
+  it('merges objects with overlapping self-references', () => {
+    const first: ObjectLike = { foo: 42 };
+
+    first.reference = first;
+    const second: ObjectLike = { bar: 'baz' };
+
+    second.reference = second;
+
+    const result = merge(first, second);
+
+    expect(result.reference).toEqual(result);
+
+    const expected: ObjectLike = { foo: 42, bar: 'baz' };
+
+    expected.reference = expected;
+    expect(result).toEqual(expected);
+  });
+
+  it('merges objects with cross-references', () => {
+    const first: ObjectLike = { foo: 42 };
+    const second: ObjectLike = { bar: 'baz' };
+
+    first.second = second;
+    second.first = first;
+
+    const result = merge(first, second);
+
+    expect(result.first).toEqual(first);
+    expect(result.second).toEqual(second);
+
+    const expected: ObjectLike = { foo: 42, bar: 'baz' };
+
+    expected.first = first;
+    expected.second = second;
+    expect(result).toEqual(expected);
+  });
+
+  it('merges objects with overlapping cross-references', () => {
+    const first: ObjectLike = { foo: 42 };
+    const second: ObjectLike = { bar: 'baz' };
+
+    first.reference = second;
+    second.reference = first;
+
+    const result = merge(first, second);
+
+    expect(result).toEqual((result.reference as ObjectLike).reference);
+
+    const expected = {
+      foo: 42,
+      bar: 'baz',
+      reference: { foo: 42, bar: 'baz' },
+    };
+
+    (expected.reference as ObjectLike).reference = expected;
+    expect(result).toEqual(expected);
+  });
+
+  it('produces the same results for the same combinations of property values', () => {
+    const firstCommon = { foo: 42 };
+    const secondCommon = { bar: 'baz' };
+    const first = {
+      a: firstCommon,
+      b: firstCommon,
+      c: { foo: 'different' },
+      d: firstCommon,
+    };
+    const second = {
+      a: secondCommon,
+      b: { bar: 'something else' },
+      c: secondCommon,
+      d: secondCommon,
+    };
+    const result = merge(first, second);
+
+    expect(result.a).toEqual(result.d);
+
+    const expected = {
+      a: { foo: 42, bar: 'baz' },
+      b: { foo: 42, bar: 'something else' },
+      c: { foo: 'different', bar: 'baz' },
+      d: { foo: 42, bar: 'baz' },
+    };
+
+    expect(result).toEqual(expected);
+  });
+});
diff --git a/packages/utils/src/eslint-utils/deepMerge.ts b/packages/utils/src/eslint-utils/deepMerge.ts
index a4ace614df5d..b764e2294653 100644
--- a/packages/utils/src/eslint-utils/deepMerge.ts
+++ b/packages/utils/src/eslint-utils/deepMerge.ts
@@ -1,4 +1,4 @@
-type ObjectLike<T = unknown> = Record<string, T>;
+export type ObjectLike<T = unknown> = Record<string, T>;
 
 /**
  * Check if the variable contains an object strictly rejecting arrays
diff --git a/packages/utils/src/ts-eslint/Linter.ts b/packages/utils/src/ts-eslint/Linter.ts
index b52c6f6abb9a..e759668ec393 100644
--- a/packages/utils/src/ts-eslint/Linter.ts
+++ b/packages/utils/src/ts-eslint/Linter.ts
@@ -142,7 +142,10 @@ namespace Linter {
 
   /** @deprecated use Linter.ConfigType instead */
   export type Config = ClassicConfig.Config;
-  export type ConfigType = ClassicConfig.Config | FlatConfig.ConfigArray;
+  export type ConfigType =
+    | ClassicConfig.Config
+    | FlatConfig.Config
+    | FlatConfig.ConfigArray;
   /** @deprecated use ClassicConfig.ConfigOverride instead */
   export type ConfigOverride = ClassicConfig.ConfigOverride;
 
diff --git a/packages/utils/src/ts-eslint/RuleTester.ts b/packages/utils/src/ts-eslint/RuleTester.ts
index 43090eead854..48ccf3d3cb61 100644
--- a/packages/utils/src/ts-eslint/RuleTester.ts
+++ b/packages/utils/src/ts-eslint/RuleTester.ts
@@ -1,3 +1,4 @@
+/* eslint-disable deprecation/deprecation */
 import { RuleTester as ESLintRuleTester } from 'eslint';
 
 import type { AST_NODE_TYPES, AST_TOKEN_TYPES } from '../ts-estree';
@@ -11,6 +12,9 @@ import type {
   SharedConfigurationSettings,
 } from './Rule';
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface ValidTestCase<Options extends readonly unknown[]> {
   /**
    * Name for the test case.
@@ -54,6 +58,9 @@ interface ValidTestCase<Options extends readonly unknown[]> {
   readonly only?: boolean;
 }
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface SuggestionOutput<MessageIds extends string> {
   /**
    * Reported message ID.
@@ -73,6 +80,9 @@ interface SuggestionOutput<MessageIds extends string> {
   // readonly desc?: string;
 }
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface InvalidTestCase<
   MessageIds extends string,
   Options extends readonly unknown[],
@@ -87,6 +97,9 @@ interface InvalidTestCase<
   readonly output?: string | string[] | null;
 }
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface TestCaseError<MessageIds extends string> {
   /**
    * The 1-based column number of the reported start location.
@@ -127,12 +140,16 @@ interface TestCaseError<MessageIds extends string> {
 
 /**
  * @param text a string describing the rule
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
  */
 type RuleTesterTestFrameworkFunction = (
   text: string,
   callback: () => void,
 ) => void;
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface RunTests<
   MessageIds extends string,
   Options extends readonly unknown[],
@@ -141,12 +158,19 @@ interface RunTests<
   readonly valid: readonly (ValidTestCase<Options> | string)[];
   readonly invalid: readonly InvalidTestCase<MessageIds, Options>[];
 }
+
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 interface RuleTesterConfig extends ClassicConfig.Config {
   // should be require.resolve(parserPackageName)
   readonly parser: string;
   readonly parserOptions?: Readonly<ParserOptions>;
 }
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare class RuleTesterBase {
   /**
@@ -199,6 +223,9 @@ declare class RuleTesterBase {
   ): void;
 }
 
+/**
+ * @deprecated Use `@typescript-eslint/rule-tester` instead.
+ */
 class RuleTester extends (ESLintRuleTester as typeof RuleTesterBase) {}
 
 export {
diff --git a/packages/utils/src/ts-eslint/SourceCode.ts b/packages/utils/src/ts-eslint/SourceCode.ts
index feab25ba7ac1..b16879f20a3e 100644
--- a/packages/utils/src/ts-eslint/SourceCode.ts
+++ b/packages/utils/src/ts-eslint/SourceCode.ts
@@ -226,6 +226,9 @@ declare class SourceCodeBase extends TokenStore {
    * The parsed AST for the source code.
    */
   ast: SourceCode.Program;
+  applyInlineConfig(): void;
+  applyLanguageOptions(): void;
+  finalize(): void;
   /**
    * Retrieves an array containing all comments in the source code.
    * @returns An array of comment nodes.