diff --git a/.eslint-doc-generatorrc.js b/.eslint-doc-generatorrc.js
index 1e6d1717f3..81c443bebb 100644
--- a/.eslint-doc-generatorrc.js
+++ b/.eslint-doc-generatorrc.js
@@ -4,7 +4,7 @@ const config = {
     ['jsx-runtime', '🏃'],
     ['recommended', '☑️'],
   ],
-  ignoreConfig: ['all'],
+  ignoreConfig: ['all', 'flat'],
   urlConfigs: 'https://github.com/jsx-eslint/eslint-plugin-react/#shareable-configs',
 };
 
diff --git a/.eslintrc b/.eslintrc
index 4991f200f2..894df7caa9 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -1,82 +1,85 @@
 {
-    "root": true,
-    "extends": ["airbnb-base", "plugin:eslint-plugin/recommended"],
-    "plugins": ["eslint-plugin"],
-    "env": {
-       "es6": true,
-       "node": true
-    },
-    "parserOptions": {
-      "ecmaVersion": 6,
-      "ecmaFeatures": {
-        "jsx": true
-      },
-      "sourceType": "script",
-    },
-    "ignorePatterns": [
-      "coverage/",
-      ".nyc_output/",
-    ],
-    "rules": {
-        "comma-dangle": [2, "always-multiline"],
-        "object-shorthand": [2, "always", {
-          "ignoreConstructors": false,
-          "avoidQuotes": false, // this is the override vs airbnb
-        }],
-        "max-len": [2, 120, {
-          "ignoreStrings": true,
-          "ignoreTemplateLiterals": true,
-          "ignoreComments": true,
-        }],
-        "consistent-return": 0,
+	"root": true,
+	"extends": ["airbnb-base", "plugin:eslint-plugin/recommended"],
+	"plugins": ["eslint-plugin"],
+	"env": {
+		"es6": true,
+		"node": true
+	},
+	"parserOptions": {
+		"ecmaVersion": 6,
+		"ecmaFeatures": {
+			"jsx": true
+		},
+		"sourceType": "script",
+	},
+	"ignorePatterns": [
+		"coverage/",
+		".nyc_output/",
+		"test-published-types/",
+		"tests/fixtures/flat-config/",
+		"**/*/*.d.ts",
+	],
+	"rules": {
+		"comma-dangle": [2, "always-multiline"],
+		"object-shorthand": [2, "always", {
+			"ignoreConstructors": false,
+			"avoidQuotes": false, // this is the override vs airbnb
+    }],
+    "max-len": [2, 140, {
+      "ignoreStrings": true,
+      "ignoreTemplateLiterals": true,
+      "ignoreComments": true,
+    }],
+    "consistent-return": 0,
 
-        "prefer-destructuring": [2, { "array": false, "object": false }, { "enforceForRenamedProperties": false }],
-        "prefer-object-spread": 0, // until node 8 is required
-        "prefer-rest-params": 0, // until node 6 is required
-        "prefer-spread": 0, // until node 6 is required
-        "function-call-argument-newline": 1, // TODO: enable
-        "function-paren-newline": 0,
-        "no-plusplus": [2, {"allowForLoopAfterthoughts": true}],
-        "no-param-reassign": 1,
-        "no-restricted-syntax": [2, {
-            "selector": "ObjectPattern",
-            "message": "Object destructuring is not compatible with Node v4"
-        }],
-        "strict": [2, "safe"],
-        "valid-jsdoc": [2, {
-          "requireReturn": false,
-          "requireParamDescription": false,
-          "requireReturnDescription": false,
-        }],
+    "prefer-destructuring": [2, { "array": false, "object": false }, { "enforceForRenamedProperties": false }],
+    "prefer-object-spread": 0, // until node 8 is required
+    "prefer-rest-params": 0, // until node 6 is required
+    "prefer-spread": 0, // until node 6 is required
+    "function-call-argument-newline": 1, // TODO: enable
+    "function-paren-newline": 0,
+    "no-plusplus": [2, {"allowForLoopAfterthoughts": true}],
+    "no-param-reassign": 1,
+    "no-restricted-syntax": [2, {
+      "selector": "ObjectPattern",
+      "message": "Object destructuring is not compatible with Node v4"
+    }],
+    "strict": [2, "safe"],
+    "valid-jsdoc": [2, {
+      "requireReturn": false,
+      "requireParamDescription": false,
+      "requireReturnDescription": false,
+    }],
 
-        "eslint-plugin/consistent-output": 0,
-        "eslint-plugin/require-meta-docs-description": [2, { "pattern": "^(Enforce|Require|Disallow)" }],
-        "eslint-plugin/require-meta-schema": 0,
-        "eslint-plugin/require-meta-type": 0
+    "eslint-plugin/consistent-output": 0,
+    "eslint-plugin/require-meta-docs-description": [2, { "pattern": "^(Enforce|Require|Disallow)" }],
+    "eslint-plugin/require-meta-schema": 0,
+    "eslint-plugin/require-meta-type": 0
+  },
+  "overrides": [
+    {
+      "files": "tests/**",
+      "rules": {
+        "no-template-curly-in-string": 1,
+      },
     },
-    "overrides": [
-      {
-        "files": "tests/**",
-        "rules": {
-          "no-template-curly-in-string": 1,
-        },
+    {
+      "files": "markdown.config.js",
+      "rules": {
+        "no-console": 0,
       },
-      {
-        "files": "markdown.config.js",
-        "rules": {
-          "no-console": 0,
-        },
+    },
+    {
+      "files": ".github/workflows/*.js",
+      "parserOptions": {
+        "ecmaVersion": 2019,
       },
-      {
-        "files": ".github/workflows/*.js",
-        "parserOptions": {
-          "ecmaVersion": 2019,
-        },
-        "rules": {
-          "camelcase": 0,
-          "no-console": 0,
-          "no-restricted-syntax": 0,
-        },
+      "rules": {
+        "camelcase": 0,
+        "no-console": 0,
+        "no-restricted-syntax": 0,
       },
-    ],
+    },
+  ],
 }
diff --git a/.github/workflows/node-18+.yml b/.github/workflows/node-18+.yml
index 921db8111b..5a48b15a88 100644
--- a/.github/workflows/node-18+.yml
+++ b/.github/workflows/node-18+.yml
@@ -26,6 +26,7 @@ jobs:
       matrix:
         node-version: ${{ fromJson(needs.matrix.outputs.latest) }}
         eslint:
+          - 9
           - 8
           - 7
           - 6
@@ -37,20 +38,78 @@ jobs:
           - 10
           - 9
           - 8
+        typescript-eslint:
+          - 5
+          - 6
+          - 7
+          - 8
+        exclude:
+          - eslint: 3
+            babel-eslint: 10
+          - eslint: 3
+            typescript-eslint: 5
+          - eslint: 4
+            typescript-eslint: 5
+          - eslint: 4.14
+            typescript-eslint: 5
+          - eslint: 5
+            typescript-eslint: 5
+          - eslint: 3
+            typescript-eslint: 6
+          - eslint: 4
+            typescript-eslint: 6
+          - eslint: 4.14
+            typescript-eslint: 6
+          - eslint: 5
+            typescript-eslint: 6
+          - eslint: 6
+            typescript-eslint: 6
+          - eslint: 9
+            typescript-eslint: 6
+          - eslint: 3
+            typescript-eslint: 7
+          - eslint: 4
+            typescript-eslint: 7
+          - eslint: 4.14
+            typescript-eslint: 7
+          - eslint: 5
+            typescript-eslint: 7
+          - eslint: 6
+            typescript-eslint: 7
+          - eslint: 7
+            typescript-eslint: 7
+          - eslint: 9
+            typescript-eslint: 7
+          - eslint: 3
+            typescript-eslint: 8
+          - eslint: 4
+            typescript-eslint: 8
+          - eslint: 4.14
+            typescript-eslint: 8
+          - eslint: 5
+            typescript-eslint: 8
+          - eslint: 6
+            typescript-eslint: 8
+          - eslint: 7
+            typescript-eslint: 8
+          - eslint: 9
+            typescript-eslint: 5
+          - node-version: 19
+            typescript-eslint: 7
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ljharb/actions/node/install@main
         name: 'nvm install ${{ matrix.node-version }} && npm install'
         with:
           node-version: ${{ matrix.node-version }}
           after_install: |
-            npm install --no-save "eslint@${{ matrix.eslint }}" "@typescript-eslint/parser@5" "babel-eslint@${{ matrix.babel-eslint }}"
+            npm install --no-save "eslint@${{ matrix.eslint }}" "@typescript-eslint/parser@${{ matrix.typescript-eslint == 8 && 8.17 || matrix.typescript-eslint }}" "babel-eslint@${{ matrix.babel-eslint }}"
         env:
-          NPM_CONFIG_LEGACY_PEER_DEPS: true
+          NPM_CONFIG_LEGACY_PEER_DEPS: "${{ matrix.typescript-eslint >= 6 && 'false' || 'true' }}"
       - run: npx ls-engines
       - run: npm run unit-test
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v3.1.5
 
   node:
     name: 'node 18+'
diff --git a/.github/workflows/node-minors.yml b/.github/workflows/node-minors.yml
index 2b5230268a..9e227f2b89 100644
--- a/.github/workflows/node-minors.yml
+++ b/.github/workflows/node-minors.yml
@@ -94,20 +94,20 @@ jobs:
             eslint: 5
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ljharb/actions/node/install@main
         name: 'nvm install ${{ matrix.node-version }} && npm install'
         with:
           node-version: ${{ matrix.node-version }}
           after_install: |
-            npm install --no-save "eslint@${{ matrix.eslint }}" "@typescript-eslint/parser@${{ matrix.node-version >= 14 && '5' || (matrix.node-version >= 12 && '4' || (matrix.node-version >= 10 && '4.0' || (matrix.node-version >= 8 && '3' || '2'))) }}" "babel-eslint@${{ matrix.babel-eslint }}"
+            npm install --no-save "eslint@${{ matrix.eslint }}" "@typescript-eslint/parser@${{ matrix.node-version >= 18 && matrix.eslint >= 8 && '8.17' || (matrix.node-version >= 16 && matrix.eslint >= 7 && '6' || (matrix.node-version >= 14 && '5' || (matrix.node-version >= 12 && '4' || (matrix.node-version >= 10 && '4.0' || (matrix.node-version >= 8 && '3' || '2'))))) }}" "babel-eslint@${{ matrix.babel-eslint }}"
           skip-ls-check: ${{ matrix.node-version < 10 && true || false }}
         env:
-          NPM_CONFIG_LEGACY_PEER_DEPS: true
+          NPM_CONFIG_LEGACY_PEER_DEPS: "${{ matrix.node-version >= 16 && matrix.eslint >= 7 && 'false' || 'true' }}"
       - run: npx ls-engines
         if: ${{ matrix.node-version >= 12 }}
       - run: npm run unit-test
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v3.1.5
 
   node:
     name: 'node 4 - 17'
diff --git a/.github/workflows/node-pretest.yml b/.github/workflows/node-pretest.yml
index 5177ab52fa..ed00d06b47 100644
--- a/.github/workflows/node-pretest.yml
+++ b/.github/workflows/node-pretest.yml
@@ -7,20 +7,18 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ljharb/actions/node/install@main
         name: 'nvm install lts/* && npm install'
         with:
           node-version: 'lts/*'
-        env:
-          NPM_CONFIG_LEGACY_PEER_DEPS: true
       - run: npm run pretest
 
   posttest:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ljharb/actions/node/install@main
         name: 'nvm install lts/* && npm install'
         with:
diff --git a/.github/workflows/npm-publish.yml b/.github/workflows/npm-publish.yml
index 2b89b601b7..2e654951b6 100644
--- a/.github/workflows/npm-publish.yml
+++ b/.github/workflows/npm-publish.yml
@@ -15,7 +15,7 @@ jobs:
     outputs:
       is-new-version: ${{ steps.cpv.outputs.is-new-version }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.inputs.tag }}
 
@@ -63,7 +63,10 @@ jobs:
             const pending = checkSuites.filter(({ status }) => status !== 'completed')
 
             if (pending.length > 0) {
-              core.setFailed(`Some workflows for ${context.payload.inputs.tag} are still in-progress: ${JSON.stringify(pending)}`);
+              core.setFailed(`Some workflows for ${context.payload.inputs.tag} are still in-progress`);
+              pending.forEach(({ pull_requests, ...x }) => {
+                core.debug(JSON.stringify(x));
+              });
             }
 
             const result = await Promise.all(
@@ -94,7 +97,7 @@ jobs:
       contents: read
       id-token: write
     steps:
-      - uses: step-security/harden-runner@v1
+      - uses: step-security/harden-runner@v2
         with:
           egress-policy: block
           allowed-endpoints: >
@@ -102,8 +105,9 @@ jobs:
             nodejs.org:443
             prod.api.stepsecurity.io:443
             registry.npmjs.org:443
+            raw.githubusercontent.com:443
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.inputs.tag }}
 
diff --git a/.github/workflows/rebase.yml b/.github/workflows/rebase.yml
index a4d47c74ca..b9e1712fc4 100644
--- a/.github/workflows/rebase.yml
+++ b/.github/workflows/rebase.yml
@@ -4,12 +4,6 @@ on: [pull_request_target]
 
 jobs:
   _:
-    name: "Automatic Rebase"
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: ljharb/rebase@master
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    uses: ljharb/actions/.github/workflows/rebase.yml@main
+    secrets:
+      token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a110a1f476..d6f97d2e84 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -15,18 +15,27 @@ jobs:
       contents: write
 
     steps:
-      - uses: step-security/harden-runner@v1
+      - uses: step-security/harden-runner@v2
         with:
           allowed-endpoints:
             api.github.com:443
             github.com:443
+            raw.githubusercontent.com:443
+            nodejs.org:443
+            registry.npmjs.org:443
 
       - name: Get version from tag
         id: tag_name
         run: echo "current_version=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_OUTPUT"
         shell: bash
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+
+      - uses: ljharb/actions/node/install@main
+        with:
+          node-version: node
+          skip-install: true
+          skip-ls-check: true
 
       - uses: mindsers/changelog-reader-action@v2
         id: changelog_reader
@@ -37,9 +46,9 @@ jobs:
         id: changelog
         run: |
           # Parse the changelog for common links
-          _links="$(grep -P '^\[.*]:.+' ${GITHUB_WORKSPACE}/CHANGELOG.md | sort -u)"
+          _links="$(egrep '^\[.*]:.+' ${GITHUB_WORKSPACE:-.}/CHANGELOG.md | sort -u)"
           _links="${_links//'%'/'%25'}"
-          _links="${_links//$'\n'/'%0A'}"
+          # _links="${_links//$'\n'/'%0A'}"
           _links="${_links//$'\r'/'%0D'}"
           # Set output 'links' to $_links
           DELIMITER=$(uuidgen)
@@ -47,8 +56,23 @@ jobs:
           echo "$_links" >> "${GITHUB_OUTPUT}"
           echo "${DELIMITER}" >> "${GITHUB_OUTPUT}"
 
-      - uses: softprops/action-gh-release@v1
+      - name: 'concat data > tmp.md'
+        run: |
+          cat << 'EOF' > tmp.md
+          ${{ steps.changelog_reader.outputs.changes }}
+          ${{ steps.changelog.outputs.links }}
+          EOF
+
+      - run: cat tmp.md
+
+      - id: prune-footnotes
+        run: |
+          DELIMITER=$(uuidgen)
+          echo "body<<${DELIMITER}" >> "${GITHUB_OUTPUT}"
+          npx gfm-footnotes -i tmp.md >> "${GITHUB_OUTPUT}"
+          echo "${DELIMITER}" >> "${GITHUB_OUTPUT}"
+
+      - uses: softprops/action-gh-release@v2
         with:
           body: |
-            ${{ steps.changelog_reader.outputs.changes }}
-            ${{ steps.changelog.outputs.links }}
+            ${{ steps.prune-footnotes.outputs.body }}
diff --git a/.github/workflows/smoke-test.yml b/.github/workflows/smoke-test.yml
index 5c5d99b338..a2dacffb91 100644
--- a/.github/workflows/smoke-test.yml
+++ b/.github/workflows/smoke-test.yml
@@ -10,7 +10,7 @@ jobs:
     if: ${{ github.repository == 'jsx-eslint/eslint-plugin-react' || github.event_name == 'workflow_dispatch' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ljharb/actions/node/install@main
         name: 'nvm install lts/* && npm install'
         with:
diff --git a/.github/workflows/type-check.yml b/.github/workflows/type-check.yml
new file mode 100644
index 0000000000..0aaca2cb00
--- /dev/null
+++ b/.github/workflows/type-check.yml
@@ -0,0 +1,77 @@
+name: "Types: check published types"
+
+on: [pull_request, push]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: TS ${{ matrix.ts_version }}, "${{ matrix.ts_lib }}"
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ts_version:
+          # The official ESLint types are not compatible with TS 3.9
+          # - 3.9
+          - '4.0'
+          - 4.1
+          - 4.2
+          - 4.3
+          - 4.4
+          - 4.5
+          - '5.0'
+          - 5.5
+          - 5.6
+        ts_lib:
+          - es2015
+          - es2015,dom
+          - es2020
+          - esnext
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          show-progress: false
+
+      - uses: ljharb/actions/node/install@main
+        name: 'nvm install lts/* && npm install'
+        with:
+          node-version: 'lts/*'
+          skip-ls-check: true
+
+      - name: build types
+        run: npm run build-types
+
+      # Pack the lib into a tarball so that when we install the lib later in the
+      # test-published-types directory, it's only install `dependencies` of the
+      # lib.
+      - name: pack the lib
+        run: npm pack --pack-destination /tmp/
+
+      - name: find the packed lib
+        run: echo "ESLINT_PLUGIN_REACT_PATH=$(ls /tmp/eslint-plugin-react*.tgz | tail -n 1)" >> $GITHUB_ENV
+
+      - name: show the path to the packed lib
+        run: echo "$ESLINT_PLUGIN_REACT_PATH"
+
+      - name: npm install working directory
+        run: npm install
+        working-directory: test-published-types
+
+      - name: install eslint-plugin-react and typescript version ${{ matrix.ts_version }}
+        run: npm install --no-save "$ESLINT_PLUGIN_REACT_PATH" typescript@${{ matrix.ts_version }}
+        working-directory: test-published-types
+
+      - name: show installed typescript version
+        run: npm list typescript --depth=0
+        working-directory: test-published-types
+
+      - name: show installed eslint-plugin-react version
+        run: npm list eslint-plugin-react --depth=0
+        working-directory: test-published-types
+
+      - name: check types with lib "${{ matrix.ts_lib }}"
+        run: npx tsc --lib ${{ matrix.ts_lib }}
+        working-directory: test-published-types
diff --git a/.gitignore b/.gitignore
index 453b7fd5f6..43605edffc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,9 @@ package-lock.json
 yarn.lock
 
 .npmignore
+
+/lib/**/*.d.ts
+/lib/**/*.d.ts.map
+!/lib/types.d.ts
+/index.d.ts
+/index.d.ts.map
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b95e4560f..9696eca775 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,265 @@
 # Change Log
+
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 This change log adheres to standards from [Keep a CHANGELOG](https://keepachangelog.com).
 
 ## Unreleased
 
+### Added
+* [`jsx-props-no-multi-spaces`]: improve autofix for multi-line ([#3930][] @justisb)
+
+### Fixed
+* [`no-unknown-property`]: allow `onLoad` on `body` ([#3923][] @DerekStapleton)
+
+[#3930]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3930
+[#3923]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3923
+
+## [7.37.5] - 2025.04.03
+
+### Fixed
+* [`no-unknown-property`]: allow shadow root attrs on `<template>` ([#3912][] @ljharb)
+* [`prop-types`]: support `ComponentPropsWithRef` from a namespace import ([#3651][] @corydeppen)
+* [`jsx-no-constructed-context-values`]: detect constructed context values in React 19 `<Context>` usage ([#3910][] @TildaDares)
+* [`no-unknown-property`]: allow `transform-origin` on `rect` ([#3914][] @ljharb)
+
+### Changed
+* [Docs] [`button-has-type`]: clean up phrasing ([#3909][] @hamirmahal)
+
+[7.37.5]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.37.4...v7.37.5
+[#3914]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3914
+[#3912]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3912
+[#3910]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3910
+[#3909]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3909
+[#3651]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3651
+
+## [7.37.4] - 2025.01.12
+
+### Fixed
+* [`no-unknown-property`]: support `onBeforeToggle`, `popoverTarget`, `popoverTargetAction` attributes ([#3865][] @acusti)
+* [types] fix types of flat configs ([#3874][] @ljharb)
+
+[7.37.4]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.37.3...v7.37.4
+[#3874]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3874
+[#3865]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3865
+
+## [7.37.3] - 2024.12.23
+
+### Fixed
+* [`no-danger`]: avoid a crash on a nested component name ([#3833][] @ljharb)
+* [Fix] types: correct generated type declaration ([#3840][] @ocavue)
+* [`no-unknown-property`]: support `precedence` prop in react 19 ([#3829][] @acusti)
+* [`prop-types`]: props missing in validation when using generic types from a namespace import ([#3859][] @rbondoc96)
+
+### Changed
+* [Tests] [`jsx-no-script-url`]: Improve tests ([#3849][] @radu2147)
+* [Docs] fix broken links: [`default-props-match-prop-types`], [`jsx-boolean-value`], [`jsx-curly-brace-presence`], [`jsx-no-bind`], [`no-array-index-key`], [`no-is-mounted`], [`no-render-return-value`], [`require-default-props`] ([#3841][] @bastiendmt)
+
+[7.37.3]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.37.2...v7.37.3
+[#3859]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3859
+[#3849]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3849
+[#3841]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3841
+[#3840]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3840
+[#3833]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3833
+[#3829]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3829
+
+## [7.37.2] - 2024.10.22
+
+### Fixed
+* [`destructuring-assignment`]: fix false negative when using `typeof props.a` ([#3835][] @golopot)
+
+### Changed
+* [Refactor] [`destructuring-assignment`]: use `getParentStatelessComponent` ([#3835][] @golopot)
+
+[7.37.2]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.37.1...v7.37.2
+[#3835]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3835
+
+## [7.37.1] - 2024.10.01
+
+### Fixed
+* [meta] do not npmignore `d.ts` files ([#3836][] @ljharb)
+
+### Changed
+* [readme] Fix shared settings link ([#3834][] @MgenGlder)
+
+[7.37.1]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.37.0...v7.37.1
+[#3836]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3836
+[#3834]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3834
+
+## [7.37.0] - 2024.09.26
+
+### Added
+* add type generation ([#3830][] @voxpelli)
+* [`no-unescaped-entities`]: add suggestions ([#3831][] @StyleShit)
+* [`forbid-component-props`]: add `allowedForPatterns`/`disallowedForPatterns` options ([#3805][] @Efimenko)
+* [`no-unstable-nested-components`]: add `propNamePattern` to support custom render prop naming conventions ([#3826][] @danreeves)
+
+### Changed
+* [readme] flat config example for react 17+ ([#3824][] @GabenGar)
+
+[7.37.0]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.36.1...v7.37.0
+[#3831]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3831
+[#3830]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3830
+[#3826]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3826
+[#3824]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3824
+[#3805]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3805
+
+## [7.36.1] - 2024.09.12
+
+### Fixed
+* [`no-is-mounted`]: fix logic in method name check ([#3821][] @Mathias-S)
+* [`jsx-no-literals`]: Avoid crashing on valueless boolean props ([#3823][] @reosarevok)
+
+[7.36.1]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.36.0...v7.36.1
+[#3823]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3823
+[#3821]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3821
+
+## [7.36.0] - 2024.09.12
+
+### Added
+* [`no-string-refs`]: allow this.refs in > 18.3.0 ([#3807][] @henryqdineen)
+* [`jsx-no-literals`] Add `elementOverrides` option and the ability to ignore this rule on specific elements ([#3812][] @Pearce-Ropion)
+* [`forward-ref-uses-ref`]: add rule for checking ref parameter is added ([#3667][] @NotWoods)
+
+### Fixed
+* [`function-component-definition`], [`boolean-prop-naming`], [`jsx-first-prop-new-line`], [`jsx-props-no-multi-spaces`], `propTypes`: use type args ([#3629][] @HenryBrown0)
+* JSX pragma: fail gracefully ([#3632][] @ljharb)
+* [`jsx-props-no-spreading`]: add `explicitSpread` option to schema ([#3799][] @ljharb)
+
+### Changed
+* [Tests] add @typescript-eslint/parser v6 ([#3629][] @HenryBrown0)
+* [Tests] add @typescript-eslint/parser v7 and v8 ([#3629][] @hampustagerud)
+* [Docs] [`no-danger`]: update broken link ([#3817][] @lucasrmendonca)
+* [types] add jsdoc type annotations ([#3731][] @y-hsgw)
+* [Tests] `button-has-type`: add test case with spread ([#3731][] @y-hsgw)
+
+[7.36.0]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.35.2...v7.36.0
+[#3799]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3799
+[#3632]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3632
+[#3812]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3812
+[#3731]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3731
+[#3694]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3667
+[#3629]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3629
+[#3817]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3817
+[#3807]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3807
+
+## [7.35.2] - 2024.09.03
+
+### Fixed
+* [`jsx-curly-brace-presence`]: avoid autofixing attributes with double quotes to a double quoted attribute ([#3814][] @ljharb)
+
+[7.35.2]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.35.1...v7.35.2
+[#3814]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3814
+
+## [7.35.1] - 2024.09.02
+
+### Fixed
+* [`jsx-curly-brace-presence`]: do not trigger on strings containing a quote character ([#3798][] @akulsr0)
+
+[7.35.1]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.35.0...v7.35.1
+[#3798]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3798
+
+## [7.35.0] - 2024.07.19
+
+### Added
+* support eslint v9 ([#3759][] @mdjermanovic)
+* export flat configs from plugin root and fix flat config crash ([#3694][] @bradzacher @mdjermanovic)
+* add [`jsx-props-no-spread-multi`] ([#3724][] @SimonSchick)
+* [`forbid-component-props`]: add `propNamePattern` to allow / disallow prop name patterns ([#3774][] @akulsr0)
+* [`jsx-handler-names`]: support ignoring component names ([#3772][] @akulsr0)
+* version settings: Allow react defaultVersion to be configurable ([#3771][] @onlywei)
+* [`jsx-closing-tag-location`]: add `line-aligned` option ([#3777] @kimtaejin3)
+* [`no-danger`]: add `customComponentNames` option ([#3748][] @akulsr0)
+
+### Fixed
+* [`no-invalid-html-attribute`]: substitute placeholders in suggestion messages ([#3759][] @mdjermanovic)
+* [`sort-prop-types`]: single line type ending without semicolon ([#3784][] @akulsr0)
+* [`require-default-props`]: report when required props have default value ([#3785][] @akulsr0)
+
+### Changed
+* [Refactor] `variableUtil`: Avoid creating a single flat variable scope for each lookup ([#3782][] @DanielRosenwasser)
+
+[7.35.0]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.34.4...v7.35.0
+[#3785]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3785
+[#3784]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3784
+[#3782]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3782
+[#3777]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3777
+[#3774]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3774
+[#3772]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3772
+[#3771]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3771
+[#3759]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3759
+[#3748]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3748
+[#3724]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3724
+[#3694]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3694
+
+## [7.34.4] - 2024.07.13
+
+### Fixed
+
+* [`prop-types`]: fix `className` missing in prop validation false negative ([#3749][] @akulsr0)
+* [`sort-prop-types`]: Check for undefined before accessing `node.typeAnnotation.typeAnnotation` ([#3779][] @tylerlaprade)
+
+[7.34.4]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.34.3...v7.34.4
+[#3779]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3779
+[#3749]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3749
+
+## [7.34.3] - 2024.06.18
+
+### Fixed
+* [`prop-types`]: null-check rootNode before calling getScope ([#3762][] @crnhrv)
+* [`boolean-prop-naming`]: avoid a crash with a spread prop ([#3733][] @ljharb)
+* [`jsx-boolean-value`]: `assumeUndefinedIsFalse` with `never` must not allow explicit `true` value ([#3757][] @6uliver)
+* [`no-object-type-as-default-prop`]: enable rule for components with many parameters ([#3768][] @JulienR1)
+* [`jsx-key`]: incorrect behavior for checkKeyMustBeforeSpread with map callbacks ([#3769][] @akulsr0)
+
+[7.34.3]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.34.2...v7.34.3
+[#3769]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3769
+[#3768]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3768
+[#3762]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3762
+[#3757]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3757
+[#3733]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3733
+
+## [7.34.2] - 2024.05.24
+
+### Fixed
+* [`boolean-prop-naming`]: avoid a crash with a non-TSTypeReference type ([#3718][] @developer-bandi)
+* [`jsx-no-leaked-render`]: invalid report if left eside is boolean ([#3746][] @akulsr0)
+* [`jsx-closing-bracket-location`]: message shows `{{details}}` when there are no details ([#3759][] @mdjermanovic)
+* [`no-invalid-html-attribute`]: ensure error messages are correct ([#3759][] @mdjermanovic, @ljharb)
+
+### Changed
+ * [Refactor] create various eslint utils to fix eslint deprecations ([#3759][] @mdjermanovic, @ljharb)
+
+[7.34.2]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.34.1...v7.34.2
+[#3759]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3759
+[#3746]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3746
+[#3718]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3718
+
+## [7.34.1] - 2024.03.15
+
+### Fixed
+* [`jsx-no-leaked-render`]: prevent wrongly adding parens ([#3700][] @developer-bandi)
+* [`boolean-prop-naming`]: detect TS interfaces ([#3701][] @developer-bandi)
+* [`boolean-prop-naming`]: literalType error fix ([#3704][] @developer-bandi)
+* [`boolean-prop-naming`]: allow TSIntersectionType ([#3705][] @developer-bandi)
+* [`no-unknown-property`]: support `popover`, `popovertarget`, `popovertargetaction` attributes ([#3707][] @ljharb)
+* [`no-unknown-property`]: only match `data-*` attributes containing `-` ([#3713][] @silverwind)
+* [`checked-requires-onchange-or-readonly`]: correct options that were behaving opposite ([#3715][] @jaesoekjjang)
+
+### Changed
+* [`boolean-prop-naming`]: improve error message (@ljharb)
+
+[7.34.1]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.34.0...v7.34.1
+[#3715]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3715
+[#3713]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3713
+[#3707]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3707
+[#3705]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3705
+[#3704]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3704
+[#3701]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3701
+[#3700]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3700
+
+## [7.34.0] - 2024.03.03
+
 ### Added
 * [`sort-prop-types`]: give errors on TS types ([#3615][] @akulsr0)
 * [`no-invalid-html-attribute`]: add support for `apple-touch-startup-image` `rel` attributes in `link` tags ([#3638][] @thomashockaday)
@@ -18,21 +273,34 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange
 * `linkAttribute` setting, [`jsx-no-target-blank`]: support multiple properties ([#3673][] @burtek)
 * [`jsx-no-script-url`]: add `includeFromSettings` option to support `linkAttributes` setting ([#3673][] @burtek)
 * [`jsx-one-expression-per-line`]: add `non-jsx` option to allow non-JSX children in one line ([#3677][] @burtek)
+* add [`checked-requires-onchange-or-readonly`] rule ([#3680][] @jaesoekjjang)
 
 ### Fixed
 * [`jsx-no-leaked-render`]: preserve RHS parens for multiline jsx elements while fixing ([#3623][] @akulsr0)
 * [`jsx-key`]: detect conditional returns ([#3630][] @yialo)
-* [`jsx-newline`]: prevent a crash when `allowMultilines ([#3633][] @ljharb)
+* [`jsx-newline`]: prevent a crash when `allowMultilines` ([#3633][] @ljharb)
 * [`no-unknown-property`]: use a better regex to avoid a crash ([#3666][] @ljharb @SCH227)
+* [`prop-types`]: handle nested forwardRef + memo ([#3679][] @developer-bandi)
+* [`no-unknown-property`]: add `fetchPriority` ([#3697][] @SevereCloud)
+* [`forbid-elements`]: prevent a crash on `createElement()` ([#3632][] @ljharb)
 
 ### Changed
+* [`jsx-boolean-value`]: make error messages clearer ([#3691][] @developer-bandi)
 * [Refactor] `propTypes`: extract type params to var ([#3634][] @HenryBrown0)
 * [Refactor] [`boolean-prop-naming`]: invert if statement ([#3634][] @HenryBrown0)
 * [Refactor] [`function-component-definition`]: exit early if no type params ([#3634][] @HenryBrown0)
 * [Refactor] [`jsx-props-no-multi-spaces`]: extract type parameters to var ([#3634][] @HenryBrown0)
 * [Docs] [`jsx-key`]: fix correct example ([#3656][] @developer-bandi)
 * [Tests] `jsx-wrap-multilines`: passing tests ([#3545][] @burtek)
-
+* [Docs] [`iframe-missing-sandbox`]: fix link to iframe attribute on mdn ([#3690][] @nnmrts)
+* [Docs] [`hook-use-state`]: fix an undefined variable ([#3626][] @chentsulin)
+
+[7.34.0]: https://github.com/jsx-eslint/eslint-plugin-react/compare/v7.33.2...v7.34.0
+[#3697]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3697
+[#3691]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3691
+[#3690]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3690
+[#3680]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3680
+[#3679]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3679
 [#3677]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3677
 [#3675]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3675
 [#3674]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3674
@@ -47,7 +315,9 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange
 [#3638]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3638
 [#3634]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3634
 [#3633]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3633
+[#3632]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3632
 [#3630]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3630
+[#3626]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3626
 [#3623]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3623
 [#3615]: https://github.com/jsx-eslint/eslint-plugin-react/pull/3615
 [#3545]: https://github.com/jsx-eslint/eslint-plugin-react/issues/3545
@@ -4136,6 +4406,7 @@ If you're still not using React 15 you can keep the old behavior by setting the
 
 [`boolean-prop-naming`]: docs/rules/boolean-prop-naming.md
 [`button-has-type`]: docs/rules/button-has-type.md
+[`checked-requires-onchange-or-readonly`]: docs/rules/checked-requires-onchange-or-readonly.md
 [`default-props-match-prop-types`]: docs/rules/default-props-match-prop-types.md
 [`destructuring-assignment`]: docs/rules/destructuring-assignment.md
 [`display-name`]: docs/rules/display-name.md
@@ -4144,6 +4415,7 @@ If you're still not using React 15 you can keep the old behavior by setting the
 [`forbid-elements`]: docs/rules/forbid-elements.md
 [`forbid-foreign-prop-types`]: docs/rules/forbid-foreign-prop-types.md
 [`forbid-prop-types`]: docs/rules/forbid-prop-types.md
+[`forward-ref-uses-ref`]: docs/rules/forward-ref-uses-ref.md
 [`function-component-definition`]: docs/rules/function-component-definition.md
 [`hook-use-state`]: docs/rules/hook-use-state.md
 [`iframe-missing-sandbox`]: docs/rules/iframe-missing-sandbox.md
@@ -4178,6 +4450,7 @@ If you're still not using React 15 you can keep the old behavior by setting the
 [`jsx-one-expression-per-line`]: docs/rules/jsx-one-expression-per-line.md
 [`jsx-pascal-case`]: docs/rules/jsx-pascal-case.md
 [`jsx-props-no-multi-spaces`]: docs/rules/jsx-props-no-multi-spaces.md
+[`jsx-props-no-spread-multi`]: docs/rules/jsx-props-no-spread-multi.md
 [`jsx-props-no-spreading`]: docs/rules/jsx-props-no-spreading.md
 [`jsx-props-no-spreading`]: docs/rules/jsx-props-no-spreading.md
 [`jsx-sort-default-props`]: docs/rules/jsx-sort-default-props.md
diff --git a/README.md b/README.md
index 9c67ff12b5..3c3cd24e3f 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ Use [our preset](#recommended) to get reasonable defaults:
 
 If you are using the [new JSX transform from React 17](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html#removing-unused-react-imports), extend [`react/jsx-runtime`](https://github.com/jsx-eslint/eslint-plugin-react/blob/c8917b0885094b5e4cc2a6f613f7fb6f16fe932e/index.js#L163-L176) in your eslint config (add `"plugin:react/jsx-runtime"` to `"extends"`) to disable the relevant rules.
 
-You should also specify settings that will be shared across all the plugin rules. ([More about eslint shared settings](https://eslint.org/docs/user-guide/configuring/configuration-files#adding-shared-settings))
+You should also specify settings that will be shared across all the plugin rules. ([More about eslint shared settings](https://eslint.org/docs/latest/use/configure/configuration-files#configuring-shared-settings))
 
 ```json5
 {
@@ -42,7 +42,9 @@ You should also specify settings that will be shared across all the plugin rules
       "fragment": "Fragment",  // Fragment to use (may be a property of <pragma>), default to "Fragment"
       "version": "detect", // React version. "detect" automatically picks the version you have installed.
                            // You can also use `16.0`, `16.3`, etc, if you want to override the detected value.
-                           // It will default to "latest" and warn if missing, and to "detect" in the future
+                           // Defaults to the "defaultVersion" setting and warns if missing, and to "detect" in the future
+      "defaultVersion": "", // Default React version to use when the version you have installed cannot be detected.
+                            // If not provided, defaults to the latest React version.
       "flowVersion": "0.53" // Flow version
     },
     "propWrapperFunctions": [
@@ -203,27 +205,23 @@ Refer to the [official docs](https://eslint.org/docs/latest/user-guide/configuri
 The schema of the `settings.react` object would be identical to that of what's already described above in the legacy config section.
 
 <!-- markdownlint-disable-next-line no-duplicate-heading -->
-### Shareable configs
-
-There're also 3 shareable configs.
-
-- `eslint-plugin-react/configs/all`
-- `eslint-plugin-react/configs/recommended`
-- `eslint-plugin-react/configs/jsx-runtime`
+### Flat Configs
 
-If your eslint.config.js is ESM, include the `.js` extension (e.g. `eslint-plugin-react/recommended.js`). Note that the next semver-major will require omitting the extension for these imports.
+This plugin exports 3 flat configs:
 
-**Note**: These configurations will import `eslint-plugin-react` and enable JSX in [`languageOptions.parserOptions`](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new#configuration-objects).
+- `flat.all`
+- `flat.recommended`
+- `flat['jsx-runtime']`
 
-In the new config system, `plugin:` protocol(e.g. `plugin:react/recommended`) is no longer valid.
-As eslint does not automatically import the preset config (shareable config), you explicitly do it by yourself.
+The flat configs are available via the root plugin import. They will configure the plugin under the `react/` namespace and enable JSX in [`languageOptions.parserOptions`](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options).
 
 ```js
-const reactRecommended = require('eslint-plugin-react/configs/recommended');
+const reactPlugin = require('eslint-plugin-react');
 
 module.exports = [
   …
-  reactRecommended, // This is not a plugin object, but a shareable config object
+  reactPlugin.configs.flat.recommended, // This is not a plugin object, but a shareable config object
+  reactPlugin.configs.flat['jsx-runtime'], // Add this if you are using React 17+
   …
 ];
 ```
@@ -234,16 +232,16 @@ You can of course add/override some properties.
 For most of the cases, you probably want to configure some properties by yourself.
 
 ```js
-const reactRecommended = require('eslint-plugin-react/configs/recommended');
+const reactPlugin = require('eslint-plugin-react');
 const globals = require('globals');
 
 module.exports = [
   …
   {
     files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
-    ...reactRecommended,
+    ...reactPlugin.configs.flat.recommended,
     languageOptions: {
-      ...reactRecommended.languageOptions,
+      ...reactPlugin.configs.flat.recommended.languageOptions,
       globals: {
         ...globals.serviceworker,
         ...globals.browser,
@@ -257,14 +255,14 @@ module.exports = [
 The above example is same as the example below, as the new config system is based on chaining.
 
 ```js
-const reactRecommended = require('eslint-plugin-react/configs/recommended');
+const reactPlugin = require('eslint-plugin-react');
 const globals = require('globals');
 
 module.exports = [
   …
   {
     files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
-    ...reactRecommended,
+    ...reactPlugin.configs.flat.recommended,
   },
   {
     files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
@@ -288,111 +286,114 @@ module.exports = [
 🏃 Set in the `jsx-runtime` [configuration](https://github.com/jsx-eslint/eslint-plugin-react/#shareable-configs).\
 ☑️ Set in the `recommended` [configuration](https://github.com/jsx-eslint/eslint-plugin-react/#shareable-configs).\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).\
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
 ❌ Deprecated.
 
-| Name                                                                                       | Description                                                                                                                                  | 💼 | 🚫 | 🔧 | 💡 | ❌  |
-| :----------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- | :- | :- |
-| [boolean-prop-naming](docs/rules/boolean-prop-naming.md)                                   | Enforces consistent naming for boolean props                                                                                                 |    |    |    |    |    |
-| [button-has-type](docs/rules/button-has-type.md)                                           | Disallow usage of `button` elements without an explicit `type` attribute                                                                     |    |    |    |    |    |
-| [default-props-match-prop-types](docs/rules/default-props-match-prop-types.md)             | Enforce all defaultProps have a corresponding non-required PropType                                                                          |    |    |    |    |    |
-| [destructuring-assignment](docs/rules/destructuring-assignment.md)                         | Enforce consistent usage of destructuring assignment of props, state, and context                                                            |    |    | 🔧 |    |    |
-| [display-name](docs/rules/display-name.md)                                                 | Disallow missing displayName in a React component definition                                                                                 | ☑️ |    |    |    |    |
-| [forbid-component-props](docs/rules/forbid-component-props.md)                             | Disallow certain props on components                                                                                                         |    |    |    |    |    |
-| [forbid-dom-props](docs/rules/forbid-dom-props.md)                                         | Disallow certain props on DOM Nodes                                                                                                          |    |    |    |    |    |
-| [forbid-elements](docs/rules/forbid-elements.md)                                           | Disallow certain elements                                                                                                                    |    |    |    |    |    |
-| [forbid-foreign-prop-types](docs/rules/forbid-foreign-prop-types.md)                       | Disallow using another component's propTypes                                                                                                 |    |    |    |    |    |
-| [forbid-prop-types](docs/rules/forbid-prop-types.md)                                       | Disallow certain propTypes                                                                                                                   |    |    |    |    |    |
-| [function-component-definition](docs/rules/function-component-definition.md)               | Enforce a specific function type for function components                                                                                     |    |    | 🔧 |    |    |
-| [hook-use-state](docs/rules/hook-use-state.md)                                             | Ensure destructuring and symmetric naming of useState hook value and setter variables                                                        |    |    |    | 💡 |    |
-| [iframe-missing-sandbox](docs/rules/iframe-missing-sandbox.md)                             | Enforce sandbox attribute on iframe elements                                                                                                 |    |    |    |    |    |
-| [jsx-boolean-value](docs/rules/jsx-boolean-value.md)                                       | Enforce boolean attributes notation in JSX                                                                                                   |    |    | 🔧 |    |    |
-| [jsx-child-element-spacing](docs/rules/jsx-child-element-spacing.md)                       | Enforce or disallow spaces inside of curly braces in JSX attributes and expressions                                                          |    |    |    |    |    |
-| [jsx-closing-bracket-location](docs/rules/jsx-closing-bracket-location.md)                 | Enforce closing bracket location in JSX                                                                                                      |    |    | 🔧 |    |    |
-| [jsx-closing-tag-location](docs/rules/jsx-closing-tag-location.md)                         | Enforce closing tag location for multiline JSX                                                                                               |    |    | 🔧 |    |    |
-| [jsx-curly-brace-presence](docs/rules/jsx-curly-brace-presence.md)                         | Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes |    |    | 🔧 |    |    |
-| [jsx-curly-newline](docs/rules/jsx-curly-newline.md)                                       | Enforce consistent linebreaks in curly braces in JSX attributes and expressions                                                              |    |    | 🔧 |    |    |
-| [jsx-curly-spacing](docs/rules/jsx-curly-spacing.md)                                       | Enforce or disallow spaces inside of curly braces in JSX attributes and expressions                                                          |    |    | 🔧 |    |    |
-| [jsx-equals-spacing](docs/rules/jsx-equals-spacing.md)                                     | Enforce or disallow spaces around equal signs in JSX attributes                                                                              |    |    | 🔧 |    |    |
-| [jsx-filename-extension](docs/rules/jsx-filename-extension.md)                             | Disallow file extensions that may contain JSX                                                                                                |    |    |    |    |    |
-| [jsx-first-prop-new-line](docs/rules/jsx-first-prop-new-line.md)                           | Enforce proper position of the first property in JSX                                                                                         |    |    | 🔧 |    |    |
-| [jsx-fragments](docs/rules/jsx-fragments.md)                                               | Enforce shorthand or standard form for React fragments                                                                                       |    |    | 🔧 |    |    |
-| [jsx-handler-names](docs/rules/jsx-handler-names.md)                                       | Enforce event handler naming conventions in JSX                                                                                              |    |    |    |    |    |
-| [jsx-indent](docs/rules/jsx-indent.md)                                                     | Enforce JSX indentation                                                                                                                      |    |    | 🔧 |    |    |
-| [jsx-indent-props](docs/rules/jsx-indent-props.md)                                         | Enforce props indentation in JSX                                                                                                             |    |    | 🔧 |    |    |
-| [jsx-key](docs/rules/jsx-key.md)                                                           | Disallow missing `key` props in iterators/collection literals                                                                                | ☑️ |    |    |    |    |
-| [jsx-max-depth](docs/rules/jsx-max-depth.md)                                               | Enforce JSX maximum depth                                                                                                                    |    |    |    |    |    |
-| [jsx-max-props-per-line](docs/rules/jsx-max-props-per-line.md)                             | Enforce maximum of props on a single line in JSX                                                                                             |    |    | 🔧 |    |    |
-| [jsx-newline](docs/rules/jsx-newline.md)                                                   | Require or prevent a new line after jsx elements and expressions.                                                                            |    |    | 🔧 |    |    |
-| [jsx-no-bind](docs/rules/jsx-no-bind.md)                                                   | Disallow `.bind()` or arrow functions in JSX props                                                                                           |    |    |    |    |    |
-| [jsx-no-comment-textnodes](docs/rules/jsx-no-comment-textnodes.md)                         | Disallow comments from being inserted as text nodes                                                                                          | ☑️ |    |    |    |    |
-| [jsx-no-constructed-context-values](docs/rules/jsx-no-constructed-context-values.md)       | Disallows JSX context provider values from taking values that will cause needless rerenders                                                  |    |    |    |    |    |
-| [jsx-no-duplicate-props](docs/rules/jsx-no-duplicate-props.md)                             | Disallow duplicate properties in JSX                                                                                                         | ☑️ |    |    |    |    |
-| [jsx-no-leaked-render](docs/rules/jsx-no-leaked-render.md)                                 | Disallow problematic leaked values from being rendered                                                                                       |    |    | 🔧 |    |    |
-| [jsx-no-literals](docs/rules/jsx-no-literals.md)                                           | Disallow usage of string literals in JSX                                                                                                     |    |    |    |    |    |
-| [jsx-no-script-url](docs/rules/jsx-no-script-url.md)                                       | Disallow usage of `javascript:` URLs                                                                                                         |    |    |    |    |    |
-| [jsx-no-target-blank](docs/rules/jsx-no-target-blank.md)                                   | Disallow `target="_blank"` attribute without `rel="noreferrer"`                                                                              | ☑️ |    | 🔧 |    |    |
-| [jsx-no-undef](docs/rules/jsx-no-undef.md)                                                 | Disallow undeclared variables in JSX                                                                                                         | ☑️ |    |    |    |    |
-| [jsx-no-useless-fragment](docs/rules/jsx-no-useless-fragment.md)                           | Disallow unnecessary fragments                                                                                                               |    |    | 🔧 |    |    |
-| [jsx-one-expression-per-line](docs/rules/jsx-one-expression-per-line.md)                   | Require one JSX element per line                                                                                                             |    |    | 🔧 |    |    |
-| [jsx-pascal-case](docs/rules/jsx-pascal-case.md)                                           | Enforce PascalCase for user-defined JSX components                                                                                           |    |    |    |    |    |
-| [jsx-props-no-multi-spaces](docs/rules/jsx-props-no-multi-spaces.md)                       | Disallow multiple spaces between inline JSX props                                                                                            |    |    | 🔧 |    |    |
-| [jsx-props-no-spreading](docs/rules/jsx-props-no-spreading.md)                             | Disallow JSX prop spreading                                                                                                                  |    |    |    |    |    |
-| [jsx-sort-default-props](docs/rules/jsx-sort-default-props.md)                             | Enforce defaultProps declarations alphabetical sorting                                                                                       |    |    |    |    | ❌  |
-| [jsx-sort-props](docs/rules/jsx-sort-props.md)                                             | Enforce props alphabetical sorting                                                                                                           |    |    | 🔧 |    |    |
-| [jsx-space-before-closing](docs/rules/jsx-space-before-closing.md)                         | Enforce spacing before closing bracket in JSX                                                                                                |    |    | 🔧 |    | ❌  |
-| [jsx-tag-spacing](docs/rules/jsx-tag-spacing.md)                                           | Enforce whitespace in and around the JSX opening and closing brackets                                                                        |    |    | 🔧 |    |    |
-| [jsx-uses-react](docs/rules/jsx-uses-react.md)                                             | Disallow React to be incorrectly marked as unused                                                                                            | ☑️ | 🏃 |    |    |    |
-| [jsx-uses-vars](docs/rules/jsx-uses-vars.md)                                               | Disallow variables used in JSX to be incorrectly marked as unused                                                                            | ☑️ |    |    |    |    |
-| [jsx-wrap-multilines](docs/rules/jsx-wrap-multilines.md)                                   | Disallow missing parentheses around multiline JSX                                                                                            |    |    | 🔧 |    |    |
-| [no-access-state-in-setstate](docs/rules/no-access-state-in-setstate.md)                   | Disallow when this.state is accessed within setState                                                                                         |    |    |    |    |    |
-| [no-adjacent-inline-elements](docs/rules/no-adjacent-inline-elements.md)                   | Disallow adjacent inline elements not separated by whitespace.                                                                               |    |    |    |    |    |
-| [no-array-index-key](docs/rules/no-array-index-key.md)                                     | Disallow usage of Array index in keys                                                                                                        |    |    |    |    |    |
-| [no-arrow-function-lifecycle](docs/rules/no-arrow-function-lifecycle.md)                   | Lifecycle methods should be methods on the prototype, not class fields                                                                       |    |    | 🔧 |    |    |
-| [no-children-prop](docs/rules/no-children-prop.md)                                         | Disallow passing of children as props                                                                                                        | ☑️ |    |    |    |    |
-| [no-danger](docs/rules/no-danger.md)                                                       | Disallow usage of dangerous JSX properties                                                                                                   |    |    |    |    |    |
-| [no-danger-with-children](docs/rules/no-danger-with-children.md)                           | Disallow when a DOM element is using both children and dangerouslySetInnerHTML                                                               | ☑️ |    |    |    |    |
-| [no-deprecated](docs/rules/no-deprecated.md)                                               | Disallow usage of deprecated methods                                                                                                         | ☑️ |    |    |    |    |
-| [no-did-mount-set-state](docs/rules/no-did-mount-set-state.md)                             | Disallow usage of setState in componentDidMount                                                                                              |    |    |    |    |    |
-| [no-did-update-set-state](docs/rules/no-did-update-set-state.md)                           | Disallow usage of setState in componentDidUpdate                                                                                             |    |    |    |    |    |
-| [no-direct-mutation-state](docs/rules/no-direct-mutation-state.md)                         | Disallow direct mutation of this.state                                                                                                       | ☑️ |    |    |    |    |
-| [no-find-dom-node](docs/rules/no-find-dom-node.md)                                         | Disallow usage of findDOMNode                                                                                                                | ☑️ |    |    |    |    |
-| [no-invalid-html-attribute](docs/rules/no-invalid-html-attribute.md)                       | Disallow usage of invalid attributes                                                                                                         |    |    |    | 💡 |    |
-| [no-is-mounted](docs/rules/no-is-mounted.md)                                               | Disallow usage of isMounted                                                                                                                  | ☑️ |    |    |    |    |
-| [no-multi-comp](docs/rules/no-multi-comp.md)                                               | Disallow multiple component definition per file                                                                                              |    |    |    |    |    |
-| [no-namespace](docs/rules/no-namespace.md)                                                 | Enforce that namespaces are not used in React elements                                                                                       |    |    |    |    |    |
-| [no-object-type-as-default-prop](docs/rules/no-object-type-as-default-prop.md)             | Disallow usage of referential-type variables as default param in functional component                                                        |    |    |    |    |    |
-| [no-redundant-should-component-update](docs/rules/no-redundant-should-component-update.md) | Disallow usage of shouldComponentUpdate when extending React.PureComponent                                                                   |    |    |    |    |    |
-| [no-render-return-value](docs/rules/no-render-return-value.md)                             | Disallow usage of the return value of ReactDOM.render                                                                                        | ☑️ |    |    |    |    |
-| [no-set-state](docs/rules/no-set-state.md)                                                 | Disallow usage of setState                                                                                                                   |    |    |    |    |    |
-| [no-string-refs](docs/rules/no-string-refs.md)                                             | Disallow using string references                                                                                                             | ☑️ |    |    |    |    |
-| [no-this-in-sfc](docs/rules/no-this-in-sfc.md)                                             | Disallow `this` from being used in stateless functional components                                                                           |    |    |    |    |    |
-| [no-typos](docs/rules/no-typos.md)                                                         | Disallow common typos                                                                                                                        |    |    |    |    |    |
-| [no-unescaped-entities](docs/rules/no-unescaped-entities.md)                               | Disallow unescaped HTML entities from appearing in markup                                                                                    | ☑️ |    |    |    |    |
-| [no-unknown-property](docs/rules/no-unknown-property.md)                                   | Disallow usage of unknown DOM property                                                                                                       | ☑️ |    | 🔧 |    |    |
-| [no-unsafe](docs/rules/no-unsafe.md)                                                       | Disallow usage of unsafe lifecycle methods                                                                                                   |    | ☑️ |    |    |    |
-| [no-unstable-nested-components](docs/rules/no-unstable-nested-components.md)               | Disallow creating unstable components inside components                                                                                      |    |    |    |    |    |
-| [no-unused-class-component-methods](docs/rules/no-unused-class-component-methods.md)       | Disallow declaring unused methods of component class                                                                                         |    |    |    |    |    |
-| [no-unused-prop-types](docs/rules/no-unused-prop-types.md)                                 | Disallow definitions of unused propTypes                                                                                                     |    |    |    |    |    |
-| [no-unused-state](docs/rules/no-unused-state.md)                                           | Disallow definitions of unused state                                                                                                         |    |    |    |    |    |
-| [no-will-update-set-state](docs/rules/no-will-update-set-state.md)                         | Disallow usage of setState in componentWillUpdate                                                                                            |    |    |    |    |    |
-| [prefer-es6-class](docs/rules/prefer-es6-class.md)                                         | Enforce ES5 or ES6 class for React Components                                                                                                |    |    |    |    |    |
-| [prefer-exact-props](docs/rules/prefer-exact-props.md)                                     | Prefer exact proptype definitions                                                                                                            |    |    |    |    |    |
-| [prefer-read-only-props](docs/rules/prefer-read-only-props.md)                             | Enforce that props are read-only                                                                                                             |    |    | 🔧 |    |    |
-| [prefer-stateless-function](docs/rules/prefer-stateless-function.md)                       | Enforce stateless components to be written as a pure function                                                                                |    |    |    |    |    |
-| [prop-types](docs/rules/prop-types.md)                                                     | Disallow missing props validation in a React component definition                                                                            | ☑️ |    |    |    |    |
-| [react-in-jsx-scope](docs/rules/react-in-jsx-scope.md)                                     | Disallow missing React when using JSX                                                                                                        | ☑️ | 🏃 |    |    |    |
-| [require-default-props](docs/rules/require-default-props.md)                               | Enforce a defaultProps definition for every prop that is not a required prop                                                                 |    |    |    |    |    |
-| [require-optimization](docs/rules/require-optimization.md)                                 | Enforce React components to have a shouldComponentUpdate method                                                                              |    |    |    |    |    |
-| [require-render-return](docs/rules/require-render-return.md)                               | Enforce ES5 or ES6 class for returning value in render function                                                                              | ☑️ |    |    |    |    |
-| [self-closing-comp](docs/rules/self-closing-comp.md)                                       | Disallow extra closing tags for components without children                                                                                  |    |    | 🔧 |    |    |
-| [sort-comp](docs/rules/sort-comp.md)                                                       | Enforce component methods order                                                                                                              |    |    |    |    |    |
-| [sort-default-props](docs/rules/sort-default-props.md)                                     | Enforce defaultProps declarations alphabetical sorting                                                                                       |    |    |    |    |    |
-| [sort-prop-types](docs/rules/sort-prop-types.md)                                           | Enforce propTypes declarations alphabetical sorting                                                                                          |    |    | 🔧 |    |    |
-| [state-in-constructor](docs/rules/state-in-constructor.md)                                 | Enforce class component state initialization style                                                                                           |    |    |    |    |    |
-| [static-property-placement](docs/rules/static-property-placement.md)                       | Enforces where React component static properties should be positioned.                                                                       |    |    |    |    |    |
-| [style-prop-object](docs/rules/style-prop-object.md)                                       | Enforce style prop value is an object                                                                                                        |    |    |    |    |    |
-| [void-dom-elements-no-children](docs/rules/void-dom-elements-no-children.md)               | Disallow void DOM elements (e.g. `<img />`, `<br />`) from receiving children                                                                |    |    |    |    |    |
+| Name                                                                                         | Description                                                                                                                                  | 💼 | 🚫 | 🔧 | 💡 | ❌  |
+| :------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- | :- | :- |
+| [boolean-prop-naming](docs/rules/boolean-prop-naming.md)                                     | Enforces consistent naming for boolean props                                                                                                 |    |    |    |    |    |
+| [button-has-type](docs/rules/button-has-type.md)                                             | Disallow usage of `button` elements without an explicit `type` attribute                                                                     |    |    |    |    |    |
+| [checked-requires-onchange-or-readonly](docs/rules/checked-requires-onchange-or-readonly.md) | Enforce using `onChange` or `readonly` attribute when `checked` is used                                                                      |    |    |    |    |    |
+| [default-props-match-prop-types](docs/rules/default-props-match-prop-types.md)               | Enforce all defaultProps have a corresponding non-required PropType                                                                          |    |    |    |    |    |
+| [destructuring-assignment](docs/rules/destructuring-assignment.md)                           | Enforce consistent usage of destructuring assignment of props, state, and context                                                            |    |    | 🔧 |    |    |
+| [display-name](docs/rules/display-name.md)                                                   | Disallow missing displayName in a React component definition                                                                                 | ☑️ |    |    |    |    |
+| [forbid-component-props](docs/rules/forbid-component-props.md)                               | Disallow certain props on components                                                                                                         |    |    |    |    |    |
+| [forbid-dom-props](docs/rules/forbid-dom-props.md)                                           | Disallow certain props on DOM Nodes                                                                                                          |    |    |    |    |    |
+| [forbid-elements](docs/rules/forbid-elements.md)                                             | Disallow certain elements                                                                                                                    |    |    |    |    |    |
+| [forbid-foreign-prop-types](docs/rules/forbid-foreign-prop-types.md)                         | Disallow using another component's propTypes                                                                                                 |    |    |    |    |    |
+| [forbid-prop-types](docs/rules/forbid-prop-types.md)                                         | Disallow certain propTypes                                                                                                                   |    |    |    |    |    |
+| [forward-ref-uses-ref](docs/rules/forward-ref-uses-ref.md)                                   | Require all forwardRef components include a ref parameter                                                                                    |    |    |    | 💡 |    |
+| [function-component-definition](docs/rules/function-component-definition.md)                 | Enforce a specific function type for function components                                                                                     |    |    | 🔧 |    |    |
+| [hook-use-state](docs/rules/hook-use-state.md)                                               | Ensure destructuring and symmetric naming of useState hook value and setter variables                                                        |    |    |    | 💡 |    |
+| [iframe-missing-sandbox](docs/rules/iframe-missing-sandbox.md)                               | Enforce sandbox attribute on iframe elements                                                                                                 |    |    |    |    |    |
+| [jsx-boolean-value](docs/rules/jsx-boolean-value.md)                                         | Enforce boolean attributes notation in JSX                                                                                                   |    |    | 🔧 |    |    |
+| [jsx-child-element-spacing](docs/rules/jsx-child-element-spacing.md)                         | Enforce or disallow spaces inside of curly braces in JSX attributes and expressions                                                          |    |    |    |    |    |
+| [jsx-closing-bracket-location](docs/rules/jsx-closing-bracket-location.md)                   | Enforce closing bracket location in JSX                                                                                                      |    |    | 🔧 |    |    |
+| [jsx-closing-tag-location](docs/rules/jsx-closing-tag-location.md)                           | Enforce closing tag location for multiline JSX                                                                                               |    |    | 🔧 |    |    |
+| [jsx-curly-brace-presence](docs/rules/jsx-curly-brace-presence.md)                           | Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes |    |    | 🔧 |    |    |
+| [jsx-curly-newline](docs/rules/jsx-curly-newline.md)                                         | Enforce consistent linebreaks in curly braces in JSX attributes and expressions                                                              |    |    | 🔧 |    |    |
+| [jsx-curly-spacing](docs/rules/jsx-curly-spacing.md)                                         | Enforce or disallow spaces inside of curly braces in JSX attributes and expressions                                                          |    |    | 🔧 |    |    |
+| [jsx-equals-spacing](docs/rules/jsx-equals-spacing.md)                                       | Enforce or disallow spaces around equal signs in JSX attributes                                                                              |    |    | 🔧 |    |    |
+| [jsx-filename-extension](docs/rules/jsx-filename-extension.md)                               | Disallow file extensions that may contain JSX                                                                                                |    |    |    |    |    |
+| [jsx-first-prop-new-line](docs/rules/jsx-first-prop-new-line.md)                             | Enforce proper position of the first property in JSX                                                                                         |    |    | 🔧 |    |    |
+| [jsx-fragments](docs/rules/jsx-fragments.md)                                                 | Enforce shorthand or standard form for React fragments                                                                                       |    |    | 🔧 |    |    |
+| [jsx-handler-names](docs/rules/jsx-handler-names.md)                                         | Enforce event handler naming conventions in JSX                                                                                              |    |    |    |    |    |
+| [jsx-indent](docs/rules/jsx-indent.md)                                                       | Enforce JSX indentation                                                                                                                      |    |    | 🔧 |    |    |
+| [jsx-indent-props](docs/rules/jsx-indent-props.md)                                           | Enforce props indentation in JSX                                                                                                             |    |    | 🔧 |    |    |
+| [jsx-key](docs/rules/jsx-key.md)                                                             | Disallow missing `key` props in iterators/collection literals                                                                                | ☑️ |    |    |    |    |
+| [jsx-max-depth](docs/rules/jsx-max-depth.md)                                                 | Enforce JSX maximum depth                                                                                                                    |    |    |    |    |    |
+| [jsx-max-props-per-line](docs/rules/jsx-max-props-per-line.md)                               | Enforce maximum of props on a single line in JSX                                                                                             |    |    | 🔧 |    |    |
+| [jsx-newline](docs/rules/jsx-newline.md)                                                     | Require or prevent a new line after jsx elements and expressions.                                                                            |    |    | 🔧 |    |    |
+| [jsx-no-bind](docs/rules/jsx-no-bind.md)                                                     | Disallow `.bind()` or arrow functions in JSX props                                                                                           |    |    |    |    |    |
+| [jsx-no-comment-textnodes](docs/rules/jsx-no-comment-textnodes.md)                           | Disallow comments from being inserted as text nodes                                                                                          | ☑️ |    |    |    |    |
+| [jsx-no-constructed-context-values](docs/rules/jsx-no-constructed-context-values.md)         | Disallows JSX context provider values from taking values that will cause needless rerenders                                                  |    |    |    |    |    |
+| [jsx-no-duplicate-props](docs/rules/jsx-no-duplicate-props.md)                               | Disallow duplicate properties in JSX                                                                                                         | ☑️ |    |    |    |    |
+| [jsx-no-leaked-render](docs/rules/jsx-no-leaked-render.md)                                   | Disallow problematic leaked values from being rendered                                                                                       |    |    | 🔧 |    |    |
+| [jsx-no-literals](docs/rules/jsx-no-literals.md)                                             | Disallow usage of string literals in JSX                                                                                                     |    |    |    |    |    |
+| [jsx-no-script-url](docs/rules/jsx-no-script-url.md)                                         | Disallow usage of `javascript:` URLs                                                                                                         |    |    |    |    |    |
+| [jsx-no-target-blank](docs/rules/jsx-no-target-blank.md)                                     | Disallow `target="_blank"` attribute without `rel="noreferrer"`                                                                              | ☑️ |    | 🔧 |    |    |
+| [jsx-no-undef](docs/rules/jsx-no-undef.md)                                                   | Disallow undeclared variables in JSX                                                                                                         | ☑️ |    |    |    |    |
+| [jsx-no-useless-fragment](docs/rules/jsx-no-useless-fragment.md)                             | Disallow unnecessary fragments                                                                                                               |    |    | 🔧 |    |    |
+| [jsx-one-expression-per-line](docs/rules/jsx-one-expression-per-line.md)                     | Require one JSX element per line                                                                                                             |    |    | 🔧 |    |    |
+| [jsx-pascal-case](docs/rules/jsx-pascal-case.md)                                             | Enforce PascalCase for user-defined JSX components                                                                                           |    |    |    |    |    |
+| [jsx-props-no-multi-spaces](docs/rules/jsx-props-no-multi-spaces.md)                         | Disallow multiple spaces between inline JSX props                                                                                            |    |    | 🔧 |    |    |
+| [jsx-props-no-spread-multi](docs/rules/jsx-props-no-spread-multi.md)                         | Disallow JSX prop spreading the same identifier multiple times                                                                               |    |    |    |    |    |
+| [jsx-props-no-spreading](docs/rules/jsx-props-no-spreading.md)                               | Disallow JSX prop spreading                                                                                                                  |    |    |    |    |    |
+| [jsx-sort-default-props](docs/rules/jsx-sort-default-props.md)                               | Enforce defaultProps declarations alphabetical sorting                                                                                       |    |    |    |    | ❌  |
+| [jsx-sort-props](docs/rules/jsx-sort-props.md)                                               | Enforce props alphabetical sorting                                                                                                           |    |    | 🔧 |    |    |
+| [jsx-space-before-closing](docs/rules/jsx-space-before-closing.md)                           | Enforce spacing before closing bracket in JSX                                                                                                |    |    | 🔧 |    | ❌  |
+| [jsx-tag-spacing](docs/rules/jsx-tag-spacing.md)                                             | Enforce whitespace in and around the JSX opening and closing brackets                                                                        |    |    | 🔧 |    |    |
+| [jsx-uses-react](docs/rules/jsx-uses-react.md)                                               | Disallow React to be incorrectly marked as unused                                                                                            | ☑️ | 🏃 |    |    |    |
+| [jsx-uses-vars](docs/rules/jsx-uses-vars.md)                                                 | Disallow variables used in JSX to be incorrectly marked as unused                                                                            | ☑️ |    |    |    |    |
+| [jsx-wrap-multilines](docs/rules/jsx-wrap-multilines.md)                                     | Disallow missing parentheses around multiline JSX                                                                                            |    |    | 🔧 |    |    |
+| [no-access-state-in-setstate](docs/rules/no-access-state-in-setstate.md)                     | Disallow when this.state is accessed within setState                                                                                         |    |    |    |    |    |
+| [no-adjacent-inline-elements](docs/rules/no-adjacent-inline-elements.md)                     | Disallow adjacent inline elements not separated by whitespace.                                                                               |    |    |    |    |    |
+| [no-array-index-key](docs/rules/no-array-index-key.md)                                       | Disallow usage of Array index in keys                                                                                                        |    |    |    |    |    |
+| [no-arrow-function-lifecycle](docs/rules/no-arrow-function-lifecycle.md)                     | Lifecycle methods should be methods on the prototype, not class fields                                                                       |    |    | 🔧 |    |    |
+| [no-children-prop](docs/rules/no-children-prop.md)                                           | Disallow passing of children as props                                                                                                        | ☑️ |    |    |    |    |
+| [no-danger](docs/rules/no-danger.md)                                                         | Disallow usage of dangerous JSX properties                                                                                                   |    |    |    |    |    |
+| [no-danger-with-children](docs/rules/no-danger-with-children.md)                             | Disallow when a DOM element is using both children and dangerouslySetInnerHTML                                                               | ☑️ |    |    |    |    |
+| [no-deprecated](docs/rules/no-deprecated.md)                                                 | Disallow usage of deprecated methods                                                                                                         | ☑️ |    |    |    |    |
+| [no-did-mount-set-state](docs/rules/no-did-mount-set-state.md)                               | Disallow usage of setState in componentDidMount                                                                                              |    |    |    |    |    |
+| [no-did-update-set-state](docs/rules/no-did-update-set-state.md)                             | Disallow usage of setState in componentDidUpdate                                                                                             |    |    |    |    |    |
+| [no-direct-mutation-state](docs/rules/no-direct-mutation-state.md)                           | Disallow direct mutation of this.state                                                                                                       | ☑️ |    |    |    |    |
+| [no-find-dom-node](docs/rules/no-find-dom-node.md)                                           | Disallow usage of findDOMNode                                                                                                                | ☑️ |    |    |    |    |
+| [no-invalid-html-attribute](docs/rules/no-invalid-html-attribute.md)                         | Disallow usage of invalid attributes                                                                                                         |    |    |    | 💡 |    |
+| [no-is-mounted](docs/rules/no-is-mounted.md)                                                 | Disallow usage of isMounted                                                                                                                  | ☑️ |    |    |    |    |
+| [no-multi-comp](docs/rules/no-multi-comp.md)                                                 | Disallow multiple component definition per file                                                                                              |    |    |    |    |    |
+| [no-namespace](docs/rules/no-namespace.md)                                                   | Enforce that namespaces are not used in React elements                                                                                       |    |    |    |    |    |
+| [no-object-type-as-default-prop](docs/rules/no-object-type-as-default-prop.md)               | Disallow usage of referential-type variables as default param in functional component                                                        |    |    |    |    |    |
+| [no-redundant-should-component-update](docs/rules/no-redundant-should-component-update.md)   | Disallow usage of shouldComponentUpdate when extending React.PureComponent                                                                   |    |    |    |    |    |
+| [no-render-return-value](docs/rules/no-render-return-value.md)                               | Disallow usage of the return value of ReactDOM.render                                                                                        | ☑️ |    |    |    |    |
+| [no-set-state](docs/rules/no-set-state.md)                                                   | Disallow usage of setState                                                                                                                   |    |    |    |    |    |
+| [no-string-refs](docs/rules/no-string-refs.md)                                               | Disallow using string references                                                                                                             | ☑️ |    |    |    |    |
+| [no-this-in-sfc](docs/rules/no-this-in-sfc.md)                                               | Disallow `this` from being used in stateless functional components                                                                           |    |    |    |    |    |
+| [no-typos](docs/rules/no-typos.md)                                                           | Disallow common typos                                                                                                                        |    |    |    |    |    |
+| [no-unescaped-entities](docs/rules/no-unescaped-entities.md)                                 | Disallow unescaped HTML entities from appearing in markup                                                                                    | ☑️ |    |    | 💡 |    |
+| [no-unknown-property](docs/rules/no-unknown-property.md)                                     | Disallow usage of unknown DOM property                                                                                                       | ☑️ |    | 🔧 |    |    |
+| [no-unsafe](docs/rules/no-unsafe.md)                                                         | Disallow usage of unsafe lifecycle methods                                                                                                   |    | ☑️ |    |    |    |
+| [no-unstable-nested-components](docs/rules/no-unstable-nested-components.md)                 | Disallow creating unstable components inside components                                                                                      |    |    |    |    |    |
+| [no-unused-class-component-methods](docs/rules/no-unused-class-component-methods.md)         | Disallow declaring unused methods of component class                                                                                         |    |    |    |    |    |
+| [no-unused-prop-types](docs/rules/no-unused-prop-types.md)                                   | Disallow definitions of unused propTypes                                                                                                     |    |    |    |    |    |
+| [no-unused-state](docs/rules/no-unused-state.md)                                             | Disallow definitions of unused state                                                                                                         |    |    |    |    |    |
+| [no-will-update-set-state](docs/rules/no-will-update-set-state.md)                           | Disallow usage of setState in componentWillUpdate                                                                                            |    |    |    |    |    |
+| [prefer-es6-class](docs/rules/prefer-es6-class.md)                                           | Enforce ES5 or ES6 class for React Components                                                                                                |    |    |    |    |    |
+| [prefer-exact-props](docs/rules/prefer-exact-props.md)                                       | Prefer exact proptype definitions                                                                                                            |    |    |    |    |    |
+| [prefer-read-only-props](docs/rules/prefer-read-only-props.md)                               | Enforce that props are read-only                                                                                                             |    |    | 🔧 |    |    |
+| [prefer-stateless-function](docs/rules/prefer-stateless-function.md)                         | Enforce stateless components to be written as a pure function                                                                                |    |    |    |    |    |
+| [prop-types](docs/rules/prop-types.md)                                                       | Disallow missing props validation in a React component definition                                                                            | ☑️ |    |    |    |    |
+| [react-in-jsx-scope](docs/rules/react-in-jsx-scope.md)                                       | Disallow missing React when using JSX                                                                                                        | ☑️ | 🏃 |    |    |    |
+| [require-default-props](docs/rules/require-default-props.md)                                 | Enforce a defaultProps definition for every prop that is not a required prop                                                                 |    |    |    |    |    |
+| [require-optimization](docs/rules/require-optimization.md)                                   | Enforce React components to have a shouldComponentUpdate method                                                                              |    |    |    |    |    |
+| [require-render-return](docs/rules/require-render-return.md)                                 | Enforce ES5 or ES6 class for returning value in render function                                                                              | ☑️ |    |    |    |    |
+| [self-closing-comp](docs/rules/self-closing-comp.md)                                         | Disallow extra closing tags for components without children                                                                                  |    |    | 🔧 |    |    |
+| [sort-comp](docs/rules/sort-comp.md)                                                         | Enforce component methods order                                                                                                              |    |    |    |    |    |
+| [sort-default-props](docs/rules/sort-default-props.md)                                       | Enforce defaultProps declarations alphabetical sorting                                                                                       |    |    |    |    |    |
+| [sort-prop-types](docs/rules/sort-prop-types.md)                                             | Enforce propTypes declarations alphabetical sorting                                                                                          |    |    | 🔧 |    |    |
+| [state-in-constructor](docs/rules/state-in-constructor.md)                                   | Enforce class component state initialization style                                                                                           |    |    |    |    |    |
+| [static-property-placement](docs/rules/static-property-placement.md)                         | Enforces where React component static properties should be positioned.                                                                       |    |    |    |    |    |
+| [style-prop-object](docs/rules/style-prop-object.md)                                         | Enforce style prop value is an object                                                                                                        |    |    |    |    |    |
+| [void-dom-elements-no-children](docs/rules/void-dom-elements-no-children.md)                 | Disallow void DOM elements (e.g. `<img />`, `<br />`) from receiving children                                                                |    |    |    |    |    |
 
 <!-- end auto-generated rules list -->
 
diff --git a/build.tsconfig.json b/build.tsconfig.json
new file mode 100644
index 0000000000..df874658e8
--- /dev/null
+++ b/build.tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig",
+  "files": [
+    "index.js"
+  ],
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "noEmit": false,
+    "emitDeclarationOnly": true
+  }
+}
diff --git a/configs/all.js b/configs/all.js
index c507744ac1..3123c5bd5d 100644
--- a/configs/all.js
+++ b/configs/all.js
@@ -1,39 +1,13 @@
 'use strict';
 
-const fromEntries = require('object.fromentries');
-const entries = require('object.entries');
+const plugin = require('..');
 
-const allRules = require('../lib/rules');
-
-function filterRules(rules, predicate) {
-  return fromEntries(entries(rules).filter((entry) => predicate(entry[1])));
-}
-
-function configureAsError(rules) {
-  return fromEntries(Object.keys(rules).map((key) => [`react/${key}`, 2]));
-}
-
-const activeRules = filterRules(allRules, (rule) => !rule.meta.deprecated);
-const activeRulesConfig = configureAsError(activeRules);
-
-const deprecatedRules = filterRules(allRules, (rule) => rule.meta.deprecated);
+const legacyConfig = plugin.configs.all;
 
 module.exports = {
-  plugins: {
-    react: {
-      deprecatedRules,
-      rules: allRules,
-    },
-  },
-  rules: activeRulesConfig,
-  languageOptions: {
-    parserOptions: {
-      ecmaFeatures: {
-        jsx: true,
-      },
-    },
-  },
+  plugins: { react: plugin },
+  rules: legacyConfig.rules,
+  languageOptions: { parserOptions: legacyConfig.parserOptions },
 };
 
-// this is so the `languageOptions` property won't be warned in the new config system
 Object.defineProperty(module.exports, 'languageOptions', { enumerable: false });
diff --git a/configs/jsx-runtime.js b/configs/jsx-runtime.js
index a6302be504..f5cd178587 100644
--- a/configs/jsx-runtime.js
+++ b/configs/jsx-runtime.js
@@ -1,18 +1,13 @@
 'use strict';
 
-const all = require('./all');
+const plugin = require('..');
 
-module.exports = Object.assign({}, all, {
-  languageOptions: Object.assign({}, all.languageOptions, {
-    parserOptions: Object.assign({}, all.languageOptions.parserOptions, {
-      jsxPragma: null, // for @typescript/eslint-parser
-    }),
-  }),
-  rules: {
-    'react/react-in-jsx-scope': 0,
-    'react/jsx-uses-react': 0,
-  },
-});
+const legacyConfig = plugin.configs['jsx-runtime'];
+
+module.exports = {
+  plugins: { react: plugin },
+  rules: legacyConfig.rules,
+  languageOptions: { parserOptions: legacyConfig.parserOptions },
+};
 
-// this is so the `languageOptions` property won't be warned in the new config system
 Object.defineProperty(module.exports, 'languageOptions', { enumerable: false });
diff --git a/configs/recommended.js b/configs/recommended.js
index 0bba09f7bb..19cbda4cf4 100644
--- a/configs/recommended.js
+++ b/configs/recommended.js
@@ -1,34 +1,13 @@
 'use strict';
 
-const all = require('./all');
+const plugin = require('..');
 
-module.exports = Object.assign({}, all, {
-  languageOptions: all.languageOptions,
-  rules: {
-    'react/display-name': 2,
-    'react/jsx-key': 2,
-    'react/jsx-no-comment-textnodes': 2,
-    'react/jsx-no-duplicate-props': 2,
-    'react/jsx-no-target-blank': 2,
-    'react/jsx-no-undef': 2,
-    'react/jsx-uses-react': 2,
-    'react/jsx-uses-vars': 2,
-    'react/no-children-prop': 2,
-    'react/no-danger-with-children': 2,
-    'react/no-deprecated': 2,
-    'react/no-direct-mutation-state': 2,
-    'react/no-find-dom-node': 2,
-    'react/no-is-mounted': 2,
-    'react/no-render-return-value': 2,
-    'react/no-string-refs': 2,
-    'react/no-unescaped-entities': 2,
-    'react/no-unknown-property': 2,
-    'react/no-unsafe': 0,
-    'react/prop-types': 2,
-    'react/react-in-jsx-scope': 2,
-    'react/require-render-return': 2,
-  },
-});
+const legacyConfig = plugin.configs.recommended;
+
+module.exports = {
+  plugins: { react: plugin },
+  rules: legacyConfig.rules,
+  languageOptions: { parserOptions: legacyConfig.parserOptions },
+};
 
-// this is so the `languageOptions` property won't be warned in the new config system
 Object.defineProperty(module.exports, 'languageOptions', { enumerable: false });
diff --git a/docs/rules/button-has-type.md b/docs/rules/button-has-type.md
index 8bd8b6a85b..cf2d5914c8 100644
--- a/docs/rules/button-has-type.md
+++ b/docs/rules/button-has-type.md
@@ -2,8 +2,8 @@
 
 <!-- end auto-generated rule header -->
 
-The default value of `type` attribute for `button` HTML element is `"submit"` which is often not the desired behavior and may lead to unexpected page reloads.
-This rules enforces an explicit `type` attribute for all the `button` elements and checks that its value is valid per spec (i.e., is one of `"button"`, `"submit"`, and `"reset"`).
+The default value of the `type` attribute for HTML `button` elements is `"submit"`. This is often not the desired behavior and may lead to unexpected page reloads.
+This rules enforces an explicit `type` attribute for all `button` elements and checks that its value is valid per the spec (i.e., is one of `"button"`, `"submit"`, and `"reset"`).
 
 ## Rule Details
 
diff --git a/docs/rules/checked-requires-onchange-or-readonly.md b/docs/rules/checked-requires-onchange-or-readonly.md
new file mode 100644
index 0000000000..13ec64dd0e
--- /dev/null
+++ b/docs/rules/checked-requires-onchange-or-readonly.md
@@ -0,0 +1,44 @@
+# Enforce using `onChange` or `readonly` attribute when `checked` is used (`react/checked-requires-onchange-or-readonly`)
+
+<!-- end auto-generated rule header -->
+
+This rule enforces `onChange` or `readonly` attribute for `checked` property of input elements.
+
+It also warns when `checked` and `defaultChecked` properties are used together.
+
+## Rule Details
+
+Example of **incorrect** code for this rule:
+
+```jsx
+<input type="checkbox" checked />
+<input type="checkbox" checked defaultChecked />
+<input type="radio" checked defaultChecked />
+
+React.createElement('input', { checked: false });
+React.createElement('input', { type: 'checkbox', checked: true });
+React.createElement('input', { type: 'checkbox', checked: true, defaultChecked: true });
+```
+
+Example of **correct** code for this rule:
+
+```jsx
+<input type="checkbox" checked onChange={() => {}} />
+<input type="checkbox" checked readOnly />
+<input type="checkbox" checked onChange readOnly />
+<input type="checkbox" defaultChecked />
+
+React.createElement('input', { type: 'checkbox', checked: true, onChange() {} });
+React.createElement('input', { type: 'checkbox', checked: true, readOnly: true });
+React.createElement('input', { type: 'checkbox', checked: true, onChange() {}, readOnly: true });
+React.createElement('input', { type: 'checkbox', defaultChecked: true });
+```
+
+## Rule Options
+
+```js
+"react/checked-requires-onchange-or-readonly": [<enabled>, {
+  "ignoreMissingProperties": <boolean>,
+  "ignoreExclusiveCheckedAttribute": <boolean>
+}]
+```
diff --git a/docs/rules/default-props-match-prop-types.md b/docs/rules/default-props-match-prop-types.md
index f5641c44aa..d8773046f2 100644
--- a/docs/rules/default-props-match-prop-types.md
+++ b/docs/rules/default-props-match-prop-types.md
@@ -196,7 +196,7 @@ If you don't care about stray `defaultsProps` in your components, you can disabl
 
 ## Resources
 
-- [Official React documentation on defaultProps](https://facebook.github.io/react/docs/typechecking-with-proptypes.html#default-prop-values)
+- [Official React documentation on defaultProps](https://legacy.reactjs.org/docs/typechecking-with-proptypes.html#default-prop-values)
 
 [PropTypes]: https://reactjs.org/docs/typechecking-with-proptypes.html
 [TypeScript]: https://www.typescriptlang.org/
diff --git a/docs/rules/forbid-component-props.md b/docs/rules/forbid-component-props.md
index 2d624be31c..209b6abba7 100644
--- a/docs/rules/forbid-component-props.md
+++ b/docs/rules/forbid-component-props.md
@@ -44,7 +44,7 @@ Examples of **correct** code for this rule:
 ### `forbid`
 
 An array specifying the names of props that are forbidden. The default value of this option is `['className', 'style']`.
-Each array element can either be a string with the property name or object specifying the property name, an optional
+Each array element can either be a string with the property name or object specifying the property name or glob string, an optional
 custom message, and a component allowlist:
 
 ```js
@@ -65,6 +65,55 @@ Use `disallowedFor` as an exclusion list to warn on props for specific component
 }
 ```
 
+For `propNamePattern` glob string patterns:
+
+```js
+{
+  "propNamePattern": '**-**',
+  "allowedFor": ['div'],
+  "message": "Avoid using kebab-case except div"
+}
+```
+
+```js
+{
+  "propNamePattern": '**-**',
+  "allowedForPatterns": ["*Component"],
+  "message": "Avoid using kebab-case except components that match the `*Component` pattern"
+}
+```
+
+Use `allowedForPatterns` for glob string patterns:
+
+```js
+{
+  "propName": "someProp",
+  "allowedForPatterns": ["*Component"],
+  "message": "Avoid using `someProp` except components that match the `*Component` pattern"
+}
+```
+
+Use `disallowedForPatterns` for glob string patterns:
+
+```js
+{
+  "propName": "someProp",
+  "disallowedForPatterns": ["*Component"],
+  "message": "Avoid using `someProp` for components that match the `*Component` pattern"
+}
+```
+
+Combine several properties to cover more cases:
+
+```js
+{
+  "propName": "someProp",
+  "allowedFor": ['div'],
+  "allowedForPatterns": ["*Component"],
+  "message": "Avoid using `someProp` except `div` and components that match the `*Component` pattern"
+}
+```
+
 ### Related rules
 
 - [forbid-dom-props](./forbid-dom-props.md)
diff --git a/docs/rules/forward-ref-uses-ref.md b/docs/rules/forward-ref-uses-ref.md
new file mode 100644
index 0000000000..68891a091b
--- /dev/null
+++ b/docs/rules/forward-ref-uses-ref.md
@@ -0,0 +1,45 @@
+# Require all forwardRef components include a ref parameter (`react/forward-ref-uses-ref`)
+
+💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+<!-- end auto-generated rule header -->
+
+Requires that components wrapped with `forwardRef` must have a `ref` parameter. Omitting the `ref` argument is usually a bug, and components not using `ref` don't need to be wrapped by `forwardRef`.
+
+See <https://react.dev/reference/react/forwardRef>
+
+## Rule Details
+
+This rule checks all React components using `forwardRef` and verifies that there is a second parameter.
+
+The following patterns are considered warnings:
+
+```jsx
+var React = require('react');
+
+var Component = React.forwardRef((props) => (
+    <div />
+));
+```
+
+The following patterns are **not** considered warnings:
+
+```jsx
+var React = require('react');
+
+var Component = React.forwardRef((props, ref) => (
+    <div ref={ref} />
+));
+
+var Component = React.forwardRef((props, ref) => (
+    <div />
+));
+
+function Component(props) {
+    return <div />;
+};
+```
+
+## When not to use
+
+If you don't want to enforce that components using `forwardRef` utilize the forwarded ref.
diff --git a/docs/rules/hook-use-state.md b/docs/rules/hook-use-state.md
index 838d86b607..3229d16bf4 100644
--- a/docs/rules/hook-use-state.md
+++ b/docs/rules/hook-use-state.md
@@ -1,6 +1,6 @@
 # Ensure destructuring and symmetric naming of useState hook value and setter variables (`react/hook-use-state`)
 
-💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
+💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
 <!-- end auto-generated rule header -->
 
@@ -27,7 +27,7 @@ export default function useColor() {
   // useState call is destructured into value + setter pair, but identifier
   // names do not follow the [thing, setThing] naming convention
   const [color, updateColor] = React.useState();
-  return useStateResult;
+  return [color, updateColor];
 }
 ```
 
diff --git a/docs/rules/iframe-missing-sandbox.md b/docs/rules/iframe-missing-sandbox.md
index 85e3931faa..1934e67b63 100644
--- a/docs/rules/iframe-missing-sandbox.md
+++ b/docs/rules/iframe-missing-sandbox.md
@@ -4,7 +4,7 @@
 
 The sandbox attribute enables an extra set of restrictions for the content in the iframe. Using sandbox attribute is considered a good security practice.
 
-See <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-sandbox>
+See <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox>
 
 ## Rule Details
 
diff --git a/docs/rules/jsx-boolean-value.md b/docs/rules/jsx-boolean-value.md
index 1a0c2bde17..6bebe31137 100644
--- a/docs/rules/jsx-boolean-value.md
+++ b/docs/rules/jsx-boolean-value.md
@@ -4,7 +4,7 @@
 
 <!-- end auto-generated rule header -->
 
-[When using a boolean attribute in JSX](https://facebook.github.io/react/docs/jsx-in-depth.html#boolean-attributes), you can set the attribute value to `true` or omit the value.
+When using a [boolean attribute in JSX](https://web.archive.org/web/20160607204033/http://facebook.github.io/react/docs/jsx-in-depth.html#boolean-attributes), you can set the attribute value to `true` or omit the value.
 
 ## Rule Details
 
diff --git a/docs/rules/jsx-closing-tag-location.md b/docs/rules/jsx-closing-tag-location.md
index c740fc27bc..8282982393 100644
--- a/docs/rules/jsx-closing-tag-location.md
+++ b/docs/rules/jsx-closing-tag-location.md
@@ -35,6 +35,82 @@ Examples of **correct** code for this rule:
 <Hello>marklar</Hello>
 ```
 
+## Rule Options
+
+There is one way to configure this rule.
+
+The configuration is a string shortcut corresponding to the `location` values specified below. If omitted, it defaults to `"tag-aligned"`.
+
+```js
+"react/jsx-closing-tag-location": <enabled> // -> [<enabled>, "tag-aligned"]
+"react/jsx-closing-tag-location": [<enabled>, "<location>"]
+```
+
+### `location`
+
+Enforced location for the closing tag.
+
+- `tag-aligned`: must be aligned with the opening tag.
+- `line-aligned`: must be aligned with the line containing the opening tag.
+
+Defaults to `tag-aligned`.
+
+For backward compatibility, you may pass an object `{ "location": <location> }` that is equivalent to the first string shortcut form.
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+// 'jsx-closing-tag-location': 1
+// 'jsx-closing-tag-location': [1, 'tag-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'tag-aligned'}]
+<Say
+  firstName="John"
+  lastName="Smith">
+  Hello
+  </Say>;
+
+// 'jsx-closing-tag-location': [1, 'tag-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'tag-aligned'}]
+const App = <Bar>
+  Foo
+</Bar>;
+
+
+// 'jsx-closing-tag-location': [1, 'line-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'line-aligned'}]
+const App = <Bar>
+  Foo
+            </Bar>;
+
+
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+// 'jsx-closing-tag-location': 1
+// 'jsx-closing-tag-location': [1, 'tag-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'tag-aligned'}]
+<Say
+  firstName="John"
+  lastName="Smith">
+  Hello
+</Say>;
+
+// 'jsx-closing-tag-location': [1, 'tag-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'tag-aligned'}]
+const App = <Bar>
+  Foo
+            </Bar>;
+
+// 'jsx-closing-tag-location': [1, 'line-aligned']
+// 'jsx-closing-tag-location': [1, {"location":'line-aligned'}]
+const App = <Bar>
+  Foo
+</Bar>;
+
+```
+
 ## When Not To Use It
 
 If you do not care about closing tag JSX alignment then you can disable this rule.
diff --git a/docs/rules/jsx-curly-brace-presence.md b/docs/rules/jsx-curly-brace-presence.md
index ddd296926a..30a00364db 100644
--- a/docs/rules/jsx-curly-brace-presence.md
+++ b/docs/rules/jsx-curly-brace-presence.md
@@ -6,7 +6,7 @@
 
 This rule allows you to enforce curly braces or disallow unnecessary curly braces in JSX props and/or children.
 
-For situations where JSX expressions are unnecessary, please refer to [the React doc](https://facebook.github.io/react/docs/jsx-in-depth.html) and [this page about JSX gotchas](https://github.com/facebook/react/blob/v15.4.0-rc.3/docs/docs/02.3-jsx-gotchas.md#html-entities).
+For situations where JSX expressions are unnecessary, please refer to [the React doc](https://legacy.reactjs.org/docs/jsx-in-depth.html) and [this page about JSX gotchas](https://github.com/facebook/react/blob/v15.4.0-rc.3/docs/docs/02.3-jsx-gotchas.md#html-entities).
 
 ## Rule Details
 
diff --git a/docs/rules/jsx-handler-names.md b/docs/rules/jsx-handler-names.md
index ced349f374..8e93a1679f 100644
--- a/docs/rules/jsx-handler-names.md
+++ b/docs/rules/jsx-handler-names.md
@@ -34,7 +34,8 @@ Examples of **correct** code for this rule:
   "eventHandlerPrefix": <eventHandlerPrefix>,
   "eventHandlerPropPrefix": <eventHandlerPropPrefix>,
   "checkLocalVariables": <boolean>,
-  "checkInlineFunction": <boolean>
+  "checkInlineFunction": <boolean>,
+  "ignoreComponentNames": Array<string>
 }]
 ...
 ```
@@ -43,6 +44,7 @@ Examples of **correct** code for this rule:
 - `eventHandlerPropPrefix`: Prefix for props that are used as event handlers. Defaults to `on`
 - `checkLocalVariables`: Determines whether event handlers stored as local variables are checked. Defaults to `false`
 - `checkInlineFunction`: Determines whether event handlers set as inline functions are checked. Defaults to `false`
+- `ignoreComponentNames`: Array of glob strings, when matched with component name, ignores the rule on that component. Defaults to `[]`
 
 ## When Not To Use It
 
diff --git a/docs/rules/jsx-no-bind.md b/docs/rules/jsx-no-bind.md
index 10141656a6..2becfef8a0 100644
--- a/docs/rules/jsx-no-bind.md
+++ b/docs/rules/jsx-no-bind.md
@@ -153,7 +153,7 @@ This will speed up rendering, as it avoids the need to create new functions (thr
 
 ### ES6 Classes
 
-Unfortunately [React ES6 classes](https://facebook.github.io/react/blog/2015/01/27/react-v0.13.0-beta-1.html#es6-classes) do not autobind their methods like components created with the older `createReactClass` syntax. There are several approaches to binding methods for ES6 classes. A basic approach is to just manually bind the methods in the constructor:
+Unfortunately [React ES6 classes](https://legacy.reactjs.org/blog/2015/01/27/react-v0.13.0-beta-1.html#es6-classes) do not autobind their methods like components created with the older `createReactClass` syntax. There are several approaches to binding methods for ES6 classes. A basic approach is to just manually bind the methods in the constructor:
 
 ```jsx
 class Foo extends React.Component {
@@ -174,7 +174,7 @@ class Foo extends React.Component {
 }
 ```
 
-A more sophisticated approach would be to use something like an [autobind ES7 decorator](https://www.npmjs.com/package/core-decorators#autobind) or [property initializers](https://facebook.github.io/react/blog/2015/01/27/react-v0.13.0-beta-1.html#autobinding).
+A more sophisticated approach would be to use something like an [autobind ES7 decorator](https://www.npmjs.com/package/core-decorators#autobind) or [property initializers](https://legacy.reactjs.org/blog/2015/01/27/react-v0.13.0-beta-1.html#autobinding).
 
 ### React Hooks
 
@@ -191,7 +191,7 @@ const Button = () => {
 };
 ```
 
-Otherwise, the idiomatic way to avoid redefining callbacks on every render would be to memoize them using the [`useCallback`](https://reactjs.org/docs/hooks-reference.html#usecallback) hook:
+Otherwise, the idiomatic way to avoid redefining callbacks on every render would be to memoize them using the [`useCallback`](https://legacy.reactjs.org/docs/hooks-reference.html#usecallback) hook:
 
 ```jsx
 const Button = () => {
diff --git a/docs/rules/jsx-no-constructed-context-values.md b/docs/rules/jsx-no-constructed-context-values.md
index aba9ac6254..fed69f5394 100644
--- a/docs/rules/jsx-no-constructed-context-values.md
+++ b/docs/rules/jsx-no-constructed-context-values.md
@@ -8,7 +8,7 @@ This rule prevents non-stable values (i.e. object identities) from being used as
 
 One way to resolve this issue may be to wrap the value in a `useMemo()`. If it's a function then `useCallback()` can be used as well.
 
-If you _expect_ the context to be rerun on each render, then consider adding a comment/lint supression explaining why.
+If you _expect_ the context to be rerun on each render, then consider adding a comment/lint suppression explaining why.
 
 ## Examples
 
@@ -22,6 +22,16 @@ return (
 )
 ```
 
+```jsx
+import React from 'react';
+
+const MyContext = React.createContext();
+function Component() {
+    function foo() {}
+    return (<MyContext value={foo}></MyContext>);
+}
+```
+
 Examples of **correct** code for this rule:
 
 ```jsx
@@ -33,6 +43,11 @@ return (
 )
 ```
 
+```jsx
+const SomeContext = createContext();
+const Component = () => <SomeContext value="Some string"><SomeContext>;
+```
+
 ## Legitimate Uses
 
 React Context, and all its child nodes and Consumers are rerendered whenever the value prop changes. Because each Javascript object carries its own _identity_, things like object expressions (`{foo: 'bar'}`) or function expressions get a new identity on every run through the component. This makes the context think it has gotten a new object and can cause needless rerenders and unintended consequences.
diff --git a/docs/rules/jsx-no-literals.md b/docs/rules/jsx-no-literals.md
index 1a69313951..0ff292cadc 100644
--- a/docs/rules/jsx-no-literals.md
+++ b/docs/rules/jsx-no-literals.md
@@ -34,6 +34,61 @@ The supported options are:
 - `allowedStrings` - An array of unique string values that would otherwise warn, but will be ignored.
 - `ignoreProps` (default: `false`) - When `true` the rule ignores literals used in props, wrapped or unwrapped.
 - `noAttributeStrings` (default: `false`) - Enforces no string literals used in attributes when set to `true`.
+- `elementOverrides` - An object where the keys are the element names and the values are objects with the same options as above. This allows you to specify different options for different elements.
+
+### `elementOverrides`
+
+The `elementOverrides` option allows you to specify different options for different elements. This is useful when you want to enforce different rules for different elements. For example, you may want to allow string literals in `Button` elements, but not in the rest of your application.
+
+The element name only accepts component names.
+HTML element tag names are not supported. Component names are case-sensitive and should exactly match the name of the component as it is used in the JSX.
+It can also be the name of a compound component (ie. `Modal.Button`).
+
+Specifying options creates a new context for the rule, so the rule will only apply the new options to the specified element and its children (if `applyToNestedElements` is `true` - see below).
+This means that the root rule options will not apply to the specified element.
+
+In addition to the options above (`noStrings`, `allowedStrings`, `noAttributeStrings` and `ignoreProps`), you can also specify the the following options that are specific to `elementOverrides`:
+
+- `allowElement` (default: `false`) - When `true` the rule will allow the specified element to have string literals as children, wrapped or unwrapped without warning.
+- `applyToNestedElements` (default: `true`) - When `false` the rule will not apply the current options set to nested elements. This is useful when you want to apply the rule to a specific element, but not to its children.
+
+**Note**: As this rule has no way of differentiating between different componets with the same name, it is recommended to use this option with specific components that are unique to your application.
+
+#### `elementOverrides` Examples
+
+The following are **correct** examples that demonstrate how to use the `elementOverrides` option:
+
+```js
+// "react/jsx-no-literals": [<enabled>, {"elementOverrides": { "Button": {"allowElement": true} }}]
+
+var Hello = <div>{'test'}</div>;
+var World = <Button>test</Button>;
+```
+
+```js
+// "react/jsx-no-literals": [<enabled>, {"elementOverrides": { "Text": {"allowElement": true} }}]
+
+var World = <Text>Hello <a href="a">world</a></Text>;
+```
+
+```js
+// "react/jsx-no-literals": [<enabled>, {"elementOverrides": { "Text": {"allowElement": true, "applyToNestedElements": false} }}]
+
+var linkText = 'world';
+var World = <Text>Hello <a href="a">{linkText}</a></Text>;
+```
+
+```js
+// "react/jsx-no-literals": [<enabled>, {"noStrings": true, "elementOverrides": { "Button": {"noStrings": false} }}]
+// OR
+// "react/jsx-no-literals": [<enabled>, {"noStrings": true, "elementOverrides": { "Button": {} }}]
+
+var test = 'test'
+var Hello = <div>{test}</div>;
+var World = <Button>{'test'}</Button>;
+```
+
+## Examples
 
 To use, you can specify as follows:
 
diff --git a/docs/rules/jsx-props-no-spread-multi.md b/docs/rules/jsx-props-no-spread-multi.md
new file mode 100644
index 0000000000..bc3a8bc148
--- /dev/null
+++ b/docs/rules/jsx-props-no-spread-multi.md
@@ -0,0 +1,26 @@
+# Disallow JSX prop spreading the same identifier multiple times (`react/jsx-props-no-spread-multi`)
+
+<!-- end auto-generated rule header -->
+
+Enforces that any unique expression is only spread once.
+Generally spreading the same expression twice is an indicator of a mistake since any attribute between the spreads may be overridden when the intent was not to.
+Even when that is not the case this will lead to unnecessary computations being performed.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+<App {...props} myAttr="1" {...props} />
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+<App myAttr="1" {...props} />
+<App {...props} myAttr="1" />
+```
+
+## When Not To Use It
+
+When spreading the same expression multiple times yields different results.
diff --git a/docs/rules/no-array-index-key.md b/docs/rules/no-array-index-key.md
index 37f2652d93..4fc4f928ad 100644
--- a/docs/rules/no-array-index-key.md
+++ b/docs/rules/no-array-index-key.md
@@ -4,7 +4,7 @@
 
 Warn if an element uses an Array index in its `key`.
 
-The `key` is used by React to [identify which items have changed, are added, or are removed and should be stable](https://facebook.github.io/react/docs/lists-and-keys.html#keys).
+The `key` is used by React to [identify which items have changed, are added, or are removed and should be stable](https://react.dev/learn/rendering-lists#why-does-react-need-keys).
 
 It's a bad idea to use the array index since it doesn't uniquely identify your elements. In cases where the array is sorted or an element is added to the beginning of the array, the index will be changed even though the element representing that index may be the same. This results in unnecessary renders.
 
diff --git a/docs/rules/no-danger.md b/docs/rules/no-danger.md
index 417989e0b2..8858f13875 100644
--- a/docs/rules/no-danger.md
+++ b/docs/rules/no-danger.md
@@ -2,9 +2,9 @@
 
 <!-- end auto-generated rule header -->
 
-Dangerous properties in React are those whose behavior is known to be a common source of application vulnerabilities. The properties names clearly indicate they are dangerous and should be avoided unless great care is taken.
+Dangerous properties in React are those whose behavior is known to be a common source of application vulnerabilities. The properties' names clearly indicate they are dangerous and should be avoided unless great care is taken.
 
-See <https://facebook.github.io/react/tips/dangerously-set-inner-html.html>
+See <https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html>
 
 ## Rule Details
 
@@ -24,6 +24,20 @@ var React = require('react');
 var Hello = <div>Hello World</div>;
 ```
 
+## Rule Options
+
+```js
+...
+"react/no-danger": [<enabled>, {
+  "customComponentNames": Array<string>,
+}]
+...
+```
+
+### customComponentNames
+
+Defaults to `[]`, if you want to enable this rule for all custom components you can pass `customComponentNames` as `['*']`, or else you can pass specific components name to the array.
+
 ## When Not To Use It
 
 If you are certain the content passed to dangerouslySetInnerHTML is sanitized HTML you can disable this rule.
diff --git a/docs/rules/no-invalid-html-attribute.md b/docs/rules/no-invalid-html-attribute.md
index d749ead037..9f251ca9ae 100644
--- a/docs/rules/no-invalid-html-attribute.md
+++ b/docs/rules/no-invalid-html-attribute.md
@@ -1,6 +1,6 @@
 # Disallow usage of invalid attributes (`react/no-invalid-html-attribute`)
 
-💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
+💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
 <!-- end auto-generated rule header -->
 
diff --git a/docs/rules/no-is-mounted.md b/docs/rules/no-is-mounted.md
index e38be740bc..ce06311545 100644
--- a/docs/rules/no-is-mounted.md
+++ b/docs/rules/no-is-mounted.md
@@ -6,7 +6,7 @@
 
 [`isMounted` is an anti-pattern][anti-pattern], is not available when using ES6 classes, and it is on its way to being officially deprecated.
 
-[anti-pattern]: https://facebook.github.io/react/blog/2015/12/16/ismounted-antipattern.html
+[anti-pattern]: https://legacy.reactjs.org/blog/2015/12/16/ismounted-antipattern.html
 
 ## Rule Details
 
diff --git a/docs/rules/no-render-return-value.md b/docs/rules/no-render-return-value.md
index 2042ba9f57..1859f75231 100644
--- a/docs/rules/no-render-return-value.md
+++ b/docs/rules/no-render-return-value.md
@@ -4,9 +4,9 @@
 
 <!-- end auto-generated rule header -->
 
-> `ReactDOM.render()` currently returns a reference to the root `ReactComponent` instance. However, using this return value is legacy and should be avoided because future versions of React may render components asynchronously in some cases. If you need a reference to the root `ReactComponent` instance, the preferred solution is to attach a [callback ref](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs) to the root element.
+> `ReactDOM.render()` currently returns a reference to the root `ReactComponent` instance. However, using this return value is legacy and should be avoided because future versions of React may render components asynchronously in some cases. If you need a reference to the root `ReactComponent` instance, the preferred solution is to attach a [callback ref](https://legacy.reactjs.org/docs/refs-and-the-dom.html#callback-refs) to the root element.
 
-Source: [ReactDOM documentation](https://facebook.github.io/react/docs/react-dom.html#render)
+Source: [ReactDOM documentation](https://legacy.reactjs.org/docs/react-dom.html#render)
 
 ## Rule Details
 
diff --git a/docs/rules/no-unescaped-entities.md b/docs/rules/no-unescaped-entities.md
index 2f6f8906b6..7146bc484c 100644
--- a/docs/rules/no-unescaped-entities.md
+++ b/docs/rules/no-unescaped-entities.md
@@ -2,6 +2,8 @@
 
 💼 This rule is enabled in the ☑️ `recommended` [config](https://github.com/jsx-eslint/eslint-plugin-react/#shareable-configs).
 
+💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
 <!-- end auto-generated rule header -->
 
 This rule prevents characters that you may have meant as JSX escape characters
diff --git a/docs/rules/no-unstable-nested-components.md b/docs/rules/no-unstable-nested-components.md
index 8117636805..45fa214ef4 100644
--- a/docs/rules/no-unstable-nested-components.md
+++ b/docs/rules/no-unstable-nested-components.md
@@ -125,6 +125,7 @@ function Component() {
   {
     "allowAsProps": true | false,
     "customValidators": [] /* optional array of validators used for propTypes validation */
+    "propNamePattern": string
   }
 ]
 ...
@@ -148,6 +149,16 @@ function Component() {
 }
 ```
 
+You can allow other render prop naming conventions by setting the `propNamePattern` option. By default this option is `"render*"`.
+
+For example, if `propNamePattern` is set to `"*Renderer"` the following pattern is **not** considered warnings:
+
+```jsx
+<Table
+  rowRenderer={(rowData) => <Row data={rowData} />}
+/>
+```
+
 ## When Not To Use It
 
 If you are not interested in preventing bugs related to re-creation of the nested components or do not care about optimization of virtual DOM.
diff --git a/docs/rules/require-default-props.md b/docs/rules/require-default-props.md
index f083aaf7ff..ea4e69e086 100644
--- a/docs/rules/require-default-props.md
+++ b/docs/rules/require-default-props.md
@@ -476,7 +476,7 @@ If you don't care about using `defaultProps` for your component's props that are
 
 ## Resources
 
-- [Official React documentation on defaultProps](https://facebook.github.io/react/docs/typechecking-with-proptypes.html#default-prop-values)
+- [Official React documentation on defaultProps](https://legacy.reactjs.org/docs/typechecking-with-proptypes.html#default-prop-values)
 
 [PropTypes]: https://reactjs.org/docs/typechecking-with-proptypes.html
 [TypeScript]: https://www.typescriptlang.org/
diff --git a/index.js b/index.js
index 4140c6c881..64ff9bbdc4 100644
--- a/index.js
+++ b/index.js
@@ -1,31 +1,125 @@
 'use strict';
 
-const configAll = require('./configs/all');
-const configRecommended = require('./configs/recommended');
-const configRuntime = require('./configs/jsx-runtime');
+const fromEntries = require('object.fromentries');
+const entries = require('object.entries');
 
 const allRules = require('./lib/rules');
 
+function filterRules(rules, predicate) {
+  return fromEntries(entries(rules).filter((entry) => predicate(entry[1])));
+}
+
+/**
+ * @param {object} rules - rules object mapping rule name to rule module
+ * @returns {Record<string, SEVERITY_ERROR | 'error'>}
+ */
+function configureAsError(rules) {
+  return fromEntries(Object.keys(rules).map((key) => [`react/${key}`, 2]));
+}
+
+/** @type {Partial<typeof allRules>} */
+const activeRules = filterRules(allRules, (rule) => !rule.meta.deprecated);
+/** @type {Record<keyof typeof activeRules, 2 | 'error'>} */
+const activeRulesConfig = configureAsError(activeRules);
+
+/** @type {Partial<typeof allRules>} */
+const deprecatedRules = filterRules(allRules, (rule) => rule.meta.deprecated);
+
+/** @type {['react']} */
 // for legacy config system
 const plugins = [
   'react',
 ];
 
-module.exports = {
-  deprecatedRules: configAll.plugins.react.deprecatedRules,
-  rules: allRules,
-  configs: {
-    recommended: Object.assign({}, configRecommended, {
-      parserOptions: configRecommended.languageOptions.parserOptions,
-      plugins,
-    }),
-    all: Object.assign({}, configAll, {
-      parserOptions: configAll.languageOptions.parserOptions,
-      plugins,
-    }),
-    'jsx-runtime': Object.assign({}, configRuntime, {
-      parserOptions: configRuntime.languageOptions.parserOptions,
-      plugins,
-    }),
+// TODO: with TS 4.5+, inline this
+const SEVERITY_ERROR = /** @type {2} */ (2);
+const SEVERITY_OFF = /** @type {0} */ (0);
+
+const configs = {
+  recommended: {
+    plugins,
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+    rules: {
+      'react/display-name': SEVERITY_ERROR,
+      'react/jsx-key': SEVERITY_ERROR,
+      'react/jsx-no-comment-textnodes': SEVERITY_ERROR,
+      'react/jsx-no-duplicate-props': SEVERITY_ERROR,
+      'react/jsx-no-target-blank': SEVERITY_ERROR,
+      'react/jsx-no-undef': SEVERITY_ERROR,
+      'react/jsx-uses-react': SEVERITY_ERROR,
+      'react/jsx-uses-vars': SEVERITY_ERROR,
+      'react/no-children-prop': SEVERITY_ERROR,
+      'react/no-danger-with-children': SEVERITY_ERROR,
+      'react/no-deprecated': SEVERITY_ERROR,
+      'react/no-direct-mutation-state': SEVERITY_ERROR,
+      'react/no-find-dom-node': SEVERITY_ERROR,
+      'react/no-is-mounted': SEVERITY_ERROR,
+      'react/no-render-return-value': SEVERITY_ERROR,
+      'react/no-string-refs': SEVERITY_ERROR,
+      'react/no-unescaped-entities': SEVERITY_ERROR,
+      'react/no-unknown-property': SEVERITY_ERROR,
+      'react/no-unsafe': SEVERITY_OFF,
+      'react/prop-types': SEVERITY_ERROR,
+      'react/react-in-jsx-scope': SEVERITY_ERROR,
+      'react/require-render-return': SEVERITY_ERROR,
+    },
+  },
+  all: {
+    plugins,
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+    rules: activeRulesConfig,
   },
+  'jsx-runtime': {
+    plugins,
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+      jsxPragma: null, // for @typescript/eslint-parser
+    },
+    rules: {
+      'react/react-in-jsx-scope': SEVERITY_OFF,
+      'react/jsx-uses-react': SEVERITY_OFF,
+    },
+  },
+  flat: /** @type {Record<string, ReactFlatConfig>} */ ({
+    __proto__: null,
+  }),
 };
+
+/** @typedef {{ plugins: { react: typeof plugin }, rules: import('eslint').Linter.RulesRecord, languageOptions: { parserOptions: import('eslint').Linter.ParserOptions } }} ReactFlatConfig */
+
+/** @type {{ deprecatedRules: typeof deprecatedRules, rules: typeof allRules, configs: typeof configs & { flat: Record<string, ReactFlatConfig> }}} */
+const plugin = {
+  deprecatedRules,
+  rules: allRules,
+  configs,
+};
+
+Object.assign(configs.flat, {
+  recommended: {
+    plugins: { react: plugin },
+    rules: configs.recommended.rules,
+    languageOptions: { parserOptions: configs.recommended.parserOptions },
+  },
+  all: {
+    plugins: { react: plugin },
+    rules: configs.all.rules,
+    languageOptions: { parserOptions: configs.all.parserOptions },
+  },
+  'jsx-runtime': {
+    plugins: { react: plugin },
+    rules: configs['jsx-runtime'].rules,
+    languageOptions: { parserOptions: configs['jsx-runtime'].parserOptions },
+  },
+});
+
+module.exports = plugin;
diff --git a/lib/rules/boolean-prop-naming.js b/lib/rules/boolean-prop-naming.js
index b5dd37b529..afa844a903 100644
--- a/lib/rules/boolean-prop-naming.js
+++ b/lib/rules/boolean-prop-naming.js
@@ -5,22 +5,41 @@
 
 'use strict';
 
+const flatMap = require('array.prototype.flatmap');
 const values = require('object.values');
 
 const Components = require('../util/Components');
 const propsUtil = require('../util/props');
+const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 const propWrapperUtil = require('../util/propWrapper');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
+
+/**
+ * Checks if prop is nested
+ * @param {Object} prop Property object, single prop type declaration
+ * @returns {boolean}
+ */
+function nestedPropTypes(prop) {
+  return (
+    prop.type === 'Property'
+    && astUtil.isCallExpression(prop.value)
+  );
+}
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 const messages = {
-  patternMismatch: 'Prop name ({{propName}}) doesn\'t match rule ({{pattern}})',
+  patternMismatch: 'Prop name `{{propName}}` doesn’t match rule `{{pattern}}`',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -113,7 +132,7 @@ module.exports = {
       // we can't get the name of the Flow object key name. So we have
       // to hack around it for now.
       if (node.type === 'ObjectTypeProperty') {
-        return context.getSourceCode().getFirstToken(node).value;
+        return getSourceCode(context).getFirstToken(node).value;
       }
 
       return node.key.name;
@@ -122,7 +141,7 @@ module.exports = {
     /**
      * Checks if prop is declared in flow way
      * @param {Object} prop Property object, single prop type declaration
-     * @returns {Boolean}
+     * @returns {boolean}
      */
     function flowCheck(prop) {
       return (
@@ -135,7 +154,7 @@ module.exports = {
     /**
      * Checks if prop is declared in regular way
      * @param {Object} prop Property object, single prop type declaration
-     * @returns {Boolean}
+     * @returns {boolean}
      */
     function regularCheck(prop) {
       const propKey = getPropKey(prop);
@@ -156,33 +175,23 @@ module.exports = {
       );
     }
 
-    /**
-     * Checks if prop is nested
-     * @param {Object} prop Property object, single prop type declaration
-     * @returns {Boolean}
-     */
-    function nestedPropTypes(prop) {
-      return (
-        prop.type === 'Property'
-        && prop.value.type === 'CallExpression'
-      );
-    }
-
     /**
      * Runs recursive check on all proptypes
      * @param {Array} proptypes A list of Property object (for each proptype defined)
      * @param {Function} addInvalidProp callback to run for each error
      */
     function runCheck(proptypes, addInvalidProp) {
-      (proptypes || []).forEach((prop) => {
-        if (config.validateNested && nestedPropTypes(prop)) {
-          runCheck(prop.value.arguments[0].properties, addInvalidProp);
-          return;
-        }
-        if (flowCheck(prop) || regularCheck(prop) || tsCheck(prop)) {
-          addInvalidProp(prop);
-        }
-      });
+      if (proptypes) {
+        proptypes.forEach((prop) => {
+          if (config.validateNested && nestedPropTypes(prop)) {
+            runCheck(prop.value.arguments[0].properties, addInvalidProp);
+            return;
+          }
+          if (flowCheck(prop) || regularCheck(prop) || tsCheck(prop)) {
+            addInvalidProp(prop);
+          }
+        });
+      }
     }
 
     /**
@@ -250,21 +259,23 @@ module.exports = {
         return;
       }
 
-      const annotationTypeParams = component.node.parent.id.typeAnnotation.typeAnnotation.typeParameters;
+      const annotationTypeArguments = propsUtil.getTypeArguments(
+        component.node.parent.id.typeAnnotation.typeAnnotation
+      );
       if (
-        annotationTypeParams && (
-          annotationTypeParams.type === 'TSTypeParameterInstantiation'
-          || annotationTypeParams.type === 'TypeParameterInstantiation'
+        annotationTypeArguments && (
+          annotationTypeArguments.type === 'TSTypeParameterInstantiation'
+          || annotationTypeArguments.type === 'TypeParameterInstantiation'
         )
       ) {
-        return annotationTypeParams.params.find(
+        return annotationTypeArguments.params.find(
           (param) => param.type === 'TSTypeReference' || param.type === 'GenericTypeAnnotation'
         );
       }
     }
 
     function findAllTypeAnnotations(identifier, node) {
-      if (node.type === 'TSTypeLiteral' || node.type === 'ObjectTypeAnnotation') {
+      if (node.type === 'TSTypeLiteral' || node.type === 'ObjectTypeAnnotation' || node.type === 'TSInterfaceBody') {
         const currentNode = [].concat(
           objectTypeAnnotations.get(identifier.name) || [],
           node
@@ -303,10 +314,10 @@ module.exports = {
         }
         if (
           node.value
-          && node.value.type === 'CallExpression'
+          && astUtil.isCallExpression(node.value)
           && propWrapperUtil.isPropWrapperFunction(
             context,
-            context.getSourceCode().getText(node.value.callee)
+            getText(context, node.value.callee)
           )
         ) {
           checkPropWrapperArguments(node, node.value.arguments);
@@ -329,10 +340,10 @@ module.exports = {
         }
         const right = node.parent.right;
         if (
-          right.type === 'CallExpression'
+          astUtil.isCallExpression(right)
           && propWrapperUtil.isPropWrapperFunction(
             context,
-            context.getSourceCode().getText(right.callee)
+            getText(context, right.callee)
           )
         ) {
           checkPropWrapperArguments(component.node, right.arguments);
@@ -363,6 +374,10 @@ module.exports = {
         findAllTypeAnnotations(node.id, node.typeAnnotation);
       },
 
+      TSInterfaceDeclaration(node) {
+        findAllTypeAnnotations(node.id, node.body);
+      },
+
       // eslint-disable-next-line object-shorthand
       'Program:exit'() {
         if (!rule) {
@@ -376,17 +391,23 @@ module.exports = {
             let propType;
             if (annotation.type === 'GenericTypeAnnotation') {
               propType = objectTypeAnnotations.get(annotation.id.name);
-            } else if (annotation.type === 'ObjectTypeAnnotation') {
+            } else if (annotation.type === 'ObjectTypeAnnotation' || annotation.type === 'TSTypeLiteral') {
               propType = annotation;
             } else if (annotation.type === 'TSTypeReference') {
               propType = objectTypeAnnotations.get(annotation.typeName.name);
+            } else if (annotation.type === 'TSIntersectionType') {
+              propType = flatMap(annotation.types, (type) => (
+                type.type === 'TSTypeReference'
+                  ? objectTypeAnnotations.get(type.typeName.name)
+                  : type
+              ));
             }
 
             if (propType) {
-              [].concat(propType).forEach((prop) => {
+              [].concat(propType).filter(Boolean).forEach((prop) => {
                 validatePropNaming(
                   component.node,
-                  prop.properties || prop.members
+                  prop.properties || prop.members || prop.body
                 );
               });
             }
diff --git a/lib/rules/button-has-type.js b/lib/rules/button-has-type.js
index 204a33c43e..a6fd41cbfe 100644
--- a/lib/rules/button-has-type.js
+++ b/lib/rules/button-has-type.js
@@ -28,6 +28,7 @@ const messages = {
   forbiddenValue: '"{{value}}" is an invalid value for button type attribute',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -135,7 +136,7 @@ module.exports = {
         checkValue(node, propValue);
       },
       CallExpression(node) {
-        if (!isCreateElement(node, context) || node.arguments.length < 1) {
+        if (!isCreateElement(context, node) || node.arguments.length < 1) {
           return;
         }
 
@@ -149,14 +150,19 @@ module.exports = {
         }
 
         const props = node.arguments[1].properties;
-        const typeProp = props.find((prop) => prop.key && prop.key.name === 'type');
+        const typeProp = props.find((prop) => (
+          'key' in prop
+          && prop.key
+          && 'name' in prop.key
+          && prop.key.name === 'type'
+        ));
 
         if (!typeProp) {
           reportMissing(node);
           return;
         }
 
-        checkExpression(node, typeProp.value);
+        checkExpression(node, 'value' in typeProp ? typeProp.value : undefined);
       },
     };
   },
diff --git a/lib/rules/checked-requires-onchange-or-readonly.js b/lib/rules/checked-requires-onchange-or-readonly.js
new file mode 100644
index 0000000000..d67449ea51
--- /dev/null
+++ b/lib/rules/checked-requires-onchange-or-readonly.js
@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Enforce the use of the 'onChange' or 'readonly' attribute when 'checked' is used'
+ * @author Jaesoekjjang
+ */
+
+'use strict';
+
+const ASTUtils = require('jsx-ast-utils');
+const flatMap = require('array.prototype.flatmap');
+const isCreateElement = require('../util/isCreateElement');
+const report = require('../util/report');
+const docsUrl = require('../util/docsUrl');
+
+const messages = {
+  missingProperty: '`checked` should be used with either `onChange` or `readOnly`.',
+  exclusiveCheckedAttribute: 'Use either `checked` or `defaultChecked`, but not both.',
+};
+
+const targetPropSet = new Set(['checked', 'onChange', 'readOnly', 'defaultChecked']);
+
+const defaultOptions = {
+  ignoreMissingProperties: false,
+  ignoreExclusiveCheckedAttribute: false,
+};
+
+/**
+ * @param {object[]} properties
+ * @param {string} keyName
+ * @returns {Set<string>}
+ */
+function extractTargetProps(properties, keyName) {
+  return new Set(
+    flatMap(
+      properties,
+      (prop) => (
+        prop[keyName] && targetPropSet.has(prop[keyName].name)
+          ? [prop[keyName].name]
+          : []
+      )
+    )
+  );
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Enforce using `onChange` or `readonly` attribute when `checked` is used',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('checked-requires-onchange-or-readonly'),
+    },
+    messages,
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        ignoreMissingProperties: {
+          type: 'boolean',
+        },
+        ignoreExclusiveCheckedAttribute: {
+          type: 'boolean',
+        },
+      },
+    }],
+  },
+  create(context) {
+    const options = Object.assign({}, defaultOptions, context.options[0]);
+
+    function reportMissingProperty(node) {
+      report(
+        context,
+        messages.missingProperty,
+        'missingProperty',
+        { node }
+      );
+    }
+
+    function reportExclusiveCheckedAttribute(node) {
+      report(
+        context,
+        messages.exclusiveCheckedAttribute,
+        'exclusiveCheckedAttribute',
+        { node }
+      );
+    }
+
+    /**
+     * @param {ASTNode} node
+     * @param {Set<string>} propSet
+     * @returns {void}
+     */
+    const checkAttributesAndReport = (node, propSet) => {
+      if (!propSet.has('checked')) {
+        return;
+      }
+
+      if (!options.ignoreExclusiveCheckedAttribute && propSet.has('defaultChecked')) {
+        reportExclusiveCheckedAttribute(node);
+      }
+
+      if (
+        !options.ignoreMissingProperties
+        && !(propSet.has('onChange') || propSet.has('readOnly'))
+      ) {
+        reportMissingProperty(node);
+      }
+    };
+
+    return {
+      JSXOpeningElement(node) {
+        if (ASTUtils.elementType(node) !== 'input') {
+          return;
+        }
+
+        const propSet = extractTargetProps(node.attributes, 'name');
+        checkAttributesAndReport(node, propSet);
+      },
+      CallExpression(node) {
+        if (!isCreateElement(context, node)) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+        const secondArg = node.arguments[1];
+        if (
+          !firstArg
+          || firstArg.type !== 'Literal'
+          || firstArg.value !== 'input'
+        ) {
+          return;
+        }
+
+        if (!secondArg || secondArg.type !== 'ObjectExpression') {
+          return;
+        }
+
+        const propSet = extractTargetProps(secondArg.properties, 'key');
+        checkAttributesAndReport(node, propSet);
+      },
+    };
+  },
+};
diff --git a/lib/rules/default-props-match-prop-types.js b/lib/rules/default-props-match-prop-types.js
index ba3db9328d..95b341650a 100644
--- a/lib/rules/default-props-match-prop-types.js
+++ b/lib/rules/default-props-match-prop-types.js
@@ -21,6 +21,7 @@ const messages = {
   defaultHasNoType: 'defaultProp "{{name}}" has no corresponding propTypes declaration.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/destructuring-assignment.js b/lib/rules/destructuring-assignment.js
index e4abdaede9..6e254f772f 100644
--- a/lib/rules/destructuring-assignment.js
+++ b/lib/rules/destructuring-assignment.js
@@ -6,9 +6,13 @@
 
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const isAssignmentLHS = require('../util/ast').isAssignmentLHS;
 const report = require('../util/report');
 
+const getScope = eslintUtil.getScope;
+const getText = eslintUtil.getText;
+
 const DEFAULT_OPTION = 'always';
 
 function createSFCParams() {
@@ -53,6 +57,7 @@ const messages = {
   destructureInSignature: 'Must destructure props in the function signature.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -101,7 +106,7 @@ module.exports = {
     function handleStatelessComponent(node) {
       const params = evalParams(node.params);
 
-      const SFCComponent = components.get(context.getScope(node).block);
+      const SFCComponent = components.get(getScope(context, node).block);
       if (!SFCComponent) {
         return;
       }
@@ -119,7 +124,7 @@ module.exports = {
     }
 
     function handleStatelessComponentExit(node) {
-      const SFCComponent = components.get(context.getScope(node).block);
+      const SFCComponent = components.get(getScope(context, node).block);
       if (SFCComponent) {
         sfcParams.pop();
       }
@@ -176,6 +181,25 @@ module.exports = {
       }
     }
 
+    // valid-jsdoc cannot read function types
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * Find a parent that satisfy the given predicate
+     * @param {ASTNode} node
+     * @param {(node: ASTNode) => boolean} predicate
+     * @returns {ASTNode | undefined}
+     */
+    function findParent(node, predicate) {
+      let n = node;
+      while (n) {
+        if (predicate(n)) {
+          return n;
+        }
+        n = n.parent;
+      }
+      return undefined;
+    }
+
     return {
 
       FunctionDeclaration: handleStatelessComponent,
@@ -191,12 +215,7 @@ module.exports = {
       'FunctionExpression:exit': handleStatelessComponentExit,
 
       MemberExpression(node) {
-        let scope = context.getScope(node);
-        let SFCComponent = components.get(scope.block);
-        while (!SFCComponent && scope.upper && scope.upper !== scope) {
-          SFCComponent = components.get(scope.upper.block);
-          scope = scope.upper;
-        }
+        const SFCComponent = utils.getParentStatelessComponent(node);
         if (SFCComponent) {
           handleSFCUsage(node);
         }
@@ -207,9 +226,28 @@ module.exports = {
         }
       },
 
+      TSQualifiedName(node) {
+        if (configuration !== 'always') {
+          return;
+        }
+        // handle `typeof props.a.b`
+        if (node.left.type === 'Identifier'
+          && node.left.name === sfcParams.propsName()
+          && findParent(node, (n) => n.type === 'TSTypeQuery')
+          && utils.getParentStatelessComponent(node)
+        ) {
+          report(context, messages.useDestructAssignment, 'useDestructAssignment', {
+            node,
+            data: {
+              type: 'props',
+            },
+          });
+        }
+      },
+
       VariableDeclarator(node) {
         const classComponent = utils.getParentComponent(node);
-        const SFCComponent = components.get(context.getScope(node).block);
+        const SFCComponent = components.get(getScope(context, node).block);
 
         const destructuring = (node.init && node.id && node.id.type === 'ObjectPattern');
         // let {foo} = props;
@@ -247,11 +285,12 @@ module.exports = {
           && destructureInSignature === 'always'
           && node.init.name === 'props'
         ) {
-          const scopeSetProps = context.getScope().set.get('props');
+          const scopeSetProps = getScope(context, node).set.get('props');
           const propsRefs = scopeSetProps && scopeSetProps.references;
           if (!propsRefs) {
             return;
           }
+
           // Skip if props is used elsewhere
           if (propsRefs.length > 1) {
             return;
@@ -268,7 +307,7 @@ module.exports = {
                 param.typeAnnotation ? param.typeAnnotation.range[0] : param.range[1],
               ];
               return [
-                fixer.replaceTextRange(replaceRange, context.getSourceCode().getText(node.id)),
+                fixer.replaceTextRange(replaceRange, getText(context, node.id)),
                 fixer.remove(node.parent),
               ];
             },
diff --git a/lib/rules/display-name.js b/lib/rules/display-name.js
index be0e2985b3..b85ec34f1c 100644
--- a/lib/rules/display-name.js
+++ b/lib/rules/display-name.js
@@ -27,6 +27,7 @@ const messages = {
   noContextDisplayName: 'Context definition is missing display name',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -72,12 +73,13 @@ module.exports = {
     /**
      * Checks if React.forwardRef is nested inside React.memo
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if React.forwardRef is nested inside React.memo, false if not.
+     * @returns {boolean} True if React.forwardRef is nested inside React.memo, false if not.
      */
     function isNestedMemo(node) {
-      const argumentIsCallExpression = node.arguments && node.arguments[0] && node.arguments[0].type === 'CallExpression';
-
-      return node.type === 'CallExpression' && argumentIsCallExpression && utils.isPragmaComponentWrapper(node);
+      return astUtil.isCallExpression(node)
+        && node.arguments
+        && astUtil.isCallExpression(node.arguments[0])
+        && utils.isPragmaComponentWrapper(node);
     }
 
     /**
@@ -110,7 +112,7 @@ module.exports = {
     /**
      * Checks if the component have a name set by the transpiler
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if component has a name, false if not.
+     * @returns {boolean} True if component has a name, false if not.
      */
     function hasTranspilerName(node) {
       const namedObjectAssignment = (
@@ -197,7 +199,7 @@ module.exports = {
         if (!component) {
           return;
         }
-        markDisplayNameAsDeclared(component.node.type === 'TSAsExpression' ? component.node.expression : component.node);
+        markDisplayNameAsDeclared(astUtil.unwrapTSAsExpression(component.node));
       },
 
       'FunctionExpression, FunctionDeclaration, ArrowFunctionExpression'(node) {
@@ -246,7 +248,7 @@ module.exports = {
         }
 
         if (node.arguments.length > 0 && astUtil.isFunctionLikeExpression(node.arguments[0])) {
-          // Skip over React.forwardRef declarations that are embeded within
+          // Skip over React.forwardRef declarations that are embedded within
           // a React.memo i.e. React.memo(React.forwardRef(/* ... */))
           // This means that we raise a single error for the call to React.memo
           // instead of one for React.memo and one for React.forwardRef
diff --git a/lib/rules/forbid-component-props.js b/lib/rules/forbid-component-props.js
index cca553e123..2dd4412b87 100644
--- a/lib/rules/forbid-component-props.js
+++ b/lib/rules/forbid-component-props.js
@@ -5,6 +5,7 @@
 
 'use strict';
 
+const minimatch = require('minimatch');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
 
@@ -22,6 +23,7 @@ const messages = {
   propIsForbidden: 'Prop "{{prop}}" is forbidden on Components',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -50,6 +52,11 @@ module.exports = {
                     uniqueItems: true,
                     items: { type: 'string' },
                   },
+                  allowedForPatterns: {
+                    type: 'array',
+                    uniqueItems: true,
+                    items: { type: 'string' },
+                  },
                   message: { type: 'string' },
                 },
                 additionalProperties: false,
@@ -64,9 +71,60 @@ module.exports = {
                     minItems: 1,
                     items: { type: 'string' },
                   },
+                  disallowedForPatterns: {
+                    type: 'array',
+                    uniqueItems: true,
+                    minItems: 1,
+                    items: { type: 'string' },
+                  },
+                  message: { type: 'string' },
+                },
+                anyOf: [
+                  { required: ['disallowedFor'] },
+                  { required: ['disallowedForPatterns'] },
+                ],
+                additionalProperties: false,
+              },
+              {
+                type: 'object',
+                properties: {
+                  propNamePattern: { type: 'string' },
+                  allowedFor: {
+                    type: 'array',
+                    uniqueItems: true,
+                    items: { type: 'string' },
+                  },
+                  allowedForPatterns: {
+                    type: 'array',
+                    uniqueItems: true,
+                    items: { type: 'string' },
+                  },
                   message: { type: 'string' },
                 },
-                required: ['disallowedFor'],
+                additionalProperties: false,
+              },
+              {
+                type: 'object',
+                properties: {
+                  propNamePattern: { type: 'string' },
+                  disallowedFor: {
+                    type: 'array',
+                    uniqueItems: true,
+                    minItems: 1,
+                    items: { type: 'string' },
+                  },
+                  disallowedForPatterns: {
+                    type: 'array',
+                    uniqueItems: true,
+                    minItems: 1,
+                    items: { type: 'string' },
+                  },
+                  message: { type: 'string' },
+                },
+                anyOf: [
+                  { required: ['disallowedFor'] },
+                  { required: ['disallowedForPatterns'] },
+                ],
                 additionalProperties: false,
               },
             ],
@@ -80,24 +138,71 @@ module.exports = {
     const configuration = context.options[0] || {};
     const forbid = new Map((configuration.forbid || DEFAULTS).map((value) => {
       const propName = typeof value === 'string' ? value : value.propName;
+      const propPattern = value.propNamePattern;
+      const prop = propName || propPattern;
       const options = {
-        allowList: typeof value === 'string' ? [] : (value.allowedFor || []),
-        disallowList: typeof value === 'string' ? [] : (value.disallowedFor || []),
+        allowList: [].concat(value.allowedFor || []),
+        allowPatternList: [].concat(value.allowedForPatterns || []),
+        disallowList: [].concat(value.disallowedFor || []),
+        disallowPatternList: [].concat(value.disallowedForPatterns || []),
         message: typeof value === 'string' ? null : value.message,
+        isPattern: !!value.propNamePattern,
       };
-      return [propName, options];
+      return [prop, options];
     }));
 
+    function getPropOptions(prop) {
+      // Get config options having pattern
+      const propNamePatternArray = Array.from(forbid.entries()).filter((propEntry) => propEntry[1].isPattern);
+      // Match current prop with pattern options, return if matched
+      const propNamePattern = propNamePatternArray.find((propPatternVal) => minimatch(prop, propPatternVal[0]));
+      // Get options for matched propNamePattern
+      const propNamePatternOptions = propNamePattern && propNamePattern[1];
+
+      const options = forbid.get(prop) || propNamePatternOptions;
+      return options;
+    }
+
     function isForbidden(prop, tagName) {
-      const options = forbid.get(prop);
+      const options = getPropOptions(prop);
       if (!options) {
         return false;
       }
 
+      function checkIsTagForbiddenByAllowOptions() {
+        if (options.allowList.indexOf(tagName) !== -1) {
+          return false;
+        }
+
+        if (options.allowPatternList.length === 0) {
+          return true;
+        }
+
+        return options.allowPatternList.every(
+          (pattern) => !minimatch(tagName, pattern)
+        );
+      }
+
+      function checkIsTagForbiddenByDisallowOptions() {
+        if (options.disallowList.indexOf(tagName) !== -1) {
+          return true;
+        }
+
+        if (options.disallowPatternList.length === 0) {
+          return false;
+        }
+
+        return options.disallowPatternList.some(
+          (pattern) => minimatch(tagName, pattern)
+        );
+      }
+
+      const hasDisallowOptions = options.disallowList.length > 0 || options.disallowPatternList.length > 0;
+
       // disallowList should have a least one item (schema configuration)
-      const isTagForbidden = options.disallowList.length > 0
-        ? options.disallowList.indexOf(tagName) !== -1
-        : options.allowList.indexOf(tagName) === -1;
+      const isTagForbidden = hasDisallowOptions
+        ? checkIsTagForbiddenByDisallowOptions()
+        : checkIsTagForbiddenByAllowOptions();
 
       // if the tagName is undefined (`<this.something>`), we assume it's a forbidden element
       return typeof tagName === 'undefined' || isTagForbidden;
@@ -120,7 +225,7 @@ module.exports = {
           return;
         }
 
-        const customMessage = forbid.get(prop).message;
+        const customMessage = getPropOptions(prop).message;
 
         report(context, customMessage || messages.propIsForbidden, !customMessage && 'propIsForbidden', {
           node,
diff --git a/lib/rules/forbid-dom-props.js b/lib/rules/forbid-dom-props.js
index d5131af98d..4638a8700d 100644
--- a/lib/rules/forbid-dom-props.js
+++ b/lib/rules/forbid-dom-props.js
@@ -37,6 +37,7 @@ const messages = {
   propIsForbidden: 'Prop "{{prop}}" is forbidden on DOM Nodes',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/forbid-elements.js b/lib/rules/forbid-elements.js
index 7da8f89f42..f08ef1d1e7 100644
--- a/lib/rules/forbid-elements.js
+++ b/lib/rules/forbid-elements.js
@@ -5,8 +5,9 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const isCreateElement = require('../util/isCreateElement');
 const report = require('../util/report');
 
@@ -19,6 +20,7 @@ const messages = {
   forbiddenElement_message: '<{{element}}> is forbidden, {{message}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -59,6 +61,7 @@ module.exports = {
     const configuration = context.options[0] || {};
     const forbidConfiguration = configuration.forbid || [];
 
+    /** @type {Record<string, { element: string, message?: string }>} */
     const indexedForbidConfigs = {};
 
     forbidConfiguration.forEach((item) => {
@@ -90,23 +93,25 @@ module.exports = {
 
     return {
       JSXOpeningElement(node) {
-        reportIfForbidden(context.getSourceCode().getText(node.name), node.name);
+        reportIfForbidden(getText(context, node.name), node.name);
       },
 
       CallExpression(node) {
-        if (!isCreateElement(node, context)) {
+        if (!isCreateElement(context, node)) {
           return;
         }
 
         const argument = node.arguments[0];
-        const argType = argument.type;
+        if (!argument) {
+          return;
+        }
 
-        if (argType === 'Identifier' && /^[A-Z_]/.test(argument.name)) {
+        if (argument.type === 'Identifier' && /^[A-Z_]/.test(argument.name)) {
           reportIfForbidden(argument.name, argument);
-        } else if (argType === 'Literal' && /^[a-z][^.]*$/.test(argument.value)) {
+        } else if (argument.type === 'Literal' && /^[a-z][^.]*$/.test(String(argument.value))) {
           reportIfForbidden(argument.value, argument);
-        } else if (argType === 'MemberExpression') {
-          reportIfForbidden(context.getSourceCode().getText(argument), argument);
+        } else if (argument.type === 'MemberExpression') {
+          reportIfForbidden(getText(context, argument), argument);
         }
       },
     };
diff --git a/lib/rules/forbid-foreign-prop-types.js b/lib/rules/forbid-foreign-prop-types.js
index 5d91bf07e3..20d191d264 100644
--- a/lib/rules/forbid-foreign-prop-types.js
+++ b/lib/rules/forbid-foreign-prop-types.js
@@ -13,6 +13,7 @@ const messages = {
   forbiddenPropType: 'Using propTypes from another component is not safe because they may be removed in production builds',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -108,7 +109,9 @@ module.exports = {
             && !ast.isAssignmentLHS(node)
             && !isAllowedAssignment(node)
           )) || (
+            // @ts-expect-error: The JSXText type is not present in the estree type definitions
             (node.property.type === 'Literal' || node.property.type === 'JSXText')
+            && 'value' in node.property
             && node.property.value === 'propTypes'
             && !ast.isAssignmentLHS(node)
             && !isAllowedAssignment(node)
@@ -121,7 +124,11 @@ module.exports = {
       },
 
       ObjectPattern(node) {
-        const propTypesNode = node.properties.find((property) => property.type === 'Property' && property.key.name === 'propTypes');
+        const propTypesNode = node.properties.find((property) => (
+          property.type === 'Property'
+          && 'name' in property.key
+          && property.key.name === 'propTypes'
+        ));
 
         if (propTypesNode) {
           report(context, messages.forbiddenPropType, 'forbiddenPropType', {
diff --git a/lib/rules/forbid-prop-types.js b/lib/rules/forbid-prop-types.js
index 92f0f0f51f..44de1fa023 100644
--- a/lib/rules/forbid-prop-types.js
+++ b/lib/rules/forbid-prop-types.js
@@ -10,6 +10,7 @@ const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 const propWrapperUtil = require('../util/propWrapper');
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
 
 // ------------------------------------------------------------------------------
 // Constants
@@ -25,6 +26,7 @@ const messages = {
   forbiddenPropType: 'Prop type "{{target}}" is forbidden',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -133,7 +135,7 @@ module.exports = {
           ) {
             value = value.object;
           }
-          if (value.type === 'CallExpression') {
+          if (astUtil.isCallExpression(value)) {
             if (!isPropTypesPackage(value.callee)) {
               return;
             }
@@ -157,29 +159,25 @@ module.exports = {
     }
 
     function checkNode(node) {
-      switch (node && node.type) {
-        case 'ObjectExpression':
-          checkProperties(node.properties);
-          break;
-        case 'Identifier': {
-          const propTypesObject = variableUtil.findVariableByName(context, node.name);
-          if (propTypesObject && propTypesObject.properties) {
-            checkProperties(propTypesObject.properties);
-          }
-          break;
+      if (!node) {
+        return;
+      }
+
+      if (node.type === 'ObjectExpression') {
+        checkProperties(node.properties);
+      } else if (node.type === 'Identifier') {
+        const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
+        if (propTypesObject && propTypesObject.properties) {
+          checkProperties(propTypesObject.properties);
         }
-        case 'CallExpression': {
-          const innerNode = node.arguments && node.arguments[0];
-          if (
-            propWrapperUtil.isPropWrapperFunction(context, context.getSourceCode().getText(node.callee))
+      } else if (astUtil.isCallExpression(node)) {
+        const innerNode = node.arguments && node.arguments[0];
+        if (
+          propWrapperUtil.isPropWrapperFunction(context, getText(context, node.callee))
             && innerNode
-          ) {
-            checkNode(innerNode);
-          }
-          break;
+        ) {
+          checkNode(innerNode);
         }
-        default:
-          break;
       }
     }
 
@@ -195,7 +193,10 @@ module.exports = {
           }
           if (node.specifiers.length >= 1) {
             const propTypesSpecifier = node.specifiers.find((specifier) => (
-              specifier.imported && specifier.imported.name === 'PropTypes'
+              'imported' in specifier
+              && specifier.imported
+              && 'name' in specifier.imported
+              && specifier.imported.name === 'PropTypes'
             ));
             if (propTypesSpecifier) {
               propTypesPackageName = propTypesSpecifier.local.name;
@@ -231,12 +232,13 @@ module.exports = {
           return;
         }
 
-        checkNode(node.parent.right);
+        checkNode('right' in node.parent && node.parent.right);
       },
 
       CallExpression(node) {
         if (
-          node.callee.object
+          node.callee.type === 'MemberExpression'
+          && node.callee.object
           && !isPropTypesPackage(node.callee.object)
           && !propsUtil.isPropTypesDeclaration(node.callee)
         ) {
@@ -245,9 +247,12 @@ module.exports = {
 
         if (
           node.arguments.length > 0
-          && (node.callee.name === 'shape' || astUtil.getPropertyName(node.callee) === 'shape')
+          && (
+            ('name' in node.callee && node.callee.name === 'shape')
+            || astUtil.getPropertyName(node.callee) === 'shape'
+          )
         ) {
-          checkProperties(node.arguments[0].properties);
+          checkProperties('properties' in node.arguments[0] && node.arguments[0].properties);
         }
       },
 
@@ -270,7 +275,7 @@ module.exports = {
 
       ObjectExpression(node) {
         node.properties.forEach((property) => {
-          if (!property.key) {
+          if (!('key' in property) || !property.key) {
             return;
           }
 
diff --git a/lib/rules/forward-ref-uses-ref.js b/lib/rules/forward-ref-uses-ref.js
new file mode 100644
index 0000000000..3a0b7de4c9
--- /dev/null
+++ b/lib/rules/forward-ref-uses-ref.js
@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Require all forwardRef components include a ref parameter
+ */
+
+'use strict';
+
+const isParenthesized = require('../util/ast').isParenthesized;
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+const getMessageData = require('../util/message');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/**
+ * @param {ASTNode} node
+ * @returns {boolean} If the node represents the identifier `forwardRef`.
+ */
+function isForwardRefIdentifier(node) {
+  return node.type === 'Identifier' && node.name === 'forwardRef';
+}
+
+/**
+ * @param {ASTNode} node
+ * @returns {boolean} If the node represents a function call `forwardRef()` or `React.forwardRef()`.
+ */
+function isForwardRefCall(node) {
+  return (
+    node.type === 'CallExpression'
+    && (
+      isForwardRefIdentifier(node.callee)
+      || (node.callee.type === 'MemberExpression' && isForwardRefIdentifier(node.callee.property))
+    )
+  );
+}
+
+const messages = {
+  missingRefParameter: 'forwardRef is used with this component but no ref parameter is set',
+  addRefParameter: 'Add a ref parameter',
+  removeForwardRef: 'Remove forwardRef wrapper',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Require all forwardRef components include a ref parameter',
+      category: 'Possible Errors',
+      recommended: false,
+      url: docsUrl('forward-ref-uses-ref'),
+    },
+    messages,
+    schema: [],
+    type: 'suggestion',
+    hasSuggestions: true,
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    return {
+      'FunctionExpression, ArrowFunctionExpression'(node) {
+        if (!isForwardRefCall(node.parent)) {
+          return;
+        }
+
+        if (node.params.length === 1) {
+          report(context, messages.missingRefParameter, 'missingRefParameter', {
+            node,
+            suggest: [
+              Object.assign(
+                getMessageData('addRefParameter', messages.addRefParameter),
+                {
+                  fix(fixer) {
+                    const param = node.params[0];
+                    // If using shorthand arrow function syntax, add parentheses around the new parameter pair
+                    const shouldAddParentheses = node.type === 'ArrowFunctionExpression' && !isParenthesized(context, param);
+                    return [].concat(
+                      shouldAddParentheses ? fixer.insertTextBefore(param, '(') : [],
+                      fixer.insertTextAfter(param, `, ref${shouldAddParentheses ? ')' : ''}`)
+                    );
+                  },
+                }
+              ),
+              Object.assign(
+                getMessageData('removeForwardRef', messages.removeForwardRef),
+                {
+                  fix(fixer) {
+                    return fixer.replaceText(node.parent, sourceCode.getText(node));
+                  },
+                }
+              ),
+            ],
+          });
+        }
+      },
+    };
+  },
+};
diff --git a/lib/rules/function-component-definition.js b/lib/rules/function-component-definition.js
index f8a95a9da0..cca665abe2 100644
--- a/lib/rules/function-component-definition.js
+++ b/lib/rules/function-component-definition.js
@@ -9,6 +9,8 @@ const arrayIncludes = require('array-includes');
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
 const reportC = require('../util/report');
+const getText = require('../util/eslint').getText;
+const propsUtil = require('../util/props');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -33,12 +35,12 @@ const UNNAMED_FUNCTION_TEMPLATES = {
 };
 
 function hasOneUnconstrainedTypeParam(node) {
-  const nodeTypeParams = node.typeParameters;
+  const nodeTypeArguments = propsUtil.getTypeArguments(node);
 
-  return nodeTypeParams
-    && nodeTypeParams.params
-    && nodeTypeParams.params.length === 1
-    && !nodeTypeParams.params[0].constraint;
+  return nodeTypeArguments
+    && nodeTypeArguments.params
+    && nodeTypeArguments.params.length === 1
+    && !nodeTypeArguments.params[0].constraint;
 }
 
 function hasName(node) {
@@ -113,6 +115,7 @@ const messages = {
   'arrow-function': 'Function component is not an arrow function',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -180,8 +183,7 @@ module.exports = {
     );
 
     function getFixer(node, options) {
-      const sourceCode = context.getSourceCode();
-      const source = sourceCode.getText();
+      const source = getText(context);
 
       const typeAnnotation = getTypeAnnotation(node, source);
 
@@ -201,11 +203,12 @@ module.exports = {
         varType = node.parent.parent.kind;
       }
 
+      const nodeTypeArguments = propsUtil.getTypeArguments(node);
       return (fixer) => fixer.replaceTextRange(
         options.range,
         buildFunction(options.template, {
           typeAnnotation,
-          typeParams: getNodeText(node.typeParameters, source),
+          typeParams: getNodeText(nodeTypeArguments, source),
           params: getParams(node, source),
           returnType: getNodeText(node.returnType, source),
           body: getBody(node, source),
diff --git a/lib/rules/hook-use-state.js b/lib/rules/hook-use-state.js
index a9deed4fd6..2d1cf681cd 100644
--- a/lib/rules/hook-use-state.js
+++ b/lib/rules/hook-use-state.js
@@ -9,6 +9,7 @@ const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
 const getMessageData = require('../util/message');
+const getText = require('../util/eslint').getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -25,6 +26,7 @@ const messages = {
   suggestMemo: 'Replace useState call with useMemo',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -160,14 +162,14 @@ module.exports = {
                 fix: (fixer) => [
                   // Add useMemo import, if necessary
                   useStateReactImportSpecifier
-                      && (!useMemoReactImportSpecifier || defaultReactImportName)
-                      && fixer.insertTextAfter(useStateReactImportSpecifier, ', useMemo'),
+                    && (!useMemoReactImportSpecifier || defaultReactImportName)
+                    && fixer.insertTextAfter(useStateReactImportSpecifier, ', useMemo'),
                   // Convert single-value destructure to simple assignment
                   fixer.replaceTextRange(node.parent.id.range, valueVariableName),
                   // Convert useState call to useMemo + arrow function + dependency array
                   fixer.replaceTextRange(
                     node.range,
-                    `${useMemoCode}(() => ${context.getSourceCode().getText(node.arguments[0])}, [])`
+                    `${useMemoCode}(() => ${getText(context, node.arguments[0])}, [])`
                   ),
                 ].filter(Boolean),
               }
diff --git a/lib/rules/iframe-missing-sandbox.js b/lib/rules/iframe-missing-sandbox.js
index 9a8bd4774d..7d8f234d97 100644
--- a/lib/rules/iframe-missing-sandbox.js
+++ b/lib/rules/iframe-missing-sandbox.js
@@ -109,6 +109,7 @@ function checkProps(context, node) {
   }
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -130,7 +131,7 @@ module.exports = {
       },
 
       CallExpression(node) {
-        if (isCreateElement(node, context) && node.arguments && node.arguments.length > 0) {
+        if (isCreateElement(context, node) && node.arguments && node.arguments.length > 0) {
           const tag = node.arguments[0];
           if (tag.type === 'Literal' && tag.value === 'iframe') {
             checkProps(context, node);
diff --git a/lib/rules/index.js b/lib/rules/index.js
index d7142ed9b4..0e73ab1a3f 100644
--- a/lib/rules/index.js
+++ b/lib/rules/index.js
@@ -2,9 +2,11 @@
 
 /* eslint global-require: 0 */
 
-module.exports = {
+/** @satisfies {Record<string, import('eslint').Rule.RuleModule>} */
+const rules = {
   'boolean-prop-naming': require('./boolean-prop-naming'),
   'button-has-type': require('./button-has-type'),
+  'checked-requires-onchange-or-readonly': require('./checked-requires-onchange-or-readonly'),
   'default-props-match-prop-types': require('./default-props-match-prop-types'),
   'destructuring-assignment': require('./destructuring-assignment'),
   'display-name': require('./display-name'),
@@ -13,6 +15,7 @@ module.exports = {
   'forbid-elements': require('./forbid-elements'),
   'forbid-foreign-prop-types': require('./forbid-foreign-prop-types'),
   'forbid-prop-types': require('./forbid-prop-types'),
+  'forward-ref-uses-ref': require('./forward-ref-uses-ref'),
   'function-component-definition': require('./function-component-definition'),
   'hook-use-state': require('./hook-use-state'),
   'iframe-missing-sandbox': require('./iframe-missing-sandbox'),
@@ -48,6 +51,7 @@ module.exports = {
   'jsx-fragments': require('./jsx-fragments'),
   'jsx-props-no-multi-spaces': require('./jsx-props-no-multi-spaces'),
   'jsx-props-no-spreading': require('./jsx-props-no-spreading'),
+  'jsx-props-no-spread-multi': require('./jsx-props-no-spread-multi'),
   'jsx-sort-default-props': require('./jsx-sort-default-props'),
   'jsx-sort-props': require('./jsx-sort-props'),
   'jsx-space-before-closing': require('./jsx-space-before-closing'),
@@ -104,3 +108,5 @@ module.exports = {
   'style-prop-object': require('./style-prop-object'),
   'void-dom-elements-no-children': require('./void-dom-elements-no-children'),
 };
+
+module.exports = rules;
diff --git a/lib/rules/jsx-boolean-value.js b/lib/rules/jsx-boolean-value.js
index ae6dda0da7..4572e7ff8d 100644
--- a/lib/rules/jsx-boolean-value.js
+++ b/lib/rules/jsx-boolean-value.js
@@ -21,19 +21,6 @@ const exceptionsSchema = {
 const ALWAYS = 'always';
 const NEVER = 'never';
 
-const errorData = new WeakMap();
-/**
- * @param {object} exceptions
- * @returns {object}
- */
-function getErrorData(exceptions) {
-  if (!errorData.has(exceptions)) {
-    const exceptionProps = Array.from(exceptions, (name) => `\`${name}\``).join(', ');
-    const exceptionsMessage = exceptions.size > 0 ? ` for the following props: ${exceptionProps}` : '';
-    errorData.set(exceptions, { exceptionsMessage });
-  }
-  return errorData.get(exceptions);
-}
 /**
  * @param {string} configuration
  * @param {Set<string>} exceptions
@@ -62,14 +49,12 @@ function isNever(configuration, exceptions, propName) {
 }
 
 const messages = {
-  omitBoolean: 'Value must be omitted for boolean attributes{{exceptionsMessage}}',
-  omitBoolean_noMessage: 'Value must be omitted for boolean attributes',
-  setBoolean: 'Value must be set for boolean attributes{{exceptionsMessage}}',
-  setBoolean_noMessage: 'Value must be set for boolean attributes',
-  omitPropAndBoolean: 'Value and Prop must be omitted for false attributes{{exceptionsMessage}}',
-  omitPropAndBoolean_noMessage: 'Value and Prop must be omitted for false attributes',
+  omitBoolean: 'Value must be omitted for boolean attribute `{{propName}}`',
+  setBoolean: 'Value must be set for boolean attribute `{{propName}}`',
+  omitPropAndBoolean: 'Value must be omitted for `false` attribute: `{{propName}}`',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -135,8 +120,8 @@ module.exports = {
           isAlways(configuration, exceptions, propName)
           && value === null
         ) {
-          const data = getErrorData(exceptions);
-          const messageId = data.exceptionsMessage ? 'setBoolean' : 'setBoolean_noMessage';
+          const messageId = 'setBoolean';
+          const data = { propName };
           report(context, messages[messageId], messageId, {
             node,
             data,
@@ -147,13 +132,12 @@ module.exports = {
         }
         if (
           isNever(configuration, exceptions, propName)
-          && !configObject.assumeUndefinedIsFalse
           && value
           && value.type === 'JSXExpressionContainer'
           && value.expression.value === true
         ) {
-          const data = getErrorData(exceptions);
-          const messageId = data.exceptionsMessage ? 'omitBoolean' : 'omitBoolean_noMessage';
+          const messageId = 'omitBoolean';
+          const data = { propName };
           report(context, messages[messageId], messageId, {
             node,
             data,
@@ -169,11 +153,8 @@ module.exports = {
           && value.type === 'JSXExpressionContainer'
           && value.expression.value === false
         ) {
-          const data = getErrorData(exceptions);
-          const messageId = data.exceptionsMessage
-            ? 'omitPropAndBoolean'
-            : 'omitPropAndBoolean_noMessage';
-
+          const messageId = 'omitPropAndBoolean';
+          const data = { propName };
           report(context, messages[messageId], messageId, {
             node,
             data,
diff --git a/lib/rules/jsx-child-element-spacing.js b/lib/rules/jsx-child-element-spacing.js
index d8d2af67ab..06807efcc6 100644
--- a/lib/rules/jsx-child-element-spacing.js
+++ b/lib/rules/jsx-child-element-spacing.js
@@ -44,6 +44,7 @@ const messages = {
   spacingBeforeNext: 'Ambiguous spacing before next element {{element}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-closing-bracket-location.js b/lib/rules/jsx-closing-bracket-location.js
index 4816fd0068..eed661e944 100644
--- a/lib/rules/jsx-closing-bracket-location.js
+++ b/lib/rules/jsx-closing-bracket-location.js
@@ -5,8 +5,11 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
+const repeat = require('string.prototype.repeat');
+
 const docsUrl = require('../util/docsUrl');
+const getSourceCode = require('../util/eslint').getSourceCode;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -17,6 +20,7 @@ const messages = {
   bracketLocation: 'The closing bracket must be {{location}}{{details}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -97,7 +101,7 @@ module.exports = {
     /**
      * Get expected location for the closing bracket
      * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
-     * @return {String} Expected location for the closing bracket
+     * @return {string} Expected location for the closing bracket
      */
     function getExpectedLocation(tokens) {
       let location;
@@ -118,7 +122,7 @@ module.exports = {
      * Get the correct 0-indexed column for the closing bracket, given the
      * expected location.
      * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
-     * @param {String} expectedLocation Expected location for the closing bracket
+     * @param {string} expectedLocation Expected location for the closing bracket
      * @return {?Number} The correct column for the closing bracket, or null
      */
     function getCorrectColumn(tokens, expectedLocation) {
@@ -137,8 +141,8 @@ module.exports = {
     /**
      * Check if the closing bracket is correctly located
      * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
-     * @param {String} expectedLocation Expected location for the closing bracket
-     * @return {Boolean} True if the closing bracket is correctly located, false if not
+     * @param {string} expectedLocation Expected location for the closing bracket
+     * @return {boolean} True if the closing bracket is correctly located, false if not
      */
     function hasCorrectLocation(tokens, expectedLocation) {
       switch (expectedLocation) {
@@ -160,30 +164,30 @@ module.exports = {
     /**
      * Get the characters used for indentation on the line to be matched
      * @param {Object} tokens Locations of the opening bracket, closing bracket and last prop
-     * @param {String} expectedLocation Expected location for the closing bracket
-     * @param {Number} [correctColumn] Expected column for the closing bracket. Default to 0
-     * @return {String} The characters used for indentation
+     * @param {string} expectedLocation Expected location for the closing bracket
+     * @param {number} [correctColumn] Expected column for the closing bracket. Default to 0
+     * @return {string} The characters used for indentation
      */
     function getIndentation(tokens, expectedLocation, correctColumn) {
       const newColumn = correctColumn || 0;
       let indentation;
-      let spaces = [];
+      let spaces = '';
       switch (expectedLocation) {
         case 'props-aligned':
-          indentation = /^\s*/.exec(context.getSourceCode().lines[tokens.lastProp.firstLine - 1])[0];
+          indentation = /^\s*/.exec(getSourceCode(context).lines[tokens.lastProp.firstLine - 1])[0];
           break;
         case 'tag-aligned':
         case 'line-aligned':
-          indentation = /^\s*/.exec(context.getSourceCode().lines[tokens.opening.line - 1])[0];
+          indentation = /^\s*/.exec(getSourceCode(context).lines[tokens.opening.line - 1])[0];
           break;
         default:
           indentation = '';
       }
       if (indentation.length + 1 < newColumn) {
         // Non-whitespace characters were included in the column offset
-        spaces = new Array(+correctColumn + 1 - indentation.length);
+        spaces = repeat(' ', +correctColumn - indentation.length);
       }
-      return indentation + spaces.join(' ');
+      return indentation + spaces;
     }
 
     /**
@@ -194,7 +198,7 @@ module.exports = {
      * prop and start of opening line.
      */
     function getTokensLocations(node) {
-      const sourceCode = context.getSourceCode();
+      const sourceCode = getSourceCode(context);
       const opening = sourceCode.getFirstToken(node).loc.start;
       const closing = sourceCode.getLastTokens(node, node.selfClosing ? 2 : 1)[0].loc.start;
       const tag = sourceCode.getFirstToken(node.name).loc.start;
@@ -232,7 +236,7 @@ module.exports = {
      * Get an unique ID for a given JSXOpeningElement
      *
      * @param {ASTNode} node The AST node being checked.
-     * @returns {String} Unique ID (based on its range)
+     * @returns {string} Unique ID (based on its range)
      */
     function getOpeningElementId(node) {
       return node.range.join(':');
@@ -266,7 +270,10 @@ module.exports = {
           return;
         }
 
-        const data = { location: MESSAGE_LOCATION[expectedLocation] };
+        const data = {
+          location: MESSAGE_LOCATION[expectedLocation],
+          details: '',
+        };
         const correctColumn = getCorrectColumn(tokens, expectedLocation);
 
         if (correctColumn !== null) {
diff --git a/lib/rules/jsx-closing-tag-location.js b/lib/rules/jsx-closing-tag-location.js
index ef68285513..5f6f6efe38 100644
--- a/lib/rules/jsx-closing-tag-location.js
+++ b/lib/rules/jsx-closing-tag-location.js
@@ -5,8 +5,12 @@
 
 'use strict';
 
+const repeat = require('string.prototype.repeat');
+const has = require('hasown');
+
 const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
+const getSourceCode = require('../util/eslint').getSourceCode;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -16,8 +20,17 @@ const report = require('../util/report');
 const messages = {
   onOwnLine: 'Closing tag of a multiline JSX expression must be on its own line.',
   matchIndent: 'Expected closing tag to match indentation of opening.',
+  alignWithOpening: 'Expected closing tag to be aligned with the line containing the opening tag',
 };
 
+const defaultOption = 'tag-aligned';
+
+const optionMessageMap = {
+  'tag-aligned': 'matchIndent',
+  'line-aligned': 'alignWithOpening',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -28,31 +41,87 @@ module.exports = {
     },
     fixable: 'whitespace',
     messages,
+    schema: [{
+      anyOf: [
+        {
+          enum: ['tag-aligned', 'line-aligned'],
+        },
+        {
+          type: 'object',
+          properties: {
+            location: {
+              enum: ['tag-aligned', 'line-aligned'],
+            },
+          },
+          additionalProperties: false,
+        },
+      ],
+    }],
   },
 
   create(context) {
+    const config = context.options[0];
+    let option = defaultOption;
+
+    if (typeof config === 'string') {
+      option = config;
+    } else if (typeof config === 'object') {
+      if (has(config, 'location')) {
+        option = config.location;
+      }
+    }
+
+    function getIndentation(openingStartOfLine, opening) {
+      if (option === 'line-aligned') return openingStartOfLine.column;
+      if (option === 'tag-aligned') return opening.loc.start.column;
+    }
+
     function handleClosingElement(node) {
       if (!node.parent) {
         return;
       }
+      const sourceCode = getSourceCode(context);
 
       const opening = node.parent.openingElement || node.parent.openingFragment;
+      const openingLoc = sourceCode.getFirstToken(opening).loc.start;
+      const openingLine = sourceCode.lines[openingLoc.line - 1];
+
+      const openingStartOfLine = {
+        column: /^\s*/.exec(openingLine)[0].length,
+        line: openingLoc.line,
+      };
+
       if (opening.loc.start.line === node.loc.start.line) {
         return;
       }
 
-      if (opening.loc.start.column === node.loc.start.column) {
+      if (
+        opening.loc.start.column === node.loc.start.column
+        && option === 'tag-aligned'
+      ) {
+        return;
+      }
+
+      if (
+        openingStartOfLine.column === node.loc.start.column
+        && option === 'line-aligned'
+      ) {
         return;
       }
 
       const messageId = astUtil.isNodeFirstInLine(context, node)
-        ? 'matchIndent'
+        ? optionMessageMap[option]
         : 'onOwnLine';
+
       report(context, messages[messageId], messageId, {
         node,
         loc: node.loc,
         fix(fixer) {
-          const indent = Array(opening.loc.start.column + 1).join(' ');
+          const indent = repeat(
+            ' ',
+            getIndentation(openingStartOfLine, opening)
+          );
+
           if (astUtil.isNodeFirstInLine(context, node)) {
             return fixer.replaceTextRange(
               [node.range[0] - node.loc.start.column, node.range[0]],
diff --git a/lib/rules/jsx-curly-brace-presence.js b/lib/rules/jsx-curly-brace-presence.js
index c5467cc415..0f17143ffa 100755
--- a/lib/rules/jsx-curly-brace-presence.js
+++ b/lib/rules/jsx-curly-brace-presence.js
@@ -11,6 +11,10 @@ const arrayIncludes = require('array-includes');
 const docsUrl = require('../util/docsUrl');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Constants
@@ -27,6 +31,108 @@ const OPTION_VALUES = [
 ];
 const DEFAULT_CONFIG = { props: OPTION_NEVER, children: OPTION_NEVER, propElementValues: OPTION_IGNORE };
 
+const HTML_ENTITY_REGEX = () => /&[A-Za-z\d#]+;/g;
+
+function containsLineTerminators(rawStringValue) {
+  return /[\n\r\u2028\u2029]/.test(rawStringValue);
+}
+
+function containsBackslash(rawStringValue) {
+  return arrayIncludes(rawStringValue, '\\');
+}
+
+function containsHTMLEntity(rawStringValue) {
+  return HTML_ENTITY_REGEX().test(rawStringValue);
+}
+
+function containsOnlyHtmlEntities(rawStringValue) {
+  return rawStringValue.replace(HTML_ENTITY_REGEX(), '').trim() === '';
+}
+
+function containsDisallowedJSXTextChars(rawStringValue) {
+  return /[{<>}]/.test(rawStringValue);
+}
+
+function containsQuoteCharacters(value) {
+  return /['"]/.test(value);
+}
+
+function containsMultilineComment(value) {
+  return /\/\*/.test(value);
+}
+
+function escapeDoubleQuotes(rawStringValue) {
+  return rawStringValue.replace(/\\"/g, '"').replace(/"/g, '\\"');
+}
+
+function escapeBackslashes(rawStringValue) {
+  return rawStringValue.replace(/\\/g, '\\\\');
+}
+
+function needToEscapeCharacterForJSX(raw, node) {
+  return (
+    containsBackslash(raw)
+    || containsHTMLEntity(raw)
+    || (node.parent.type !== 'JSXAttribute' && containsDisallowedJSXTextChars(raw))
+  );
+}
+
+function containsWhitespaceExpression(child) {
+  if (child.type === 'JSXExpressionContainer') {
+    const value = child.expression.value;
+    return value ? jsxUtil.isWhiteSpaces(value) : false;
+  }
+  return false;
+}
+
+function isLineBreak(text) {
+  return containsLineTerminators(text) && text.trim() === '';
+}
+
+function wrapNonHTMLEntities(text) {
+  const HTML_ENTITY = '<HTML_ENTITY>';
+  const withCurlyBraces = text.split(HTML_ENTITY_REGEX()).map((word) => (
+    word === '' ? '' : `{${JSON.stringify(word)}}`
+  )).join(HTML_ENTITY);
+
+  const htmlEntities = text.match(HTML_ENTITY_REGEX());
+  return htmlEntities.reduce((acc, htmlEntity) => (
+    acc.replace(HTML_ENTITY, htmlEntity)
+  ), withCurlyBraces);
+}
+
+function wrapWithCurlyBraces(rawText) {
+  if (!containsLineTerminators(rawText)) {
+    return `{${JSON.stringify(rawText)}}`;
+  }
+
+  return rawText.split('\n').map((line) => {
+    if (line.trim() === '') {
+      return line;
+    }
+    const firstCharIndex = line.search(/[^\s]/);
+    const leftWhitespace = line.slice(0, firstCharIndex);
+    const text = line.slice(firstCharIndex);
+
+    if (containsHTMLEntity(line)) {
+      return `${leftWhitespace}${wrapNonHTMLEntities(text)}`;
+    }
+    return `${leftWhitespace}{${JSON.stringify(text)}}`;
+  }).join('\n');
+}
+
+function isWhiteSpaceLiteral(node) {
+  return node.type && node.type === 'Literal' && node.value && jsxUtil.isWhiteSpaces(node.value);
+}
+
+function isStringWithTrailingWhiteSpaces(value) {
+  return /^\s|\s$/.test(value);
+}
+
+function isLiteralWithTrailingWhiteSpaces(node) {
+  return node.type && node.type === 'Literal' && node.value && isStringWithTrailingWhiteSpaces(node.value);
+}
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -36,6 +142,7 @@ const messages = {
   missingCurly: 'Need to wrap this literal in a JSX expression.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -69,100 +176,11 @@ module.exports = {
   },
 
   create(context) {
-    const HTML_ENTITY_REGEX = () => /&[A-Za-z\d#]+;/g;
     const ruleOptions = context.options[0];
     const userConfig = typeof ruleOptions === 'string'
       ? { props: ruleOptions, children: ruleOptions, propElementValues: OPTION_IGNORE }
       : Object.assign({}, DEFAULT_CONFIG, ruleOptions);
 
-    function containsLineTerminators(rawStringValue) {
-      return /[\n\r\u2028\u2029]/.test(rawStringValue);
-    }
-
-    function containsBackslash(rawStringValue) {
-      return arrayIncludes(rawStringValue, '\\');
-    }
-
-    function containsHTMLEntity(rawStringValue) {
-      return HTML_ENTITY_REGEX().test(rawStringValue);
-    }
-
-    function containsOnlyHtmlEntities(rawStringValue) {
-      return rawStringValue.replace(HTML_ENTITY_REGEX(), '').trim() === '';
-    }
-
-    function containsDisallowedJSXTextChars(rawStringValue) {
-      return /[{<>}]/.test(rawStringValue);
-    }
-
-    function containsQuoteCharacters(value) {
-      return /['"]/.test(value);
-    }
-
-    function containsMultilineComment(value) {
-      return /\/\*/.test(value);
-    }
-
-    function escapeDoubleQuotes(rawStringValue) {
-      return rawStringValue.replace(/\\"/g, '"').replace(/"/g, '\\"');
-    }
-
-    function escapeBackslashes(rawStringValue) {
-      return rawStringValue.replace(/\\/g, '\\\\');
-    }
-
-    function needToEscapeCharacterForJSX(raw, node) {
-      return (
-        containsBackslash(raw)
-        || containsHTMLEntity(raw)
-        || (node.parent.type !== 'JSXAttribute' && containsDisallowedJSXTextChars(raw))
-      );
-    }
-
-    function containsWhitespaceExpression(child) {
-      if (child.type === 'JSXExpressionContainer') {
-        const value = child.expression.value;
-        return value ? jsxUtil.isWhiteSpaces(value) : false;
-      }
-      return false;
-    }
-
-    function isLineBreak(text) {
-      return containsLineTerminators(text) && text.trim() === '';
-    }
-
-    function wrapNonHTMLEntities(text) {
-      const HTML_ENTITY = '<HTML_ENTITY>';
-      const withCurlyBraces = text.split(HTML_ENTITY_REGEX()).map((word) => (
-        word === '' ? '' : `{${JSON.stringify(word)}}`
-      )).join(HTML_ENTITY);
-
-      const htmlEntities = text.match(HTML_ENTITY_REGEX());
-      return htmlEntities.reduce((acc, htmlEntity) => (
-        acc.replace(HTML_ENTITY, htmlEntity)
-      ), withCurlyBraces);
-    }
-
-    function wrapWithCurlyBraces(rawText) {
-      if (!containsLineTerminators(rawText)) {
-        return `{${JSON.stringify(rawText)}}`;
-      }
-
-      return rawText.split('\n').map((line) => {
-        if (line.trim() === '') {
-          return line;
-        }
-        const firstCharIndex = line.search(/[^\s]/);
-        const leftWhitespace = line.slice(0, firstCharIndex);
-        const text = line.slice(firstCharIndex);
-
-        if (containsHTMLEntity(line)) {
-          return `${leftWhitespace}${wrapNonHTMLEntities(text)}`;
-        }
-        return `${leftWhitespace}{${JSON.stringify(text)}}`;
-      }).join('\n');
-    }
-
     /**
      * Report and fix an unnecessary curly brace violation on a node
      * @param {ASTNode} JSXExpressionNode - The AST node with an unnecessary JSX expression
@@ -175,21 +193,22 @@ module.exports = {
 
           let textToReplace;
           if (jsxUtil.isJSX(expression)) {
-            const sourceCode = context.getSourceCode();
-            textToReplace = sourceCode.getText(expression);
+            textToReplace = getText(context, expression);
           } else {
             const expressionType = expression && expression.type;
             const parentType = JSXExpressionNode.parent.type;
 
             if (parentType === 'JSXAttribute') {
-              textToReplace = `"${expressionType === 'TemplateLiteral'
-                ? expression.quasis[0].value.raw
-                : expression.raw.slice(1, -1)
-              }"`;
+              if (expressionType !== 'TemplateLiteral' && /["]/.test(expression.raw.slice(1, -1))) {
+                textToReplace = expression.raw;
+              } else {
+                textToReplace = `"${expressionType === 'TemplateLiteral'
+                  ? expression.quasis[0].value.raw
+                  : expression.raw.slice(1, -1)
+                }"`;
+              }
             } else if (jsxUtil.isJSX(expression)) {
-              const sourceCode = context.getSourceCode();
-
-              textToReplace = sourceCode.getText(expression);
+              textToReplace = getText(context, expression);
             } else {
               textToReplace = expressionType === 'TemplateLiteral'
                 ? expression.quasis[0].value.cooked : expression.value;
@@ -206,7 +225,7 @@ module.exports = {
         node: literalNode,
         fix(fixer) {
           if (jsxUtil.isJSX(literalNode)) {
-            return fixer.replaceText(literalNode, `{${context.getSourceCode().getText(literalNode)}}`);
+            return fixer.replaceText(literalNode, `{${getText(context, literalNode)}}`);
           }
 
           // If a HTML entity name is found, bail out because it can be fixed
@@ -231,18 +250,6 @@ module.exports = {
       });
     }
 
-    function isWhiteSpaceLiteral(node) {
-      return node.type && node.type === 'Literal' && node.value && jsxUtil.isWhiteSpaces(node.value);
-    }
-
-    function isStringWithTrailingWhiteSpaces(value) {
-      return /^\s|\s$/.test(value);
-    }
-
-    function isLiteralWithTrailingWhiteSpaces(node) {
-      return node.type && node.type === 'Literal' && node.value && isStringWithTrailingWhiteSpaces(node.value);
-    }
-
     // Bail out if there is any character that needs to be escaped in JSX
     // because escaping decreases readability and the original code may be more
     // readable anyway or intentional for other specific reasons
@@ -250,7 +257,7 @@ module.exports = {
       const expression = JSXExpressionNode.expression;
       const expressionType = expression.type;
 
-      const sourceCode = context.getSourceCode();
+      const sourceCode = getSourceCode(context);
       // Curly braces containing comments are necessary
       if (sourceCode.getCommentsInside && sourceCode.getCommentsInside(JSXExpressionNode).length > 0) {
         return;
@@ -266,7 +273,7 @@ module.exports = {
           && !containsMultilineComment(expression.value)
           && !needToEscapeCharacterForJSX(expression.raw, JSXExpressionNode) && (
           jsxUtil.isJSX(JSXExpressionNode.parent)
-          || !containsQuoteCharacters(expression.value)
+          || (!containsQuoteCharacters(expression.value) || typeof expression.value === 'string')
         )
       ) {
         reportUnnecessaryCurly(JSXExpressionNode);
diff --git a/lib/rules/jsx-curly-newline.js b/lib/rules/jsx-curly-newline.js
index 77c2c82d8d..046ff79582 100644
--- a/lib/rules/jsx-curly-newline.js
+++ b/lib/rules/jsx-curly-newline.js
@@ -5,8 +5,12 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const report = require('../util/report');
 
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -41,6 +45,7 @@ const messages = {
   unexpectedAfter: 'Unexpected newline after \'{\'.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     type: 'layout',
@@ -76,7 +81,7 @@ module.exports = {
   },
 
   create(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = getSourceCode(context);
     const option = getNormalizedOption(context);
 
     // ----------------------------------------------------------------------
@@ -129,8 +134,7 @@ module.exports = {
         report(context, messages.unexpectedAfter, 'unexpectedAfter', {
           node: leftCurly,
           fix(fixer) {
-            return sourceCode
-              .getText()
+            return getText(context)
               .slice(leftCurly.range[1], tokenAfterLeftCurly.range[0])
               .trim()
               ? null // If there is a comment between the { and the first element, don't do a fix.
@@ -148,8 +152,7 @@ module.exports = {
         report(context, messages.unexpectedBefore, 'unexpectedBefore', {
           node: rightCurly,
           fix(fixer) {
-            return sourceCode
-              .getText()
+            return getText(context)
               .slice(tokenBeforeRightCurly.range[1], rightCurly.range[0])
               .trim()
               ? null // If there is a comment between the last element and the }, don't do a fix.
diff --git a/lib/rules/jsx-curly-spacing.js b/lib/rules/jsx-curly-spacing.js
index 094e612c7d..fda49381ce 100644
--- a/lib/rules/jsx-curly-spacing.js
+++ b/lib/rules/jsx-curly-spacing.js
@@ -11,8 +11,9 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const docsUrl = require('../util/docsUrl');
+const getSourceCode = require('../util/eslint').getSourceCode;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -34,6 +35,7 @@ const messages = {
   spaceNeededBefore: 'A space is required before \'{{token}}\'',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -175,7 +177,7 @@ module.exports = {
      * @returns {Object|*|{range, text}}
      */
     function fixByTrimmingWhitespace(fixer, fromLoc, toLoc, mode, spacing) {
-      let replacementText = context.getSourceCode().text.slice(fromLoc, toLoc);
+      let replacementText = getSourceCode(context).text.slice(fromLoc, toLoc);
       if (mode === 'start') {
         replacementText = replacementText.replace(/^\s+/gm, '');
       } else {
@@ -206,7 +208,7 @@ module.exports = {
           token: token.value,
         },
         fix(fixer) {
-          const nextToken = context.getSourceCode().getTokenAfter(token);
+          const nextToken = getSourceCode(context).getTokenAfter(token);
           return fixByTrimmingWhitespace(fixer, token.range[1], nextToken.range[0], 'start', spacing);
         },
       });
@@ -227,7 +229,7 @@ module.exports = {
           token: token.value,
         },
         fix(fixer) {
-          const previousToken = context.getSourceCode().getTokenBefore(token);
+          const previousToken = getSourceCode(context).getTokenBefore(token);
           return fixByTrimmingWhitespace(fixer, previousToken.range[1], token.range[0], 'end', spacing);
         },
       });
@@ -247,7 +249,7 @@ module.exports = {
           token: token.value,
         },
         fix(fixer) {
-          const sourceCode = context.getSourceCode();
+          const sourceCode = getSourceCode(context);
           const nextToken = sourceCode.getTokenAfter(token);
           let nextComment;
 
@@ -284,7 +286,7 @@ module.exports = {
           token: token.value,
         },
         fix(fixer) {
-          const sourceCode = context.getSourceCode();
+          const sourceCode = getSourceCode(context);
           const previousToken = sourceCode.getTokenBefore(token);
           let previousComment;
 
@@ -370,7 +372,7 @@ module.exports = {
         return;
       }
 
-      const sourceCode = context.getSourceCode();
+      const sourceCode = getSourceCode(context);
       const first = sourceCode.getFirstToken(node);
       const last = sourceCode.getLastToken(node);
       let second = sourceCode.getTokenAfter(first, { includeComments: true });
diff --git a/lib/rules/jsx-equals-spacing.js b/lib/rules/jsx-equals-spacing.js
index e5eefd2bb5..6920fb24bf 100644
--- a/lib/rules/jsx-equals-spacing.js
+++ b/lib/rules/jsx-equals-spacing.js
@@ -6,6 +6,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getSourceCode = require('../util/eslint').getSourceCode;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -19,6 +20,7 @@ const messages = {
   needSpaceAfter: 'A space is required after \'=\'',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -59,7 +61,7 @@ module.exports = {
             return;
           }
 
-          const sourceCode = context.getSourceCode();
+          const sourceCode = getSourceCode(context);
           const equalToken = sourceCode.getTokenAfter(attrNode.name);
           const spacedBefore = sourceCode.isSpaceBetweenTokens(attrNode.name, equalToken);
           const spacedAfter = sourceCode.isSpaceBetweenTokens(equalToken, attrNode.value);
diff --git a/lib/rules/jsx-filename-extension.js b/lib/rules/jsx-filename-extension.js
index 578ffaf309..4a2cfeede6 100644
--- a/lib/rules/jsx-filename-extension.js
+++ b/lib/rules/jsx-filename-extension.js
@@ -28,6 +28,7 @@ const messages = {
   extensionOnlyForJSX: 'Only files containing JSX may use the extension \'{{ext}}\'',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-first-prop-new-line.js b/lib/rules/jsx-first-prop-new-line.js
index 026ab384a0..3014d24f1e 100644
--- a/lib/rules/jsx-first-prop-new-line.js
+++ b/lib/rules/jsx-first-prop-new-line.js
@@ -7,6 +7,7 @@
 
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const propsUtil = require('../util/props');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -17,6 +18,7 @@ const messages = {
   propOnSameLine: 'Property should be placed on the same line as the component declaration',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -54,7 +56,8 @@ module.exports = {
               report(context, messages.propOnNewLine, 'propOnNewLine', {
                 node: decl,
                 fix(fixer) {
-                  return fixer.replaceTextRange([(node.typeParameters || node.name).range[1], decl.range[0]], '\n');
+                  const nodeTypeArguments = propsUtil.getTypeArguments(node);
+                  return fixer.replaceTextRange([(nodeTypeArguments || node.name).range[1], decl.range[0]], '\n');
                 },
               });
             }
diff --git a/lib/rules/jsx-fragments.js b/lib/rules/jsx-fragments.js
index 38b4dd8b4b..b4a545846e 100644
--- a/lib/rules/jsx-fragments.js
+++ b/lib/rules/jsx-fragments.js
@@ -11,6 +11,7 @@ const variableUtil = require('../util/variable');
 const testReactVersion = require('../util/version').testReactVersion;
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -21,12 +22,12 @@ function replaceNode(source, node, text) {
 }
 
 const messages = {
-  fragmentsNotSupported: 'Fragments are only supported starting from React v16.2. '
-    + 'Please disable the `react/jsx-fragments` rule in `eslint` settings or upgrade your version of React.',
+  fragmentsNotSupported: 'Fragments are only supported starting from React v16.2. Please disable the `react/jsx-fragments` rule in `eslint` settings or upgrade your version of React.',
   preferPragma: 'Prefer {{react}}.{{fragment}} over fragment shorthand',
   preferFragment: 'Prefer fragment shorthand over {{react}}.{{fragment}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -65,36 +66,34 @@ module.exports = {
     }
 
     function getFixerToLong(jsxFragment) {
-      const sourceCode = context.getSourceCode();
       if (!jsxFragment.closingFragment || !jsxFragment.openingFragment) {
         // the old TS parser crashes here
         // TODO: FIXME: can we fake these two descriptors?
         return null;
       }
       return function fix(fixer) {
-        let source = sourceCode.getText();
+        let source = getText(context);
         source = replaceNode(source, jsxFragment.closingFragment, closeFragLong);
         source = replaceNode(source, jsxFragment.openingFragment, openFragLong);
-        const lengthDiff = openFragLong.length - sourceCode.getText(jsxFragment.openingFragment).length
-          + closeFragLong.length - sourceCode.getText(jsxFragment.closingFragment).length;
+        const lengthDiff = openFragLong.length - getText(context, jsxFragment.openingFragment).length
+          + closeFragLong.length - getText(context, jsxFragment.closingFragment).length;
         const range = jsxFragment.range;
         return fixer.replaceTextRange(range, source.slice(range[0], range[1] + lengthDiff));
       };
     }
 
     function getFixerToShort(jsxElement) {
-      const sourceCode = context.getSourceCode();
       return function fix(fixer) {
-        let source = sourceCode.getText();
+        let source = getText(context);
         let lengthDiff;
         if (jsxElement.closingElement) {
           source = replaceNode(source, jsxElement.closingElement, closeFragShort);
           source = replaceNode(source, jsxElement.openingElement, openFragShort);
-          lengthDiff = sourceCode.getText(jsxElement.openingElement).length - openFragShort.length
-            + sourceCode.getText(jsxElement.closingElement).length - closeFragShort.length;
+          lengthDiff = getText(context, jsxElement.openingElement).length - openFragShort.length
+            + getText(context, jsxElement.closingElement).length - closeFragShort.length;
         } else {
           source = replaceNode(source, jsxElement.openingElement, `${openFragShort}${closeFragShort}`);
-          lengthDiff = sourceCode.getText(jsxElement.openingElement).length - openFragShort.length
+          lengthDiff = getText(context, jsxElement.openingElement).length - openFragShort.length
             - closeFragShort.length;
         }
 
@@ -103,8 +102,8 @@ module.exports = {
       };
     }
 
-    function refersToReactFragment(name) {
-      const variableInit = variableUtil.findVariableByName(context, name);
+    function refersToReactFragment(node, name) {
+      const variableInit = variableUtil.findVariableByName(context, node, name);
       if (!variableInit) {
         return false;
       }
@@ -171,7 +170,12 @@ module.exports = {
       ImportDeclaration(node) {
         if (node.source && node.source.value === 'react') {
           node.specifiers.forEach((spec) => {
-            if (spec.imported && spec.imported.name === fragmentPragma) {
+            if (
+              'imported' in spec
+              && spec.imported
+              && 'name' in spec.imported
+              && spec.imported.name === fragmentPragma
+            ) {
               if (spec.local) {
                 fragmentNames.add(spec.local.name);
               }
@@ -185,7 +189,7 @@ module.exports = {
           const openingEl = node.openingElement;
           const elName = elementType(openingEl);
 
-          if (fragmentNames.has(elName) || refersToReactFragment(elName)) {
+          if (fragmentNames.has(elName) || refersToReactFragment(node, elName)) {
             if (reportOnReactVersion(node)) {
               return;
             }
diff --git a/lib/rules/jsx-handler-names.js b/lib/rules/jsx-handler-names.js
index e82db76474..f89f24413e 100644
--- a/lib/rules/jsx-handler-names.js
+++ b/lib/rules/jsx-handler-names.js
@@ -5,7 +5,9 @@
 
 'use strict';
 
+const minimatch = require('minimatch');
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -17,6 +19,15 @@ const messages = {
   badPropKey: 'Prop key for {{propValue}} must begin with \'{{handlerPropPrefix}}\'',
 };
 
+function isPrefixDisabled(prefix) {
+  return prefix === false;
+}
+
+function isInlineHandler(node) {
+  return node.value.expression.type === 'ArrowFunctionExpression';
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -37,6 +48,11 @@ module.exports = {
             eventHandlerPropPrefix: { type: 'string' },
             checkLocalVariables: { type: 'boolean' },
             checkInlineFunction: { type: 'boolean' },
+            ignoreComponentNames: {
+              type: 'array',
+              uniqueItems: true,
+              items: { type: 'string' },
+            },
           },
           additionalProperties: false,
         }, {
@@ -49,6 +65,11 @@ module.exports = {
             },
             checkLocalVariables: { type: 'boolean' },
             checkInlineFunction: { type: 'boolean' },
+            ignoreComponentNames: {
+              type: 'array',
+              uniqueItems: true,
+              items: { type: 'string' },
+            },
           },
           additionalProperties: false,
         }, {
@@ -61,6 +82,11 @@ module.exports = {
             eventHandlerPropPrefix: { type: 'string' },
             checkLocalVariables: { type: 'boolean' },
             checkInlineFunction: { type: 'boolean' },
+            ignoreComponentNames: {
+              type: 'array',
+              uniqueItems: true,
+              items: { type: 'string' },
+            },
           },
           additionalProperties: false,
         }, {
@@ -76,19 +102,21 @@ module.exports = {
           },
           additionalProperties: false,
         },
+        {
+          type: 'object',
+          properties: {
+            ignoreComponentNames: {
+              type: 'array',
+              uniqueItems: true,
+              items: { type: 'string' },
+            },
+          },
+        },
       ],
     }],
   },
 
   create(context) {
-    function isPrefixDisabled(prefix) {
-      return prefix === false;
-    }
-
-    function isInlineHandler(node) {
-      return node.value.expression.type === 'ArrowFunctionExpression';
-    }
-
     const configuration = context.options[0] || {};
 
     const eventHandlerPrefix = isPrefixDisabled(configuration.eventHandlerPrefix)
@@ -109,8 +137,17 @@ module.exports = {
 
     const checkInlineFunction = !!configuration.checkInlineFunction;
 
+    const ignoreComponentNames = configuration.ignoreComponentNames || [];
+
     return {
       JSXAttribute(node) {
+        const componentName = node.parent.name.name;
+
+        const isComponentNameIgnored = ignoreComponentNames.some((ignoredComponentNamePattern) => minimatch(
+          componentName,
+          ignoredComponentNamePattern
+        ));
+
         if (
           !node.value
           || !node.value.expression
@@ -122,16 +159,17 @@ module.exports = {
               : !node.value.expression.object
             )
           )
+          || isComponentNameIgnored
         ) {
           return;
         }
 
         const propKey = typeof node.name === 'object' ? node.name.name : node.name;
         const expression = node.value.expression;
-        const propValue = context.getSourceCode()
-          .getText(checkInlineFunction && isInlineHandler(node) ? expression.body.callee : expression)
-          .replace(/\s*/g, '')
-          .replace(/^this\.|.*::/, '');
+        const propValue = getText(
+          context,
+          checkInlineFunction && isInlineHandler(node) ? expression.body.callee : expression
+        ).replace(/\s*/g, '').replace(/^this\.|.*::/, '');
 
         if (propKey === 'ref') {
           return;
diff --git a/lib/rules/jsx-indent-props.js b/lib/rules/jsx-indent-props.js
index 0d971ac7ac..8504878731 100644
--- a/lib/rules/jsx-indent-props.js
+++ b/lib/rules/jsx-indent-props.js
@@ -30,8 +30,11 @@
 
 'use strict';
 
+const repeat = require('string.prototype.repeat');
+
 const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const reportC = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -42,6 +45,7 @@ const messages = {
   wrongIndent: 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -113,8 +117,8 @@ module.exports = {
     /**
      * Reports a given indent violation and properly pluralizes the message
      * @param {ASTNode} node Node violating the indent rule
-     * @param {Number} needed Expected indentation character count
-     * @param {Number} gotten Indentation character count in the actual node/code
+     * @param {number} needed Expected indentation character count
+     * @param {number} gotten Indentation character count in the actual node/code
      */
     function report(node, needed, gotten) {
       const msgContext = {
@@ -129,7 +133,8 @@ module.exports = {
         data: msgContext,
         fix(fixer) {
           return fixer.replaceTextRange([node.range[0] - node.loc.start.column, node.range[0]],
-            Array(needed + 1).join(indentType === 'space' ? ' ' : '\t'));
+            repeat(indentType === 'space' ? ' ' : '\t', needed)
+          );
         },
       });
     }
@@ -137,10 +142,10 @@ module.exports = {
     /**
      * Get node indent
      * @param {ASTNode} node Node to examine
-     * @return {Number} Indent
+     * @return {number} Indent
      */
     function getNodeIndent(node) {
-      let src = context.getSourceCode().getText(node, node.loc.start.column + extraColumnStart);
+      let src = getText(context, node, node.loc.start.column + extraColumnStart);
       const lines = src.split('\n');
       src = lines[0];
 
@@ -169,7 +174,7 @@ module.exports = {
     /**
      * Check indent for nodes list
      * @param {ASTNode[]} nodes list of node objects
-     * @param {Number} indent needed indent
+     * @param {number} indent needed indent
      */
     function checkNodesIndent(nodes, indent) {
       let nestedIndent = indent;
diff --git a/lib/rules/jsx-indent.js b/lib/rules/jsx-indent.js
index 9a86e6c03a..f27eca029d 100644
--- a/lib/rules/jsx-indent.js
+++ b/lib/rules/jsx-indent.js
@@ -31,11 +31,16 @@
 'use strict';
 
 const matchAll = require('string.prototype.matchall');
+const repeat = require('string.prototype.repeat');
 
 const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 const reportC = require('../util/report');
 const jsxUtil = require('../util/jsx');
+const eslintUtil = require('../util/eslint');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -45,6 +50,7 @@ const messages = {
   wrongIndent: 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -100,12 +106,12 @@ module.exports = {
     /**
      * Responsible for fixing the indentation issue fix
      * @param {ASTNode} node Node violating the indent rule
-     * @param {Number} needed Expected indentation character count
+     * @param {number} needed Expected indentation character count
      * @returns {Function} function to be executed by the fixer
      * @private
      */
     function getFixerFunction(node, needed) {
-      const indent = Array(needed + 1).join(indentChar);
+      const indent = repeat(indentChar, needed);
 
       if (node.type === 'JSXText' || node.type === 'Literal') {
         return function fix(fixer) {
@@ -116,7 +122,7 @@ module.exports = {
       }
 
       if (node.type === 'ReturnStatement') {
-        const raw = context.getSourceCode().getText(node);
+        const raw = getText(context, node);
         const lines = raw.split('\n');
         if (lines.length > 1) {
           return function fix(fixer) {
@@ -141,8 +147,8 @@ module.exports = {
     /**
      * Reports a given indent violation and properly pluralizes the message
      * @param {ASTNode} node Node violating the indent rule
-     * @param {Number} needed Expected indentation character count
-     * @param {Number} gotten Indentation character count in the actual node/code
+     * @param {number} needed Expected indentation character count
+     * @param {number} gotten Indentation character count in the actual node/code
      * @param {Object} [loc] Error line and column location
      */
     function report(node, needed, gotten, loc) {
@@ -163,12 +169,12 @@ module.exports = {
     /**
      * Get node indent
      * @param {ASTNode} node Node to examine
-     * @param {Boolean} [byLastLine] get indent of node's last line
-     * @param {Boolean} [excludeCommas] skip comma on start of line
-     * @return {Number} Indent
+     * @param {boolean} [byLastLine] get indent of node's last line
+     * @param {boolean} [excludeCommas] skip comma on start of line
+     * @return {number} Indent
      */
     function getNodeIndent(node, byLastLine, excludeCommas) {
-      let src = context.getSourceCode().getText(node, node.loc.start.column + extraColumnStart);
+      let src = getText(context, node, node.loc.start.column + extraColumnStart);
       const lines = src.split('\n');
       if (byLastLine) {
         src = lines[lines.length - 1];
@@ -192,7 +198,7 @@ module.exports = {
     /**
      * Check if the node is the right member of a logical expression
      * @param {ASTNode} node The node to check
-     * @return {Boolean} true if its the case, false if not
+     * @return {boolean} true if its the case, false if not
      */
     function isRightInLogicalExp(node) {
       return (
@@ -207,7 +213,7 @@ module.exports = {
     /**
      * Check if the node is the alternate member of a conditional expression
      * @param {ASTNode} node The node to check
-     * @return {Boolean} true if its the case, false if not
+     * @return {boolean} true if its the case, false if not
      */
     function isAlternateInConditionalExp(node) {
       return (
@@ -215,14 +221,14 @@ module.exports = {
         && node.parent.parent
         && node.parent.parent.type === 'ConditionalExpression'
         && node.parent.parent.alternate === node.parent
-        && context.getSourceCode().getTokenBefore(node).value !== '('
+        && getSourceCode(context).getTokenBefore(node).value !== '('
       );
     }
 
     /**
      * Check if the node is within a DoExpression block but not the first expression (which need to be indented)
      * @param {ASTNode} node The node to check
-     * @return {Boolean} true if its the case, false if not
+     * @return {boolean} true if its the case, false if not
      */
     function isSecondOrSubsequentExpWithinDoExp(node) {
       /*
@@ -293,8 +299,8 @@ module.exports = {
     /**
      * Check indent for nodes list
      * @param {ASTNode} node The node to check
-     * @param {Number} indent needed indent
-     * @param {Boolean} [excludeCommas] skip comma on start of line
+     * @param {number} indent needed indent
+     * @param {boolean} [excludeCommas] skip comma on start of line
      */
     function checkNodesIndent(node, indent, excludeCommas) {
       const nodeIndent = getNodeIndent(node, false, excludeCommas);
@@ -313,7 +319,7 @@ module.exports = {
     /**
      * Check indent for Literal Node or JSXText Node
      * @param {ASTNode} node The node to check
-     * @param {Number} indent needed indent
+     * @param {number} indent needed indent
      */
     function checkLiteralNodeIndent(node, indent) {
       const value = node.value;
@@ -334,7 +340,7 @@ module.exports = {
     }
 
     function handleOpeningElement(node) {
-      const sourceCode = context.getSourceCode();
+      const sourceCode = getSourceCode(context);
       let prevToken = sourceCode.getTokenBefore(node);
       if (!prevToken) {
         return;
@@ -377,7 +383,7 @@ module.exports = {
         return;
       }
       const nameIndent = getNodeIndent(node.name);
-      const lastToken = context.getSourceCode().getLastToken(node.value);
+      const lastToken = getSourceCode(context).getLastToken(node.value);
       const firstInLine = astUtil.getFirstNodeInLine(context, lastToken);
       const indent = node.name.loc.start.line === firstInLine.loc.start.line ? 0 : nameIndent;
       checkNodesIndent(firstInLine, indent);
@@ -424,7 +430,7 @@ module.exports = {
         }
         if (
           !fn
-          || !jsxUtil.isReturningJSX(node, context, true)
+          || !jsxUtil.isReturningJSX(context, node, true)
         ) {
           return;
         }
diff --git a/lib/rules/jsx-key.js b/lib/rules/jsx-key.js
index c13a00cf83..825d21f4bb 100644
--- a/lib/rules/jsx-key.js
+++ b/lib/rules/jsx-key.js
@@ -12,6 +12,7 @@ const docsUrl = require('../util/docsUrl');
 const pragmaUtil = require('../util/pragma');
 const report = require('../util/report');
 const astUtil = require('../util/ast');
+const getText = require('../util/eslint').getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -32,6 +33,7 @@ const messages = {
   nonUniqueKeys: '`key` prop must be unique',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -71,11 +73,31 @@ module.exports = {
     const reactPragma = pragmaUtil.getFromContext(context);
     const fragmentPragma = pragmaUtil.getFragmentFromContext(context);
 
+    function isKeyAfterSpread(attributes) {
+      let hasFoundSpread = false;
+      return attributes.some((attribute) => {
+        if (attribute.type === 'JSXSpreadAttribute') {
+          hasFoundSpread = true;
+          return false;
+        }
+        if (attribute.type !== 'JSXAttribute') {
+          return false;
+        }
+        return hasFoundSpread && propName(attribute) === 'key';
+      });
+    }
+
     function checkIteratorElement(node) {
-      if (node.type === 'JSXElement' && !hasProp(node.openingElement.attributes, 'key')) {
-        report(context, messages.missingIterKey, 'missingIterKey', {
-          node,
-        });
+      if (node.type === 'JSXElement') {
+        if (!hasProp(node.openingElement.attributes, 'key')) {
+          report(context, messages.missingIterKey, 'missingIterKey', { node });
+        } else {
+          const attrs = node.openingElement.attributes;
+
+          if (checkKeyMustBeforeSpread && isKeyAfterSpread(attrs)) {
+            report(context, messages.keyBeforeSpread, 'keyBeforeSpread', { node });
+          }
+        }
       } else if (checkFragmentShorthand && node.type === 'JSXFragment') {
         report(context, messages.missingIterKeyUsePrag, 'missingIterKeyUsePrag', {
           node,
@@ -113,20 +135,6 @@ module.exports = {
       return returnStatements;
     }
 
-    function isKeyAfterSpread(attributes) {
-      let hasFoundSpread = false;
-      return attributes.some((attribute) => {
-        if (attribute.type === 'JSXSpreadAttribute') {
-          hasFoundSpread = true;
-          return false;
-        }
-        if (attribute.type !== 'JSXAttribute') {
-          return false;
-        }
-        return hasFoundSpread && propName(attribute) === 'key';
-      });
-    }
-
     /**
      * Checks if the given node is a function expression or arrow function,
      * and checks if there is a missing key prop in return statement's arguments
@@ -212,7 +220,7 @@ module.exports = {
             }
           } else {
             keys.forEach((attr) => {
-              const value = context.getSourceCode().getText(attr.value);
+              const value = getText(context, attr.value);
               if (!map[value]) { map[value] = []; }
               map[value].push(attr);
 
diff --git a/lib/rules/jsx-max-depth.js b/lib/rules/jsx-max-depth.js
index 2ea6653351..12625fa704 100644
--- a/lib/rules/jsx-max-depth.js
+++ b/lib/rules/jsx-max-depth.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const includes = require('array-includes');
 const variableUtil = require('../util/variable');
 const jsxUtil = require('../util/jsx');
@@ -20,6 +20,7 @@ const messages = {
   wrongDepth: 'Expected the depth of nested jsx elements to be <= {{needed}}, but found {{found}}.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -87,23 +88,23 @@ module.exports = {
       });
     }
 
-    function findJSXElementOrFragment(variables, name, previousReferences) {
+    function findJSXElementOrFragment(startNode, name, previousReferences) {
       function find(refs, prevRefs) {
         for (let i = refs.length - 1; i >= 0; i--) {
-          if (has(refs[i], 'writeExpr')) {
+          if (typeof refs[i].writeExpr !== 'undefined') {
             const writeExpr = refs[i].writeExpr;
 
             return (jsxUtil.isJSX(writeExpr)
               && writeExpr)
               || ((writeExpr && writeExpr.type === 'Identifier')
-              && findJSXElementOrFragment(variables, writeExpr.name, prevRefs));
+              && findJSXElementOrFragment(startNode, writeExpr.name, prevRefs));
           }
         }
 
         return null;
       }
 
-      const variable = variableUtil.getVariable(variables, name);
+      const variable = variableUtil.getVariableFromContext(context, startNode, name);
       if (variable && variable.references) {
         const containDuplicates = previousReferences.some((ref) => includes(variable.references, ref));
 
@@ -149,8 +150,7 @@ module.exports = {
           return;
         }
 
-        const variables = variableUtil.variablesInScope(context);
-        const element = findJSXElementOrFragment(variables, node.expression.name, []);
+        const element = findJSXElementOrFragment(node, node.expression.name, []);
 
         if (element) {
           const baseDepth = getDepth(node);
diff --git a/lib/rules/jsx-max-props-per-line.js b/lib/rules/jsx-max-props-per-line.js
index 89e8748521..eebf7f0f33 100644
--- a/lib/rules/jsx-max-props-per-line.js
+++ b/lib/rules/jsx-max-props-per-line.js
@@ -6,11 +6,12 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const report = require('../util/report');
 
 function getPropName(context, propNode) {
   if (propNode.type === 'JSXSpreadAttribute') {
-    return context.getSourceCode().getText(propNode.argument);
+    return getText(context, propNode.argument);
   }
   return propNode.name.name;
 }
@@ -23,6 +24,7 @@ const messages = {
   newLine: 'Prop `{{prop}}` must be placed on a new line',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -86,7 +88,6 @@ module.exports = {
       };
 
     function generateFixFunction(line, max) {
-      const sourceCode = context.getSourceCode();
       const output = [];
       const front = line[0].range[0];
       const back = line[line.length - 1].range[1];
@@ -95,9 +96,9 @@ module.exports = {
         const nodes = line.slice(i, i + max);
         output.push(nodes.reduce((prev, curr) => {
           if (prev === '') {
-            return sourceCode.getText(curr);
+            return getText(context, curr);
           }
-          return `${prev} ${sourceCode.getText(curr)}`;
+          return `${prev} ${getText(context, curr)}`;
         }, ''));
       }
 
diff --git a/lib/rules/jsx-newline.js b/lib/rules/jsx-newline.js
index b4408e7cd8..7fd395c72f 100644
--- a/lib/rules/jsx-newline.js
+++ b/lib/rules/jsx-newline.js
@@ -7,6 +7,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -23,6 +24,7 @@ function isMultilined(node) {
   return node && node.loc.start.line !== node.loc.end.line;
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -70,10 +72,9 @@ module.exports = {
   },
   create(context) {
     const jsxElementParents = new Set();
-    const sourceCode = context.getSourceCode();
 
     function isBlockCommentInCurlyBraces(element) {
-      const elementRawValue = sourceCode.getText(element);
+      const elementRawValue = getText(context, element);
       return /^\s*{\/\*/.test(elementRawValue);
     }
 
@@ -121,8 +122,7 @@ module.exports = {
                   fix(fixer) {
                     return fixer.replaceText(
                       firstAdjacentSibling,
-                      sourceCode.getText(firstAdjacentSibling)
-                        .replace(regex, replacement)
+                      getText(context, firstAdjacentSibling).replace(regex, replacement)
                     );
                   },
                 });
@@ -150,8 +150,7 @@ module.exports = {
                   return fixer.replaceText(
                     firstAdjacentSibling,
                     // double or remove the last newline
-                    sourceCode.getText(firstAdjacentSibling)
-                      .replace(regex, replacement)
+                    getText(context, firstAdjacentSibling).replace(regex, replacement)
                   );
                 },
               });
diff --git a/lib/rules/jsx-no-bind.js b/lib/rules/jsx-no-bind.js
index 17e56e2e04..2e8aa687dc 100644
--- a/lib/rules/jsx-no-bind.js
+++ b/lib/rules/jsx-no-bind.js
@@ -9,8 +9,10 @@
 
 const propName = require('jsx-ast-utils/propName');
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
+const getAncestors = require('../util/eslint').getAncestors;
 
 // -----------------------------------------------------------------------------
 // Rule Definition
@@ -23,6 +25,7 @@ const messages = {
   func: 'JSX props should not use functions',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -82,31 +85,30 @@ module.exports = {
     }
 
     function getNodeViolationType(node) {
-      const nodeType = node.type;
       if (
         !configuration.allowBind
-        && nodeType === 'CallExpression'
+        && astUtil.isCallExpression(node)
         && node.callee.type === 'MemberExpression'
         && node.callee.property.type === 'Identifier'
         && node.callee.property.name === 'bind'
       ) {
         return 'bindCall';
       }
-      if (nodeType === 'ConditionalExpression') {
+      if (node.type === 'ConditionalExpression') {
         return getNodeViolationType(node.test)
                || getNodeViolationType(node.consequent)
                || getNodeViolationType(node.alternate);
       }
-      if (!configuration.allowArrowFunctions && nodeType === 'ArrowFunctionExpression') {
+      if (!configuration.allowArrowFunctions && node.type === 'ArrowFunctionExpression') {
         return 'arrowFunc';
       }
       if (
         !configuration.allowFunctions
-        && (nodeType === 'FunctionExpression' || nodeType === 'FunctionDeclaration')
+        && (node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration')
       ) {
         return 'func';
       }
-      if (!configuration.allowBind && nodeType === 'BindExpression') {
+      if (!configuration.allowBind && node.type === 'BindExpression') {
         return 'bindExpression';
       }
 
@@ -115,7 +117,7 @@ module.exports = {
 
     /**
      * @param {string | number} violationType
-     * @param {any} variableName
+     * @param {unknown} variableName
      * @param {string | number} blockStart
      */
     function addVariableNameToSet(violationType, variableName, blockStart) {
@@ -123,7 +125,7 @@ module.exports = {
     }
 
     function getBlockStatementAncestors(node) {
-      return context.getAncestors(node).filter(
+      return getAncestors(context, node).filter(
         (ancestor) => ancestor.type === 'BlockStatement'
       ).reverse();
     }
@@ -174,11 +176,10 @@ module.exports = {
         if (
           blockAncestors.length > 0
           && variableViolationType
+          && 'kind' in node.parent
           && node.parent.kind === 'const' // only support const right now
         ) {
-          addVariableNameToSet(
-            variableViolationType, node.id.name, blockAncestors[0].range[0]
-          );
+          addVariableNameToSet(variableViolationType, 'name' in node.id ? node.id.name : undefined, blockAncestors[0].range[0]);
         }
       },
 
diff --git a/lib/rules/jsx-no-comment-textnodes.js b/lib/rules/jsx-no-comment-textnodes.js
index b33cea0cce..de4d288c37 100644
--- a/lib/rules/jsx-no-comment-textnodes.js
+++ b/lib/rules/jsx-no-comment-textnodes.js
@@ -6,6 +6,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -16,9 +17,14 @@ const messages = {
   putCommentInBraces: 'Comments inside children section of tag should be placed inside braces',
 };
 
-function checkText(node, context) {
+/**
+ * @param {Context} context
+ * @param {ASTNode} node
+ * @returns {void}
+ */
+function checkText(context, node) {
   // since babel-eslint has the wrong node.raw, we'll get the source text
-  const rawValue = context.getSourceCode().getText(node);
+  const rawValue = getText(context, node);
   if (/^\s*\/(\/|\*)/m.test(rawValue)) {
     // inside component, e.g. <div>literal</div>
     if (
@@ -33,6 +39,7 @@ function checkText(node, context) {
   }
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -54,10 +61,10 @@ module.exports = {
 
     return {
       Literal(node) {
-        checkText(node, context);
+        checkText(context, node);
       },
       JSXText(node) {
-        checkText(node, context);
+        checkText(context, node);
       },
     };
   },
diff --git a/lib/rules/jsx-no-constructed-context-values.js b/lib/rules/jsx-no-constructed-context-values.js
index 8bcf045dad..19af331253 100644
--- a/lib/rules/jsx-no-constructed-context-values.js
+++ b/lib/rules/jsx-no-constructed-context-values.js
@@ -8,6 +8,7 @@
 
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const getScope = require('../util/eslint').getScope;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -118,6 +119,45 @@ function isConstruction(node, callScope) {
   }
 }
 
+function isReactContext(context, node) {
+  let scope = getScope(context, node);
+  let variableScoping = null;
+  const contextName = node.name;
+
+  while (scope && !variableScoping) { // Walk up the scope chain to find the variable
+    variableScoping = scope.set.get(contextName);
+    scope = scope.upper;
+  }
+
+  if (!variableScoping) { // Context was not found in scope
+    return false;
+  }
+
+  // Get the variable's definition
+  const def = variableScoping.defs[0];
+
+  if (!def || def.node.type !== 'VariableDeclarator') {
+    return false;
+  }
+
+  const init = def.node.init; // Variable initializer
+
+  const isCreateContext = init
+    && init.type === 'CallExpression'
+    && (
+      (
+        init.callee.type === 'Identifier'
+        && init.callee.name === 'createContext'
+      ) || (
+        init.callee.type === 'MemberExpression'
+        && init.callee.object.name === 'React'
+        && init.callee.property.name === 'createContext'
+      )
+    );
+
+  return isCreateContext;
+}
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -129,6 +169,7 @@ const messages = {
   defaultMsgFunc: 'The {{type}} passed as the value prop to the Context provider (at line {{nodeLine}}) changes every render. To fix this consider wrapping it in a useCallback hook.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -138,7 +179,7 @@ module.exports = {
       url: docsUrl('jsx-no-constructed-context-values'),
     },
     messages,
-    schema: {},
+    schema: false,
   },
 
   // eslint-disable-next-line arrow-body-style
@@ -146,14 +187,20 @@ module.exports = {
     return {
       JSXOpeningElement(node) {
         const openingElementName = node.name;
-        if (openingElementName.type !== 'JSXMemberExpression') {
-          // Has no member
-          return;
-        }
 
-        const isJsxContext = openingElementName.property.name === 'Provider';
-        if (!isJsxContext) {
-          // Member is not Provider
+        if (openingElementName.type === 'JSXMemberExpression') {
+          const isJSXContext = openingElementName.property.name === 'Provider';
+          if (!isJSXContext) {
+            // Member is not Provider
+            return;
+          }
+        } else if (openingElementName.type === 'JSXIdentifier') {
+          const isJSXContext = isReactContext(context, openingElementName);
+          if (!isJSXContext) {
+            // Member is not context
+            return;
+          }
+        } else {
           return;
         }
 
@@ -179,7 +226,7 @@ module.exports = {
         }
 
         const valueExpression = valueNode.expression;
-        const invocationScope = context.getScope();
+        const invocationScope = getScope(context, node);
 
         // Check if the value prop is a construction
         const constructInfo = isConstruction(valueExpression, invocationScope);
diff --git a/lib/rules/jsx-no-duplicate-props.js b/lib/rules/jsx-no-duplicate-props.js
index 41e17828e2..77de5bde51 100644
--- a/lib/rules/jsx-no-duplicate-props.js
+++ b/lib/rules/jsx-no-duplicate-props.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
 
@@ -17,6 +17,7 @@ const messages = {
   noDuplicateProps: 'No duplicate props allowed',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-no-leaked-render.js b/lib/rules/jsx-no-leaked-render.js
index 05f319edbf..1e271b2a68 100644
--- a/lib/rules/jsx-no-leaked-render.js
+++ b/lib/rules/jsx-no-leaked-render.js
@@ -8,8 +8,10 @@
 const find = require('es-iterator-helpers/Iterator.prototype.find');
 const from = require('es-iterator-helpers/Iterator.from');
 
+const getText = require('../util/eslint').getText;
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const variableUtil = require('../util/variable');
 const testReactVersion = require('../util/version').testReactVersion;
 const isParenthesized = require('../util/ast').isParenthesized;
 
@@ -54,13 +56,12 @@ function extractExpressionBetweenLogicalAnds(node) {
 }
 
 function ruleFixer(context, fixStrategy, fixer, reportedNode, leftNode, rightNode) {
-  const sourceCode = context.getSourceCode();
-  const rightSideText = sourceCode.getText(rightNode);
+  const rightSideText = getText(context, rightNode);
 
   if (fixStrategy === COERCE_STRATEGY) {
     const expressions = extractExpressionBetweenLogicalAnds(leftNode);
     const newText = expressions.map((node) => {
-      let nodeText = sourceCode.getText(node);
+      let nodeText = getText(context, node);
       if (isParenthesized(context, node)) {
         nodeText = `(${nodeText})`;
       }
@@ -79,7 +80,7 @@ function ruleFixer(context, fixStrategy, fixer, reportedNode, leftNode, rightNod
       return fixer.replaceText(reportedNode, `${newText} && ${alternateVal}`);
     }
 
-    if (rightNode.type === 'ConditionalExpression') {
+    if (rightNode.type === 'ConditionalExpression' || rightNode.type === 'LogicalExpression') {
       return fixer.replaceText(reportedNode, `${newText} && (${rightSideText})`);
     }
     if (rightNode.type === 'JSXElement') {
@@ -98,7 +99,7 @@ function ruleFixer(context, fixStrategy, fixer, reportedNode, leftNode, rightNod
   }
 
   if (fixStrategy === TERNARY_STRATEGY) {
-    let leftSideText = sourceCode.getText(trimLeftNode(leftNode));
+    let leftSideText = getText(context, trimLeftNode(leftNode));
     if (isParenthesized(context, leftNode)) {
       leftSideText = `(${leftSideText})`;
     }
@@ -108,9 +109,7 @@ function ruleFixer(context, fixStrategy, fixer, reportedNode, leftNode, rightNod
   throw new TypeError('Invalid value for "validStrategies" option');
 }
 
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -159,6 +158,16 @@ module.exports = {
           if (isCoerceValidLeftSide || getIsCoerceValidNestedLogicalExpression(leftSide)) {
             return;
           }
+          const leftSideVar = variableUtil.getVariableFromContext(context, node, leftSide.name);
+          if (leftSideVar) {
+            const leftSideValue = leftSideVar.defs
+              && leftSideVar.defs.length
+              && leftSideVar.defs[0].node.init
+              && leftSideVar.defs[0].node.init.value;
+            if (typeof leftSideValue === 'boolean') {
+              return;
+            }
+          }
         }
 
         if (testReactVersion(context, '>= 18') && leftSide.type === 'Literal' && leftSide.value === '') {
diff --git a/lib/rules/jsx-no-literals.js b/lib/rules/jsx-no-literals.js
index 41e6d0b828..45c9a54c48 100644
--- a/lib/rules/jsx-no-literals.js
+++ b/lib/rules/jsx-no-literals.js
@@ -8,27 +8,147 @@
 
 const iterFrom = require('es-iterator-helpers/Iterator.from');
 const map = require('es-iterator-helpers/Iterator.prototype.map');
+const some = require('es-iterator-helpers/Iterator.prototype.some');
+const flatMap = require('es-iterator-helpers/Iterator.prototype.flatMap');
+const fromEntries = require('object.fromentries');
+const entries = require('object.entries');
 
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
+
+/** @typedef {import('eslint').Rule.RuleModule} RuleModule */
+
+/** @typedef {import('../../types/rules/jsx-no-literals').Config} Config */
+/** @typedef {import('../../types/rules/jsx-no-literals').RawConfig} RawConfig */
+/** @typedef {import('../../types/rules/jsx-no-literals').ResolvedConfig} ResolvedConfig */
+/** @typedef {import('../../types/rules/jsx-no-literals').OverrideConfig} OverrideConfig */
+/** @typedef {import('../../types/rules/jsx-no-literals').ElementConfig} ElementConfig */
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-function trimIfString(val) {
-  return typeof val === 'string' ? val.trim() : val;
+/**
+ * @param {unknown} value
+ * @returns {string | unknown}
+ */
+function trimIfString(value) {
+  return typeof value === 'string' ? value.trim() : value;
 }
 
+const reOverridableElement = /^[A-Z][\w.]*$/;
+const reIsWhiteSpace = /^[\s]+$/;
+const jsxElementTypes = new Set(['JSXElement', 'JSXFragment']);
+const standardJSXNodeParentTypes = new Set(['JSXAttribute', 'JSXElement', 'JSXExpressionContainer', 'JSXFragment']);
+
 const messages = {
   invalidPropValue: 'Invalid prop value: "{{text}}"',
+  invalidPropValueInElement: 'Invalid prop value: "{{text}}" in {{element}}',
   noStringsInAttributes: 'Strings not allowed in attributes: "{{text}}"',
+  noStringsInAttributesInElement: 'Strings not allowed in attributes: "{{text}}" in {{element}}',
   noStringsInJSX: 'Strings not allowed in JSX files: "{{text}}"',
+  noStringsInJSXInElement: 'Strings not allowed in JSX files: "{{text}}" in {{element}}',
   literalNotInJSXExpression: 'Missing JSX expression container around literal string: "{{text}}"',
+  literalNotInJSXExpressionInElement: 'Missing JSX expression container around literal string: "{{text}}" in {{element}}',
 };
 
+/** @type {Exclude<RuleModule['meta']['schema'], unknown[] | false>['properties']} */
+const commonPropertiesSchema = {
+  noStrings: {
+    type: 'boolean',
+  },
+  allowedStrings: {
+    type: 'array',
+    uniqueItems: true,
+    items: {
+      type: 'string',
+    },
+  },
+  ignoreProps: {
+    type: 'boolean',
+  },
+  noAttributeStrings: {
+    type: 'boolean',
+  },
+};
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Normalizes the element portion of the config
+ * @param {RawConfig} config
+ * @returns {ElementConfig}
+ */
+function normalizeElementConfig(config) {
+  return {
+    type: 'element',
+    noStrings: !!config.noStrings,
+    allowedStrings: config.allowedStrings
+      ? new Set(map(iterFrom(config.allowedStrings), trimIfString))
+      : new Set(),
+    ignoreProps: !!config.ignoreProps,
+    noAttributeStrings: !!config.noAttributeStrings,
+  };
+}
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Normalizes the config and applies default values to all config options
+ * @param {RawConfig} config
+ * @returns {Config}
+ */
+function normalizeConfig(config) {
+  /** @type {Config} */
+  const normalizedConfig = Object.assign(normalizeElementConfig(config), {
+    elementOverrides: {},
+  });
+
+  if (config.elementOverrides) {
+    normalizedConfig.elementOverrides = fromEntries(
+      flatMap(
+        iterFrom(entries(config.elementOverrides)),
+        (entry) => {
+          const elementName = entry[0];
+          const rawElementConfig = entry[1];
+
+          if (!reOverridableElement.test(elementName)) {
+            return [];
+          }
+
+          return [[
+            elementName,
+            Object.assign(normalizeElementConfig(rawElementConfig), {
+              type: 'override',
+              name: elementName,
+              allowElement: !!rawElementConfig.allowElement,
+              applyToNestedElements: typeof rawElementConfig.applyToNestedElements === 'undefined' || !!rawElementConfig.applyToNestedElements,
+            }),
+          ]];
+        }
+      )
+    );
+  }
+
+  return normalizedConfig;
+}
+
+const elementOverrides = {
+  type: 'object',
+  patternProperties: {
+    [reOverridableElement.source]: {
+      type: 'object',
+      properties: Object.assign(
+        { applyToNestedElements: { type: 'boolean' } },
+        commonPropertiesSchema
+      ),
+
+    },
+  },
+};
+
+/** @type {RuleModule} */
 module.exports = {
-  meta: {
+  meta: /** @type {RuleModule['meta']} */ ({
     docs: {
       description: 'Disallow usage of string literals in JSX',
       category: 'Stylistic Issues',
@@ -40,115 +160,260 @@ module.exports = {
 
     schema: [{
       type: 'object',
-      properties: {
-        noStrings: {
-          type: 'boolean',
-        },
-        allowedStrings: {
-          type: 'array',
-          uniqueItems: true,
-          items: {
-            type: 'string',
-          },
-        },
-        ignoreProps: {
-          type: 'boolean',
-        },
-        noAttributeStrings: {
-          type: 'boolean',
-        },
-      },
+      properties: Object.assign(
+        { elementOverrides },
+        commonPropertiesSchema
+      ),
       additionalProperties: false,
     }],
-  },
+  }),
 
   create(context) {
-    const defaults = {
-      noStrings: false,
-      allowedStrings: [],
-      ignoreProps: false,
-      noAttributeStrings: false,
-    };
-    const config = Object.assign({}, defaults, context.options[0] || {});
-    config.allowedStrings = new Set(map(iterFrom(config.allowedStrings), trimIfString));
-
-    function defaultMessageId() {
-      const ancestorIsJSXElement = arguments.length >= 1 && arguments[0];
-      if (config.noAttributeStrings && !ancestorIsJSXElement) {
-        return 'noStringsInAttributes';
+    /** @type {RawConfig} */
+    const rawConfig = (context.options.length && context.options[0]) || {};
+    const config = normalizeConfig(rawConfig);
+
+    const hasElementOverrides = Object.keys(config.elementOverrides).length > 0;
+
+    /** @type {Map<string, string>} */
+    const renamedImportMap = new Map();
+
+    /**
+     * Determines if the given expression is a require statement. Supports
+     * nested MemberExpresions. ie `require('foo').nested.property`
+     * @param {ASTNode} node
+     * @returns {boolean}
+     */
+    function isRequireStatement(node) {
+      if (node.type === 'CallExpression') {
+        if (node.callee.type === 'Identifier') {
+          return node.callee.name === 'require';
+        }
       }
-      if (config.noStrings) {
-        return 'noStringsInJSX';
+      if (node.type === 'MemberExpression') {
+        return isRequireStatement(node.object);
       }
-      return 'literalNotInJSXExpression';
-    }
 
-    function getParentIgnoringBinaryExpressions(node) {
-      let current = node;
-      while (current.parent.type === 'BinaryExpression') {
-        current = current.parent;
-      }
-      return current.parent;
+      return false;
     }
 
-    function getValidation(node) {
-      const values = [trimIfString(node.raw), trimIfString(node.value)];
-      if (values.some((value) => config.allowedStrings.has(value))) {
-        return false;
+    /** @typedef {{ name: string, compoundName?: string }} ElementNameFragment */
+
+    /**
+     * Gets the name of the given JSX element. Supports nested
+     * JSXMemeberExpressions. ie `<Namesapce.Component.SubComponent />`
+     * @param {ASTNode} node
+     * @returns {ElementNameFragment | undefined}
+     */
+    function getJSXElementName(node) {
+      if (node.openingElement.name.type === 'JSXIdentifier') {
+        const name = node.openingElement.name.name;
+        return {
+          name: renamedImportMap.get(name) || name,
+          compoundName: undefined,
+        };
       }
 
-      const parent = getParentIgnoringBinaryExpressions(node);
+      /** @type {string[]} */
+      const nameFragments = [];
 
-      function isParentNodeStandard() {
-        if (!/^[\s]+$/.test(node.value) && typeof node.value === 'string' && parent.type.includes('JSX')) {
-          if (config.noAttributeStrings) {
-            return parent.type === 'JSXAttribute' || parent.type === 'JSXElement';
+      if (node.openingElement.name.type === 'JSXMemberExpression') {
+        /** @type {ASTNode} */
+        let current = node.openingElement.name;
+        while (current.type === 'JSXMemberExpression') {
+          if (current.property.type === 'JSXIdentifier') {
+            nameFragments.unshift(current.property.name);
           }
-          if (!config.noAttributeStrings) {
-            return parent.type !== 'JSXAttribute';
+
+          current = current.object;
+        }
+
+        if (current.type === 'JSXIdentifier') {
+          nameFragments.unshift(current.name);
+
+          const rootFragment = nameFragments[0];
+          if (rootFragment) {
+            const rootFragmentRenamed = renamedImportMap.get(rootFragment);
+            if (rootFragmentRenamed) {
+              nameFragments[0] = rootFragmentRenamed;
+            }
+          }
+
+          const nameFragment = nameFragments[nameFragments.length - 1];
+          if (nameFragment) {
+            return {
+              name: nameFragment,
+              compoundName: nameFragments.join('.'),
+            };
           }
         }
+      }
+    }
 
-        return false;
+    /**
+     * Gets all JSXElement ancestor nodes for the given node
+     * @param {ASTNode} node
+     * @returns {ASTNode[]}
+     */
+    function getJSXElementAncestors(node) {
+      /** @type {ASTNode[]} */
+      const ancestors = [];
+
+      let current = node;
+      while (current) {
+        if (current.type === 'JSXElement') {
+          ancestors.push(current);
+        }
+
+        current = current.parent;
       }
 
-      const standard = isParentNodeStandard();
+      return ancestors;
+    }
 
-      if (config.noStrings) {
-        return standard;
+    /**
+     * @param {ASTNode} node
+     * @returns {ASTNode}
+     */
+    function getParentIgnoringBinaryExpressions(node) {
+      let current = node;
+      while (current.parent.type === 'BinaryExpression') {
+        current = current.parent;
       }
-      return standard && parent.type !== 'JSXExpressionContainer';
+      return current.parent;
     }
 
-    function getParentAndGrandParentType(node) {
+    /**
+     * @param {ASTNode} node
+     * @returns {{ parent: ASTNode, grandParent: ASTNode }}
+     */
+    function getParentAndGrandParent(node) {
       const parent = getParentIgnoringBinaryExpressions(node);
-      const parentType = parent.type;
-      const grandParentType = parent.parent.type;
-
       return {
         parent,
-        parentType,
-        grandParentType,
         grandParent: parent.parent,
       };
     }
 
+    /**
+     * @param {ASTNode} node
+     * @returns {boolean}
+     */
     function hasJSXElementParentOrGrandParent(node) {
-      const parents = getParentAndGrandParentType(node);
-      const parentType = parents.parentType;
-      const grandParentType = parents.grandParentType;
+      const ancestors = getParentAndGrandParent(node);
+      return some(iterFrom([ancestors.parent, ancestors.grandParent]), (parent) => jsxElementTypes.has(parent.type));
+    }
+
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * Determines whether a given node's value and its immediate parent are
+     * viable text nodes that can/should be reported on
+     * @param {ASTNode} node
+     * @param {ResolvedConfig} resolvedConfig
+     * @returns {boolean}
+     */
+    function isViableTextNode(node, resolvedConfig) {
+      const textValues = iterFrom([trimIfString(node.raw), trimIfString(node.value)]);
+      if (some(textValues, (value) => resolvedConfig.allowedStrings.has(value))) {
+        return false;
+      }
+
+      const parent = getParentIgnoringBinaryExpressions(node);
+
+      let isStandardJSXNode = false;
+      if (typeof node.value === 'string' && !reIsWhiteSpace.test(node.value) && standardJSXNodeParentTypes.has(parent.type)) {
+        if (resolvedConfig.noAttributeStrings) {
+          isStandardJSXNode = parent.type === 'JSXAttribute' || parent.type === 'JSXElement';
+        } else {
+          isStandardJSXNode = parent.type !== 'JSXAttribute';
+        }
+      }
+
+      if (resolvedConfig.noStrings) {
+        return isStandardJSXNode;
+      }
+
+      return isStandardJSXNode && parent.type !== 'JSXExpressionContainer';
+    }
+
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * Gets an override config for a given node. For any given node, we also
+     * need to traverse the ancestor tree to determine if an ancestor's config
+     * will also apply to the current node.
+     * @param {ASTNode} node
+     * @returns {OverrideConfig | undefined}
+     */
+    function getOverrideConfig(node) {
+      if (!hasElementOverrides) {
+        return;
+      }
 
-      return parentType === 'JSXFragment' || parentType === 'JSXElement' || grandParentType === 'JSXElement';
+      const allAncestorElements = getJSXElementAncestors(node);
+      if (!allAncestorElements.length) {
+        return;
+      }
+
+      for (const ancestorElement of allAncestorElements) {
+        const isClosestJSXAncestor = ancestorElement === allAncestorElements[0];
+
+        const ancestor = getJSXElementName(ancestorElement);
+        if (ancestor) {
+          if (ancestor.name) {
+            const ancestorElements = config.elementOverrides[ancestor.name];
+            const ancestorConfig = ancestor.compoundName
+              ? config.elementOverrides[ancestor.compoundName] || ancestorElements
+              : ancestorElements;
+
+            if (ancestorConfig) {
+              if (isClosestJSXAncestor || ancestorConfig.applyToNestedElements) {
+                return ancestorConfig;
+              }
+            }
+          }
+        }
+      }
     }
 
-    function reportLiteralNode(node, messageId) {
-      const ancestorIsJSXElement = hasJSXElementParentOrGrandParent(node);
-      messageId = messageId || defaultMessageId(ancestorIsJSXElement);
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {ResolvedConfig} resolvedConfig
+     * @returns {boolean}
+     */
+    function shouldAllowElement(resolvedConfig) {
+      return resolvedConfig.type === 'override' && 'allowElement' in resolvedConfig && !!resolvedConfig.allowElement;
+    }
 
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {boolean} ancestorIsJSXElement
+     * @param {ResolvedConfig} resolvedConfig
+     * @returns {string}
+     */
+    function defaultMessageId(ancestorIsJSXElement, resolvedConfig) {
+      if (resolvedConfig.noAttributeStrings && !ancestorIsJSXElement) {
+        return resolvedConfig.type === 'override' ? 'noStringsInAttributesInElement' : 'noStringsInAttributes';
+      }
+
+      if (resolvedConfig.noStrings) {
+        return resolvedConfig.type === 'override' ? 'noStringsInJSXInElement' : 'noStringsInJSX';
+      }
+
+      return resolvedConfig.type === 'override' ? 'literalNotInJSXExpressionInElement' : 'literalNotInJSXExpression';
+    }
+
+    // eslint-disable-next-line valid-jsdoc
+    /**
+     * @param {ASTNode} node
+     * @param {string} messageId
+     * @param {ResolvedConfig} resolvedConfig
+     */
+    function reportLiteralNode(node, messageId, resolvedConfig) {
       report(context, messages[messageId], messageId, {
         node,
         data: {
-          text: context.getSourceCode().getText(node).trim(),
+          text: getText(context, node).trim(),
+          element: resolvedConfig.type === 'override' && 'name' in resolvedConfig ? resolvedConfig.name : undefined,
         },
       });
     }
@@ -157,39 +422,103 @@ module.exports = {
     // Public
     // --------------------------------------------------------------------------
 
-    return {
+    return Object.assign(hasElementOverrides ? {
+      // Get renamed import local names mapped to their imported name
+      ImportDeclaration(node) {
+        node.specifiers
+          .filter((s) => s.type === 'ImportSpecifier')
+          .forEach((specifier) => {
+            renamedImportMap.set(
+              (specifier.local || specifier.imported).name,
+              specifier.imported.name
+            );
+          });
+      },
+
+      // Get renamed destructured local names mapped to their imported name
+      VariableDeclaration(node) {
+        node.declarations
+          .filter((d) => (
+            d.type === 'VariableDeclarator'
+            && isRequireStatement(d.init)
+            && d.id.type === 'ObjectPattern'
+          ))
+          .forEach((declaration) => {
+            declaration.id.properties
+              .filter((property) => (
+                property.type === 'Property'
+                && property.key.type === 'Identifier'
+                && property.value.type === 'Identifier'
+              ))
+              .forEach((property) => {
+                renamedImportMap.set(property.value.name, property.key.name);
+              });
+          });
+      },
+    } : false, {
       Literal(node) {
-        if (getValidation(node) && (hasJSXElementParentOrGrandParent(node) || !config.ignoreProps)) {
-          reportLiteralNode(node);
+        const resolvedConfig = getOverrideConfig(node) || config;
+
+        const hasJSXParentOrGrandParent = hasJSXElementParentOrGrandParent(node);
+        if (hasJSXParentOrGrandParent && shouldAllowElement(resolvedConfig)) {
+          return;
+        }
+
+        if (isViableTextNode(node, resolvedConfig)) {
+          if (hasJSXParentOrGrandParent || !config.ignoreProps) {
+            reportLiteralNode(node, defaultMessageId(hasJSXParentOrGrandParent, resolvedConfig), resolvedConfig);
+          }
         }
       },
 
       JSXAttribute(node) {
-        const isNodeValueString = node && node.value && node.value.type === 'Literal' && typeof node.value.value === 'string' && !config.allowedStrings.has(node.value.value);
+        const isLiteralString = node.value && node.value.type === 'Literal'
+          && typeof node.value.value === 'string';
+        const isStringLiteral = node.value && node.value.type === 'StringLiteral';
+
+        if (isLiteralString || isStringLiteral) {
+          const resolvedConfig = getOverrideConfig(node) || config;
 
-        if (config.noStrings && !config.ignoreProps && isNodeValueString) {
-          const messageId = 'invalidPropValue';
-          reportLiteralNode(node, messageId);
+          if (
+            resolvedConfig.noStrings
+            && !resolvedConfig.ignoreProps
+            && !resolvedConfig.allowedStrings.has(node.value.value)
+          ) {
+            const messageId = resolvedConfig.type === 'override' ? 'invalidPropValueInElement' : 'invalidPropValue';
+            reportLiteralNode(node, messageId, resolvedConfig);
+          }
         }
       },
 
       JSXText(node) {
-        if (getValidation(node)) {
-          reportLiteralNode(node);
+        const resolvedConfig = getOverrideConfig(node) || config;
+
+        if (shouldAllowElement(resolvedConfig)) {
+          return;
+        }
+
+        if (isViableTextNode(node, resolvedConfig)) {
+          const hasJSXParendOrGrantParent = hasJSXElementParentOrGrandParent(node);
+          reportLiteralNode(node, defaultMessageId(hasJSXParendOrGrantParent, resolvedConfig), resolvedConfig);
         }
       },
 
       TemplateLiteral(node) {
-        const parents = getParentAndGrandParentType(node);
-        const parentType = parents.parentType;
-        const grandParentType = parents.grandParentType;
-        const isParentJSXExpressionCont = parentType === 'JSXExpressionContainer';
-        const isParentJSXElement = parentType === 'JSXElement' || grandParentType === 'JSXElement';
-
-        if (isParentJSXExpressionCont && config.noStrings && (isParentJSXElement || !config.ignoreProps)) {
-          reportLiteralNode(node);
+        const ancestors = getParentAndGrandParent(node);
+        const isParentJSXExpressionCont = ancestors.parent.type === 'JSXExpressionContainer';
+        const isParentJSXElement = ancestors.grandParent.type === 'JSXElement';
+
+        if (isParentJSXExpressionCont) {
+          const resolvedConfig = getOverrideConfig(node) || config;
+
+          if (
+            resolvedConfig.noStrings
+            && (isParentJSXElement || !resolvedConfig.ignoreProps)
+          ) {
+            reportLiteralNode(node, defaultMessageId(isParentJSXElement, resolvedConfig), resolvedConfig);
+          }
         }
       },
-    };
+    });
   },
 };
diff --git a/lib/rules/jsx-no-script-url.js b/lib/rules/jsx-no-script-url.js
index bcf9468a24..b18ce2ccb3 100644
--- a/lib/rules/jsx-no-script-url.js
+++ b/lib/rules/jsx-no-script-url.js
@@ -43,6 +43,7 @@ const messages = {
   noScriptURL: 'A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML, try using dangerouslySetInnerHTML instead.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-no-target-blank.js b/lib/rules/jsx-no-target-blank.js
index 795de8a70f..9f5d239d6c 100644
--- a/lib/rules/jsx-no-target-blank.js
+++ b/lib/rules/jsx-no-target-blank.js
@@ -70,7 +70,7 @@ function hasDynamicLink(node, linkAttributes) {
  * Get the string(s) from a value
  * @param {ASTNode} value The AST node being checked.
  * @param {ASTNode} targetValue The AST node being checked.
- * @returns {String | String[] | null} The string value, or null if not a string.
+ * @returns {string | string[] | null} The string value, or null if not a string.
  */
 function getStringFromValue(value, targetValue) {
   if (value) {
@@ -126,6 +126,7 @@ const messages = {
   noTargetBlankWithoutNoopener: 'Using target="_blank" without rel="noreferrer" or rel="noopener" (the former implies the latter and is preferred due to wider support) is a security risk: see https://mathiasbynens.github.io/rel-noopener/#recommendations',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     fixable: 'code',
diff --git a/lib/rules/jsx-no-undef.js b/lib/rules/jsx-no-undef.js
index d7a42ccff2..a15de8e854 100644
--- a/lib/rules/jsx-no-undef.js
+++ b/lib/rules/jsx-no-undef.js
@@ -6,6 +6,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
 
@@ -17,6 +18,7 @@ const messages = {
   undefined: '\'{{identifier}}\' is not defined.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -49,8 +51,8 @@ module.exports = {
      * @returns {void}
      */
     function checkIdentifierInJSX(node) {
-      let scope = context.getScope();
-      const sourceCode = context.getSourceCode();
+      let scope = eslintUtil.getScope(context, node);
+      const sourceCode = eslintUtil.getSourceCode(context);
       const sourceType = sourceCode.ast.sourceType;
       const scopeUpperBound = !allowGlobals && sourceType === 'module' ? 'module' : 'global';
       let variables = scope.variables;
diff --git a/lib/rules/jsx-no-useless-fragment.js b/lib/rules/jsx-no-useless-fragment.js
index 2d2711a5f9..9827560f0e 100644
--- a/lib/rules/jsx-no-useless-fragment.js
+++ b/lib/rules/jsx-no-useless-fragment.js
@@ -7,9 +7,11 @@
 const arrayIncludes = require('array-includes');
 
 const pragmaUtil = require('../util/pragma');
+const astUtil = require('../util/ast');
 const jsxUtil = require('../util/jsx');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
 
 function isJSXText(node) {
   return !!node && (node.type === 'JSXText' || node.type === 'Literal');
@@ -74,8 +76,7 @@ function isKeyedElement(node) {
 function containsCallExpression(node) {
   return node
     && node.type === 'JSXExpressionContainer'
-    && node.expression
-    && node.expression.type === 'CallExpression';
+    && astUtil.isCallExpression(node.expression);
 }
 
 const messages = {
@@ -83,6 +84,7 @@ const messages = {
   ChildOfHtmlElement: 'Passing a fragment to an HTML element is useless.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     type: 'suggestion',
@@ -215,7 +217,7 @@ module.exports = {
         const opener = node.type === 'JSXFragment' ? node.openingFragment : node.openingElement;
         const closer = node.type === 'JSXFragment' ? node.closingFragment : node.closingElement;
 
-        const childrenText = opener.selfClosing ? '' : context.getSourceCode().getText().slice(opener.range[1], closer.range[0]);
+        const childrenText = opener.selfClosing ? '' : getText(context).slice(opener.range[1], closer.range[0]);
 
         return fixer.replaceText(node, trimLikeReact(childrenText));
       };
diff --git a/lib/rules/jsx-one-expression-per-line.js b/lib/rules/jsx-one-expression-per-line.js
index 4c5a9c970f..3ae61e3d96 100644
--- a/lib/rules/jsx-one-expression-per-line.js
+++ b/lib/rules/jsx-one-expression-per-line.js
@@ -6,9 +6,13 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
 
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -21,6 +25,7 @@ const messages = {
   moveToNewLine: '`{{descriptor}}` must be placed on a new line',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -54,8 +59,12 @@ module.exports = {
       return `${node.loc.start.line},${node.loc.start.column}`;
     }
 
+    /**
+     * @param {ASTNode} n
+     * @returns {string}
+     */
     function nodeDescriptor(n) {
-      return n.openingElement ? n.openingElement.name.name : context.getSourceCode().getText(n).replace(/\n/g, '');
+      return n.openingElement ? n.openingElement.name.name : getText(context, n).replace(/\n/g, '');
     }
 
     function handleJSX(node) {
@@ -162,20 +171,20 @@ module.exports = {
           function spaceBetweenPrev() {
             return ((prevChild.type === 'Literal' || prevChild.type === 'JSXText') && / $/.test(prevChild.raw))
               || ((child.type === 'Literal' || child.type === 'JSXText') && /^ /.test(child.raw))
-              || context.getSourceCode().isSpaceBetweenTokens(prevChild, child);
+              || getSourceCode(context).isSpaceBetweenTokens(prevChild, child);
           }
 
           function spaceBetweenNext() {
             return ((nextChild.type === 'Literal' || nextChild.type === 'JSXText') && /^ /.test(nextChild.raw))
               || ((child.type === 'Literal' || child.type === 'JSXText') && / $/.test(child.raw))
-              || context.getSourceCode().isSpaceBetweenTokens(child, nextChild);
+              || getSourceCode(context).isSpaceBetweenTokens(child, nextChild);
           }
 
           if (!prevChild && !nextChild) {
             return;
           }
 
-          const source = context.getSourceCode().getText(child);
+          const source = getText(context, child);
           const leadingSpace = !!(prevChild && spaceBetweenPrev());
           const trailingSpace = !!(nextChild && spaceBetweenNext());
           const leadingNewLine = !!prevChild;
diff --git a/lib/rules/jsx-pascal-case.js b/lib/rules/jsx-pascal-case.js
index a1bb48116a..efeef4032a 100644
--- a/lib/rules/jsx-pascal-case.js
+++ b/lib/rules/jsx-pascal-case.js
@@ -76,6 +76,7 @@ const messages = {
   usePascalOrSnakeCase: 'Imported JSX component {{name}} must be in PascalCase or SCREAMING_SNAKE_CASE',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-props-no-multi-spaces.js b/lib/rules/jsx-props-no-multi-spaces.js
index b9cabafe32..5786506d11 100644
--- a/lib/rules/jsx-props-no-multi-spaces.js
+++ b/lib/rules/jsx-props-no-multi-spaces.js
@@ -6,7 +6,12 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const report = require('../util/report');
+const propsUtil = require('../util/props');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -17,6 +22,7 @@ const messages = {
   onlyOneSpace: 'Expected only one space between “{{prop1}}” and “{{prop2}}”',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -33,12 +39,12 @@ module.exports = {
   },
 
   create(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = getSourceCode(context);
 
     function getPropName(propNode) {
       switch (propNode.type) {
         case 'JSXSpreadAttribute':
-          return context.getSourceCode().getText(propNode.argument);
+          return getText(context, propNode.argument);
         case 'JSXIdentifier':
           return propNode.name;
         case 'JSXMemberExpression':
@@ -46,7 +52,7 @@ module.exports = {
         default:
           return propNode.name
             ? propNode.name.name
-            : `${context.getSourceCode().getText(propNode.object)}.${propNode.property.name}`; // needed for typescript-eslint parser
+            : `${getText(context, propNode.object)}.${propNode.property.name}`; // needed for typescript-eslint parser
       }
     }
 
@@ -74,6 +80,22 @@ module.exports = {
             prop1: getPropName(prev),
             prop2: getPropName(node),
           },
+          fix(fixer) {
+            const comments = sourceCode.getCommentsBefore ? sourceCode.getCommentsBefore(node) : [];
+            const nodes = [].concat(prev, comments, node);
+            const fixes = [];
+
+            for (let i = 1; i < nodes.length; i += 1) {
+              const prevNode = nodes[i - 1];
+              const currNode = nodes[i];
+              if (currNode.loc.start.line - prevNode.loc.end.line >= 2) {
+                const indent = ' '.repeat(currNode.loc.start.column);
+                fixes.push(fixer.replaceTextRange([prevNode.range[1], currNode.range[0]], `\n${indent}`));
+              }
+            }
+
+            return fixes;
+          },
         });
       }
 
@@ -81,7 +103,7 @@ module.exports = {
         return;
       }
 
-      const between = context.getSourceCode().text.slice(prev.range[1], node.range[0]);
+      const between = getSourceCode(context).text.slice(prev.range[1], node.range[0]);
 
       if (between !== ' ') {
         report(context, messages.onlyOneSpace, 'onlyOneSpace', {
@@ -98,18 +120,18 @@ module.exports = {
     }
 
     function containsGenericType(node) {
-      const nodeTypeParams = node.typeParameters;
-      if (typeof nodeTypeParams === 'undefined') {
+      const nodeTypeArguments = propsUtil.getTypeArguments(node);
+      if (typeof nodeTypeArguments === 'undefined') {
         return false;
       }
 
-      return nodeTypeParams.type === 'TSTypeParameterInstantiation';
+      return nodeTypeArguments.type === 'TSTypeParameterInstantiation';
     }
 
     function getGenericNode(node) {
       const name = node.name;
       if (containsGenericType(node)) {
-        const type = node.typeParameters;
+        const nodeTypeArguments = propsUtil.getTypeArguments(node);
 
         return Object.assign(
           {},
@@ -117,7 +139,7 @@ module.exports = {
           {
             range: [
               name.range[0],
-              type.range[1],
+              nodeTypeArguments.range[1],
             ],
           }
         );
diff --git a/lib/rules/jsx-props-no-spread-multi.js b/lib/rules/jsx-props-no-spread-multi.js
new file mode 100644
index 0000000000..3103be86da
--- /dev/null
+++ b/lib/rules/jsx-props-no-spread-multi.js
@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Prevent JSX prop spreading the same expression multiple times
+ * @author Simon Schick
+ */
+
+'use strict';
+
+const docsUrl = require('../util/docsUrl');
+const report = require('../util/report');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const messages = {
+  noMultiSpreading: 'Spreading the same expression multiple times is forbidden',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow JSX prop spreading the same identifier multiple times',
+      category: 'Best Practices',
+      recommended: false,
+      url: docsUrl('jsx-props-no-spread-multi'),
+    },
+    messages,
+  },
+
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        const spreads = node.attributes.filter(
+          (attr) => attr.type === 'JSXSpreadAttribute'
+          && attr.argument.type === 'Identifier'
+        );
+        if (spreads.length < 2) {
+          return;
+        }
+        // We detect duplicate expressions by their identifier
+        const identifierNames = new Set();
+        spreads.forEach((spread) => {
+          if (identifierNames.has(spread.argument.name)) {
+            report(context, messages.noMultiSpreading, 'noMultiSpreading', {
+              node: spread,
+            });
+          }
+          identifierNames.add(spread.argument.name);
+        });
+      },
+    };
+  },
+};
diff --git a/lib/rules/jsx-props-no-spreading.js b/lib/rules/jsx-props-no-spreading.js
index acbdea797a..1aa8ab4ace 100644
--- a/lib/rules/jsx-props-no-spreading.js
+++ b/lib/rules/jsx-props-no-spreading.js
@@ -38,6 +38,7 @@ const messages = {
   noSpreading: 'Prop spreading is forbidden',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -59,6 +60,9 @@ module.exports = {
           custom: {
             enum: [OPTIONS.enforce, OPTIONS.ignore],
           },
+          explicitSpread: {
+            enum: [OPTIONS.enforce, OPTIONS.ignore],
+          },
           exceptions: {
             type: 'array',
             items: {
diff --git a/lib/rules/jsx-sort-default-props.js b/lib/rules/jsx-sort-default-props.js
index f35e40dc5f..f990f77189 100644
--- a/lib/rules/jsx-sort-default-props.js
+++ b/lib/rules/jsx-sort-default-props.js
@@ -10,6 +10,10 @@ const variableUtil = require('../util/variable');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
 const log = require('../util/log');
+const eslintUtil = require('../util/eslint');
+
+const getFirstTokens = eslintUtil.getFirstTokens;
+const getText = eslintUtil.getText;
 
 let isWarnedForDeprecation = false;
 
@@ -21,6 +25,7 @@ const messages = {
   propsNotSorted: 'Default prop types declarations should be sorted alphabetically',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     deprecated: true,
@@ -53,7 +58,7 @@ module.exports = {
     /**
      * Get properties name
      * @param {Object} node - Property.
-     * @returns {String} Property name.
+     * @returns {string} Property name.
      */
     function getPropertyName(node) {
       if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
@@ -65,7 +70,7 @@ module.exports = {
       // (babel-eslint@5 does not expose property name so we have to rely on tokens)
       }
       if (node.type === 'ClassProperty') {
-        const tokens = context.getSourceCode().getFirstTokens(node, 2);
+        const tokens = getFirstTokens(context, node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
       return '';
@@ -74,7 +79,7 @@ module.exports = {
     /**
      * Checks if the Identifier node passed in looks like a defaultProps declaration.
      * @param   {ASTNode}  node The node to check. Must be an Identifier node.
-     * @returns {Boolean}       `true` if the node is a defaultProps declaration, `false` if not
+     * @returns {boolean}       `true` if the node is a defaultProps declaration, `false` if not
      */
     function isDefaultPropsDeclaration(node) {
       const propName = getPropertyName(node);
@@ -82,16 +87,18 @@ module.exports = {
     }
 
     function getKey(node) {
-      return context.getSourceCode().getText(node.key || node.argument);
+      return getText(context, node.key || node.argument);
     }
 
     /**
      * Find a variable by name in the current scope.
+     * @param  {ASTNode} node The node to look for.
      * @param  {string} name Name of the variable to look for.
      * @returns {ASTNode|null} Return null if the variable could not be found, ASTNode otherwise.
      */
-    function findVariableByName(name) {
-      const variable = variableUtil.variablesInScope(context).find((item) => item.name === name);
+    function findVariableByName(node, name) {
+      const variable = variableUtil
+        .getVariableFromContext(context, node, name);
 
       if (!variable || !variable.defs[0] || !variable.defs[0].node) {
         return null;
@@ -111,7 +118,7 @@ module.exports = {
      */
     function checkSorted(declarations) {
       // function fix(fixer) {
-      //   return propTypesSortUtil.fixPropTypesSort(fixer, context, declarations, ignoreCase);
+      //   return propTypesSortUtil.fixPropTypesSort(context, fixer, declarations, ignoreCase);
       // }
 
       declarations.reduce((prev, curr, idx, decls) => {
@@ -147,7 +154,7 @@ module.exports = {
       if (node.type === 'ObjectExpression') {
         checkSorted(node.properties);
       } else if (node.type === 'Identifier') {
-        const propTypesObject = findVariableByName(node.name);
+        const propTypesObject = findVariableByName(node, node.name);
         if (propTypesObject && propTypesObject.properties) {
           checkSorted(propTypesObject.properties);
         }
@@ -172,7 +179,7 @@ module.exports = {
           return;
         }
 
-        checkNode(node.parent.right);
+        checkNode('right' in node.parent && node.parent.right);
       },
 
       Program() {
diff --git a/lib/rules/jsx-sort-props.js b/lib/rules/jsx-sort-props.js
index 6d19f201cd..ec9d869b74 100644
--- a/lib/rules/jsx-sort-props.js
+++ b/lib/rules/jsx-sort-props.js
@@ -12,15 +12,16 @@ const toSorted = require('array.prototype.tosorted');
 const docsUrl = require('../util/docsUrl');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
+const propTypesSortUtil = require('../util/propTypesSort');
+const eslintUtil = require('../util/eslint');
+
+const getText = eslintUtil.getText;
+const getSourceCode = eslintUtil.getSourceCode;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-function isCallbackPropName(name) {
-  return /^on[A-Z]/.test(name);
-}
-
 function isMultilineProp(node) {
   return node.loc.start.line !== node.loc.end.line;
 }
@@ -81,8 +82,8 @@ function contextCompare(a, b, options) {
   }
 
   if (options.callbacksLast) {
-    const aIsCallback = isCallbackPropName(aProp);
-    const bIsCallback = isCallbackPropName(bProp);
+    const aIsCallback = propTypesSortUtil.isCallbackPropName(aProp);
+    const bIsCallback = propTypesSortUtil.isCallbackPropName(bProp);
     if (aIsCallback && !bIsCallback) {
       return 1;
     }
@@ -141,7 +142,7 @@ function contextCompare(a, b, options) {
  * @return {Array<Array<JSXAttribute>>}
  */
 function getGroupsOfSortableAttributes(attributes, context) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
 
   const sortableAttributeGroups = [];
   let groupCount = 0;
@@ -212,7 +213,6 @@ function getGroupsOfSortableAttributes(attributes, context) {
 }
 
 function generateFixerFunction(node, context, reservedList) {
-  const sourceCode = context.getSourceCode();
   const attributes = node.attributes.slice(0);
   const configuration = context.options[0] || {};
   const ignoreCase = configuration.ignoreCase || false;
@@ -245,7 +245,7 @@ function generateFixerFunction(node, context, reservedList) {
 
   return function fixFunction(fixer) {
     const fixers = [];
-    let source = sourceCode.getText();
+    let source = getText(context);
 
     sortableAttributeGroups.forEach((sortableGroup, ii) => {
       sortableGroup.forEach((attr, jj) => {
@@ -276,8 +276,8 @@ function generateFixerFunction(node, context, reservedList) {
 /**
  * Checks if the `reservedFirst` option is valid
  * @param {Object} context The context of the rule
- * @param {Boolean|Array<String>} reservedFirst The `reservedFirst` option
- * @return {Function|undefined} If an error is detected, a function to generate the error message, otherwise, `undefined`
+ * @param {boolean | string[]} reservedFirst The `reservedFirst` option
+ * @return {Function | undefined} If an error is detected, a function to generate the error message, otherwise, `undefined`
  */
 // eslint-disable-next-line consistent-return
 function validateReservedFirstConfig(context, reservedFirst) {
@@ -338,6 +338,7 @@ function reportNodeAttribute(nodeAttribute, errorType, node, context, reservedLi
   });
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -421,8 +422,8 @@ module.exports = {
           let currentPropName = propName(decl);
           const previousValue = memo.value;
           const currentValue = decl.value;
-          const previousIsCallback = isCallbackPropName(previousPropName);
-          const currentIsCallback = isCallbackPropName(currentPropName);
+          const previousIsCallback = propTypesSortUtil.isCallbackPropName(previousPropName);
+          const currentIsCallback = propTypesSortUtil.isCallbackPropName(currentPropName);
 
           if (ignoreCase) {
             previousPropName = previousPropName.toLowerCase();
diff --git a/lib/rules/jsx-space-before-closing.js b/lib/rules/jsx-space-before-closing.js
index f1e1e61d96..2cef238841 100644
--- a/lib/rules/jsx-space-before-closing.js
+++ b/lib/rules/jsx-space-before-closing.js
@@ -10,6 +10,7 @@ const getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBrack
 const docsUrl = require('../util/docsUrl');
 const log = require('../util/log');
 const report = require('../util/report');
+const getSourceCode = require('../util/eslint').getSourceCode;
 
 let isWarnedForDeprecation = false;
 
@@ -22,6 +23,7 @@ const messages = {
   needSpaceBeforeClose: 'A space is required before closing bracket',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     deprecated: true,
@@ -54,10 +56,10 @@ module.exports = {
           return;
         }
 
-        const sourceCode = context.getSourceCode();
+        const sourceCode = getSourceCode(context);
 
         const leftToken = getTokenBeforeClosingBracket(node);
-        const closingSlash = sourceCode.getTokenAfter(leftToken);
+        const closingSlash = /** @type {import('eslint').AST.Token} */ (sourceCode.getTokenAfter(leftToken));
 
         if (leftToken.loc.end.line !== closingSlash.loc.start.line) {
           return;
diff --git a/lib/rules/jsx-tag-spacing.js b/lib/rules/jsx-tag-spacing.js
index e7c632b479..ac7c693278 100644
--- a/lib/rules/jsx-tag-spacing.js
+++ b/lib/rules/jsx-tag-spacing.js
@@ -8,6 +8,10 @@
 const getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBracket');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getFirstTokens = eslintUtil.getFirstTokens;
+const getSourceCode = eslintUtil.getSourceCode;
 
 const messages = {
   selfCloseSlashNoSpace: 'Whitespace is forbidden between `/` and `>`; write `/>`',
@@ -29,7 +33,7 @@ const messages = {
 // ------------------------------------------------------------------------------
 
 function validateClosingSlash(context, node, option) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
 
   let adjacent;
 
@@ -64,7 +68,7 @@ function validateClosingSlash(context, node, option) {
       });
     }
   } else {
-    const firstTokens = sourceCode.getFirstTokens(node, 2);
+    const firstTokens = getFirstTokens(context, node, 2);
 
     adjacent = !sourceCode.isSpaceBetweenTokens(firstTokens[0], firstTokens[1]);
 
@@ -97,7 +101,7 @@ function validateClosingSlash(context, node, option) {
 }
 
 function validateBeforeSelfClosing(context, node, option) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   const leftToken = getTokenBeforeClosingBracket(node);
   const closingSlash = sourceCode.getTokenAfter(leftToken);
 
@@ -141,7 +145,7 @@ function validateBeforeSelfClosing(context, node, option) {
 }
 
 function validateAfterOpening(context, node, option) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   const openingToken = sourceCode.getTokenBefore(node.name);
 
   if (option === 'allow-multiline') {
@@ -182,7 +186,7 @@ function validateAfterOpening(context, node, option) {
 function validateBeforeClosing(context, node, option) {
   // Don't enforce this rule for self closing tags
   if (!node.selfClosing) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = getSourceCode(context);
     const leftToken = option === 'proportional-always'
       ? getTokenBeforeClosingBracket(node)
       : sourceCode.getLastTokens(node, 2)[0];
@@ -255,6 +259,7 @@ const optionDefaults = {
   beforeClosing: 'allow',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/jsx-uses-react.js b/lib/rules/jsx-uses-react.js
index 2bc2963d9e..5d64f76cd8 100644
--- a/lib/rules/jsx-uses-react.js
+++ b/lib/rules/jsx-uses-react.js
@@ -7,11 +7,13 @@
 
 const pragmaUtil = require('../util/pragma');
 const docsUrl = require('../util/docsUrl');
+const markVariableAsUsed = require('../util/eslint').markVariableAsUsed;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   // eslint-disable-next-line eslint-plugin/prefer-message-ids -- https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/issues/292
   meta: {
@@ -28,8 +30,12 @@ module.exports = {
     const pragma = pragmaUtil.getFromContext(context);
     const fragment = pragmaUtil.getFragmentFromContext(context);
 
-    function handleOpeningElement() {
-      context.markVariableAsUsed(pragma);
+    /**
+     * @param {ASTNode} node
+     * @returns {void}
+     */
+    function handleOpeningElement(node) {
+      markVariableAsUsed(pragma, node, context);
     }
     // --------------------------------------------------------------------------
     // Public
@@ -38,8 +44,8 @@ module.exports = {
     return {
       JSXOpeningElement: handleOpeningElement,
       JSXOpeningFragment: handleOpeningElement,
-      JSXFragment() {
-        context.markVariableAsUsed(fragment);
+      JSXFragment(node) {
+        markVariableAsUsed(fragment, node, context);
       },
     };
   },
diff --git a/lib/rules/jsx-uses-vars.js b/lib/rules/jsx-uses-vars.js
index a178d50565..6f5f4f6cc0 100644
--- a/lib/rules/jsx-uses-vars.js
+++ b/lib/rules/jsx-uses-vars.js
@@ -6,6 +6,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const markVariableAsUsed = require('../util/eslint').markVariableAsUsed;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -14,6 +15,7 @@ const docsUrl = require('../util/docsUrl');
 const isTagNameRe = /^[a-z]/;
 const isTagName = (name) => isTagNameRe.test(name);
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   // eslint-disable-next-line eslint-plugin/prefer-message-ids -- https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/issues/292
   meta: {
@@ -52,7 +54,7 @@ module.exports = {
           return;
         }
 
-        context.markVariableAsUsed(name);
+        markVariableAsUsed(name, node, context);
       },
 
     };
diff --git a/lib/rules/jsx-wrap-multilines.js b/lib/rules/jsx-wrap-multilines.js
index eb9359e773..6f5ad50bbf 100644
--- a/lib/rules/jsx-wrap-multilines.js
+++ b/lib/rules/jsx-wrap-multilines.js
@@ -5,12 +5,16 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const docsUrl = require('../util/docsUrl');
+const eslintUtil = require('../util/eslint');
 const jsxUtil = require('../util/jsx');
 const reportC = require('../util/report');
 const isParenthesized = require('../util/ast').isParenthesized;
 
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
+
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
@@ -35,6 +39,7 @@ const messages = {
   parensOnNewLines: 'Parentheses around JSX should be on separate lines',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -92,7 +97,7 @@ module.exports = {
     }
 
     function needsOpeningNewLine(node) {
-      const previousToken = context.getSourceCode().getTokenBefore(node);
+      const previousToken = getSourceCode(context).getTokenBefore(node);
 
       if (!isParenthesized(context, node)) {
         return false;
@@ -106,7 +111,7 @@ module.exports = {
     }
 
     function needsClosingNewLine(node) {
-      const nextToken = context.getSourceCode().getTokenAfter(node);
+      const nextToken = getSourceCode(context).getTokenAfter(node);
 
       if (!isParenthesized(context, node)) {
         return false;
@@ -142,11 +147,11 @@ module.exports = {
         return;
       }
 
-      const sourceCode = context.getSourceCode();
+      const sourceCode = getSourceCode(context);
       const option = getOption(type);
 
       if ((option === true || option === 'parens') && !isParenthesized(context, node) && isMultilines(node)) {
-        report(node, 'missingParens', (fixer) => fixer.replaceText(node, `(${sourceCode.getText(node)})`));
+        report(node, 'missingParens', (fixer) => fixer.replaceText(node, `(${getText(context, node)})`));
       }
 
       if (option === 'parens-new-line' && isMultilines(node)) {
@@ -161,18 +166,18 @@ module.exports = {
               'missingParens',
               (fixer) => fixer.replaceTextRange(
                 [tokenBefore.range[0], tokenAfter && (tokenAfter.value === ';' || tokenAfter.value === '}') ? tokenAfter.range[0] : node.range[1]],
-                `${trimTokenBeforeNewline(node, tokenBefore)}(\n${start.column > 0 ? ' '.repeat(start.column) : ''}${sourceCode.getText(node)}\n${start.column > 0 ? ' '.repeat(start.column - 2) : ''})`
+                `${trimTokenBeforeNewline(node, tokenBefore)}(\n${start.column > 0 ? ' '.repeat(start.column) : ''}${getText(context, node)}\n${start.column > 0 ? ' '.repeat(start.column - 2) : ''})`
               )
             );
           } else {
-            report(node, 'missingParens', (fixer) => fixer.replaceText(node, `(\n${sourceCode.getText(node)}\n)`));
+            report(node, 'missingParens', (fixer) => fixer.replaceText(node, `(\n${getText(context, node)}\n)`));
           }
         } else {
           const needsOpening = needsOpeningNewLine(node);
           const needsClosing = needsClosingNewLine(node);
           if (needsOpening || needsClosing) {
             report(node, 'parensOnNewLines', (fixer) => {
-              const text = sourceCode.getText(node);
+              const text = getText(context, node);
               let fixed = text;
               if (needsOpening) {
                 fixed = `\n${fixed}`;
@@ -191,7 +196,7 @@ module.exports = {
         const tokenAfter = sourceCode.getTokenAfter(node);
         report(node, 'extraParens', (fixer) => fixer.replaceTextRange(
           [tokenBefore.range[0], tokenAfter.range[1]],
-          sourceCode.getText(node)
+          getText(context, node)
         ));
       }
     }
diff --git a/lib/rules/no-access-state-in-setstate.js b/lib/rules/no-access-state-in-setstate.js
index 89d4976077..1b23dd88ee 100644
--- a/lib/rules/no-access-state-in-setstate.js
+++ b/lib/rules/no-access-state-in-setstate.js
@@ -6,8 +6,10 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -17,6 +19,7 @@ const messages = {
   useCallback: 'Use callback in setState when referencing the previous state.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -31,7 +34,7 @@ module.exports = {
 
   create(context) {
     function isSetStateCall(node) {
-      return node.type === 'CallExpression'
+      return astUtil.isCallExpression(node)
         && node.callee.property
         && node.callee.property.name === 'setState'
         && node.callee.object.type === 'ThisExpression';
@@ -47,8 +50,15 @@ module.exports = {
       return current.arguments[0] === node;
     }
 
-    function isClassComponent() {
-      return !!(componentUtil.getParentES6Component(context) || componentUtil.getParentES5Component(context));
+    /**
+     * @param {ASTNode} node
+     * @returns {boolean}
+     */
+    function isClassComponent(node) {
+      return !!(
+        componentUtil.getParentES6Component(context, node)
+        || componentUtil.getParentES5Component(context, node)
+      );
     }
 
     // The methods array contains all methods or functions that are using this.state
@@ -58,18 +68,18 @@ module.exports = {
     const vars = [];
     return {
       CallExpression(node) {
-        if (!isClassComponent()) {
+        if (!isClassComponent(node)) {
           return;
         }
         // Appends all the methods that are calling another
         // method containing this.state to the methods array
         methods.forEach((method) => {
-          if (node.callee.name === method.methodName) {
+          if ('name' in node.callee && node.callee.name === method.methodName) {
             let current = node.parent;
             while (current.type !== 'Program') {
               if (current.type === 'MethodDefinition') {
                 methods.push({
-                  methodName: current.key.name,
+                  methodName: 'name' in current.key ? current.key.name : undefined,
                   node: method.node,
                 });
                 break;
@@ -84,7 +94,7 @@ module.exports = {
         let current = node.parent;
         while (current.type !== 'Program') {
           if (isFirstArgumentInSetStateCall(current, node)) {
-            const methodName = node.callee.name;
+            const methodName = 'name' in node.callee ? node.callee.name : undefined;
             methods.forEach((method) => {
               if (method.methodName === methodName) {
                 report(context, messages.useCallback, 'useCallback', {
@@ -101,10 +111,12 @@ module.exports = {
 
       MemberExpression(node) {
         if (
-          node.property.name === 'state'
+          'name' in node.property
+          && node.property.name === 'state'
           && node.object.type === 'ThisExpression'
-          && isClassComponent()
+          && isClassComponent(node)
         ) {
+          /** @type {import('eslint').Rule.Node} */
           let current = node;
           while (current.type !== 'Program') {
             // Reporting if this.state is directly within this.setState
@@ -118,13 +130,17 @@ module.exports = {
             // Storing all functions and methods that contains this.state
             if (current.type === 'MethodDefinition') {
               methods.push({
-                methodName: current.key.name,
+                methodName: 'name' in current.key ? current.key.name : undefined,
                 node,
               });
               break;
-            } else if (current.type === 'FunctionExpression' && current.parent.key) {
+            } else if (
+              current.type === 'FunctionExpression'
+              && 'key' in current.parent
+              && current.parent.key
+            ) {
               methods.push({
-                methodName: current.parent.key.name,
+                methodName: 'name' in current.parent.key ? current.parent.key.name : undefined,
                 node,
               });
               break;
@@ -134,8 +150,8 @@ module.exports = {
             if (current.type === 'VariableDeclarator') {
               vars.push({
                 node,
-                scope: context.getScope(),
-                variableName: current.id.name,
+                scope: getScope(context, node),
+                variableName: 'name' in current.id ? current.id.name : undefined,
               });
               break;
             }
@@ -147,18 +163,19 @@ module.exports = {
 
       Identifier(node) {
         // Checks if the identifier is a variable within an object
+        /** @type {import('eslint').Rule.Node} */
         let current = node;
         while (current.parent.type === 'BinaryExpression') {
           current = current.parent;
         }
         if (
-          current.parent.value === current
-          || current.parent.object === current
+          ('value' in current.parent && current.parent.value === current)
+          || ('object' in current.parent && current.parent.object === current)
         ) {
           while (current.type !== 'Program') {
             if (isFirstArgumentInSetStateCall(current, node)) {
               vars
-                .filter((v) => v.scope === context.getScope() && v.variableName === node.name)
+                .filter((v) => v.scope === getScope(context, node) && v.variableName === node.name)
                 .forEach((v) => {
                   report(context, messages.useCallback, 'useCallback', {
                     node: v.node,
@@ -171,12 +188,19 @@ module.exports = {
       },
 
       ObjectPattern(node) {
-        const isDerivedFromThis = node.parent.init && node.parent.init.type === 'ThisExpression';
+        const isDerivedFromThis = 'init' in node.parent && node.parent.init && node.parent.init.type === 'ThisExpression';
         node.properties.forEach((property) => {
-          if (property && property.key && property.key.name === 'state' && isDerivedFromThis) {
+          if (
+            property
+            && 'key' in property
+            && property.key
+            && 'name' in property.key
+            && property.key.name === 'state'
+            && isDerivedFromThis
+          ) {
             vars.push({
               node: property.key,
-              scope: context.getScope(),
+              scope: getScope(context, node),
               variableName: property.key.name,
             });
           }
diff --git a/lib/rules/no-adjacent-inline-elements.js b/lib/rules/no-adjacent-inline-elements.js
index 60e404ba22..8110d8563b 100644
--- a/lib/rules/no-adjacent-inline-elements.js
+++ b/lib/rules/no-adjacent-inline-elements.js
@@ -8,6 +8,7 @@
 const docsUrl = require('../util/docsUrl');
 const isCreateElement = require('../util/isCreateElement');
 const report = require('../util/report');
+const astUtil = require('../util/ast');
 
 // ------------------------------------------------------------------------------
 // Helpers
@@ -62,7 +63,7 @@ function isInline(node) {
   if (node.type === 'JSXElement' && inlineNames.indexOf(node.openingElement.name.name) > -1) {
     return true;
   }
-  if (node.type === 'CallExpression' && inlineNames.indexOf(node.arguments[0].value) > -1) {
+  if (astUtil.isCallExpression(node) && inlineNames.indexOf(node.arguments[0].value) > -1) {
     return true;
   }
   return false;
@@ -76,6 +77,7 @@ const messages = {
   inlineElement: 'Child elements which render as inline HTML elements should be separated by a space or wrapped in block level elements.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -111,13 +113,13 @@ module.exports = {
         validate(node, node.children);
       },
       CallExpression(node) {
-        if (!isCreateElement(node, context)) {
+        if (!isCreateElement(context, node)) {
           return;
         }
         if (node.arguments.length < 2 || !node.arguments[2]) {
           return;
         }
-        const children = node.arguments[2].elements;
+        const children = 'elements' in node.arguments[2] ? node.arguments[2].elements : undefined;
         validate(node, children);
       },
     };
diff --git a/lib/rules/no-array-index-key.js b/lib/rules/no-array-index-key.js
index 08ecd7a6a9..90381b3a08 100644
--- a/lib/rules/no-array-index-key.js
+++ b/lib/rules/no-array-index-key.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 const pragma = require('../util/pragma');
@@ -28,7 +28,7 @@ function isCreateCloneElement(node, context) {
   }
 
   if (node.type === 'Identifier') {
-    const variable = variableUtil.findVariableByName(context, node.name);
+    const variable = variableUtil.findVariableByName(context, node, node.name);
     if (variable && variable.type === 'ImportSpecifier') {
       return variable.parent.source.value === 'react';
     }
@@ -41,6 +41,7 @@ const messages = {
   noArrayIndex: 'Do not use Array index in keys',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -116,6 +117,8 @@ module.exports = {
         return null;
       }
 
+      const name = /** @type {keyof iteratorFunctionsToIndexParamPosition} */ (callee.property.name);
+
       const callbackArg = isUsingReactChildren(node)
         ? node.arguments[1]
         : node.arguments[0];
@@ -130,7 +133,7 @@ module.exports = {
 
       const params = callbackArg.params;
 
-      const indexParamPosition = iteratorFunctionsToIndexParamPosition[callee.property.name];
+      const indexParamPosition = iteratorFunctionsToIndexParamPosition[name];
       if (params.length < indexParamPosition + 1) {
         return null;
       }
@@ -186,14 +189,15 @@ module.exports = {
         return;
       }
 
-      if (node.type === 'CallExpression'
-          && node.callee
-          && node.callee.type === 'MemberExpression'
-          && node.callee.object
-          && isArrayIndex(node.callee.object)
-          && node.callee.property
-          && node.callee.property.type === 'Identifier'
-          && node.callee.property.name === 'toString'
+      if (
+        astUtil.isCallExpression(node)
+        && node.callee
+        && node.callee.type === 'MemberExpression'
+        && node.callee.object
+        && isArrayIndex(node.callee.object)
+        && node.callee.property
+        && node.callee.property.type === 'Identifier'
+        && node.callee.property.name === 'toString'
       ) {
         // key={bar.toString()}
         report(context, messages.noArrayIndex, 'noArrayIndex', {
@@ -202,13 +206,14 @@ module.exports = {
         return;
       }
 
-      if (node.type === 'CallExpression'
-          && node.callee
-          && node.callee.type === 'Identifier'
-          && node.callee.name === 'String'
-          && Array.isArray(node.arguments)
-          && node.arguments.length > 0
-          && isArrayIndex(node.arguments[0])
+      if (
+        astUtil.isCallExpression(node)
+        && node.callee
+        && node.callee.type === 'Identifier'
+        && node.callee.name === 'String'
+        && Array.isArray(node.arguments)
+        && node.arguments.length > 0
+        && isArrayIndex(node.arguments[0])
       ) {
         // key={String(bar)}
         report(context, messages.noArrayIndex, 'noArrayIndex', {
diff --git a/lib/rules/no-arrow-function-lifecycle.js b/lib/rules/no-arrow-function-lifecycle.js
index d9be92540f..e56cb78601 100644
--- a/lib/rules/no-arrow-function-lifecycle.js
+++ b/lib/rules/no-arrow-function-lifecycle.js
@@ -13,8 +13,12 @@ const componentUtil = require('../util/componentUtil');
 const docsUrl = require('../util/docsUrl');
 const lifecycleMethods = require('../util/lifecycleMethods');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
 
-function getText(node) {
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
+
+function getRuleText(node) {
   const params = node.value.params.map((p) => p.name);
 
   if (node.type === 'Property') {
@@ -32,6 +36,7 @@ const messages = {
   lifecycle: '{{propertyName}} is a React lifecycle method, and should not be an arrow function or in a class field. Use an instance method instead.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -66,7 +71,7 @@ module.exports = {
         if (nodeType === 'ArrowFunctionExpression' && isLifecycleMethod) {
           const body = node.value.body;
           const isBlockBody = body.type === 'BlockStatement';
-          const sourceCode = context.getSourceCode();
+          const sourceCode = getSourceCode(context);
 
           let nextComment = [];
           let previousComment = [];
@@ -102,7 +107,7 @@ module.exports = {
             node.key.range[1],
             (previousComment.length > 0 ? previousComment[0] : body).range[0],
           ];
-          const hasSemi = node.value.expression && sourceCode.getText(node).slice(node.value.range[1] - node.range[0]) === ';';
+          const hasSemi = node.value.expression && getText(context, node).slice(node.value.range[1] - node.range[0]) === ';';
 
           report(
             context,
@@ -116,13 +121,13 @@ module.exports = {
               fix(fixer) {
                 if (!sourceCode.getCommentsAfter) {
                   // eslint 3.x
-                  return isBlockBody && fixer.replaceTextRange(headRange, getText(node));
+                  return isBlockBody && fixer.replaceTextRange(headRange, getRuleText(node));
                 }
                 return [].concat(
-                  fixer.replaceTextRange(headRange, getText(node)),
+                  fixer.replaceTextRange(headRange, getRuleText(node)),
                   isBlockBody ? [] : fixer.replaceTextRange(
                     [bodyRange[0], bodyRange[1] + (hasSemi ? 1 : 0)],
-                    `{ return ${previousComment.map((x) => sourceCode.getText(x)).join('')}${sourceCode.getText(body)}${nextComment.map((x) => sourceCode.getText(x)).join('')}; }`
+                    `{ return ${previousComment.map((x) => getText(context, x)).join('')}${getText(context, body)}${nextComment.map((x) => getText(context, x)).join('')}; }`
                   )
                 );
               },
diff --git a/lib/rules/no-children-prop.js b/lib/rules/no-children-prop.js
index 440e61e945..84ccbbf3a6 100644
--- a/lib/rules/no-children-prop.js
+++ b/lib/rules/no-children-prop.js
@@ -17,11 +17,11 @@ const report = require('../util/report');
  * Checks if the node is a createElement call with a props literal.
  * @param {ASTNode} node - The AST node being checked.
  * @param {Context} context - The AST node being checked.
- * @returns {Boolean} - True if node is a createElement call with a props
+ * @returns {boolean} - True if node is a createElement call with a props
  * object literal, False if not.
 */
 function isCreateElementWithProps(node, context) {
-  return isCreateElement(node, context)
+  return isCreateElement(context, node)
     && node.arguments.length > 1
     && node.arguments[1].type === 'ObjectExpression';
 }
@@ -37,6 +37,7 @@ const messages = {
   passFunctionAsArgs: 'Do not pass a function as an additional argument to React.createElement. Instead, pass it as a prop.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -86,11 +87,16 @@ module.exports = {
           return;
         }
 
-        const props = node.arguments[1].properties;
-        const childrenProp = props.find((prop) => prop.key && prop.key.name === 'children');
+        const props = 'properties' in node.arguments[1] ? node.arguments[1].properties : undefined;
+        const childrenProp = props.find((prop) => (
+          'key' in prop
+          && prop.key
+          && 'name' in prop.key
+          && prop.key.name === 'children'
+        ));
 
         if (childrenProp) {
-          if (childrenProp.value && !isFunction(childrenProp.value)) {
+          if ('value' in childrenProp && childrenProp.value && !isFunction(childrenProp.value)) {
             report(context, messages.passChildrenAsArgs, 'passChildrenAsArgs', {
               node,
             });
diff --git a/lib/rules/no-danger-with-children.js b/lib/rules/no-danger-with-children.js
index 17d55930ff..3b01998502 100644
--- a/lib/rules/no-danger-with-children.js
+++ b/lib/rules/no-danger-with-children.js
@@ -17,6 +17,7 @@ const messages = {
   dangerWithChildren: 'Only set one of `children` or `props.dangerouslySetInnerHTML`',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -31,8 +32,8 @@ module.exports = {
     schema: [], // no options
   },
   create(context) {
-    function findSpreadVariable(name) {
-      return variableUtil.variablesInScope(context).find((item) => item.name === name);
+    function findSpreadVariable(node, name) {
+      return variableUtil.getVariableFromContext(context, node, name);
     }
     /**
      * Takes a ObjectExpression and returns the value of the prop if it has it
@@ -50,7 +51,7 @@ module.exports = {
           return prop.key.name === propName;
         }
         if (prop.type === 'ExperimentalSpreadProperty' || prop.type === 'SpreadElement') {
-          const variable = findSpreadVariable(prop.argument.name);
+          const variable = findSpreadVariable(node, prop.argument.name);
           if (variable && variable.defs.length && variable.defs[0].node.init) {
             if (seenProps.indexOf(prop.argument.name) > -1) {
               return false;
@@ -73,7 +74,7 @@ module.exports = {
       const attributes = node.openingElement.attributes;
       return attributes.find((attribute) => {
         if (attribute.type === 'JSXSpreadAttribute') {
-          const variable = findSpreadVariable(attribute.argument.name);
+          const variable = findSpreadVariable(node, attribute.argument.name);
           if (variable && variable.defs.length && variable.defs[0].node.init) {
             return findObjectProp(variable.defs[0].node.init, propName, []);
           }
@@ -85,7 +86,7 @@ module.exports = {
     /**
      * Checks to see if a node is a line break
      * @param {ASTNode} node The AST node being checked
-     * @returns {Boolean} True if node is a line break, false if not
+     * @returns {boolean} True if node is a line break, false if not
      */
     function isLineBreak(node) {
       const isLiteral = node.type === 'Literal' || node.type === 'JSXText';
@@ -119,6 +120,7 @@ module.exports = {
         if (
           node.callee
           && node.callee.type === 'MemberExpression'
+          && 'name' in node.callee.property
           && node.callee.property.name === 'createElement'
           && node.arguments.length > 1
         ) {
@@ -127,7 +129,7 @@ module.exports = {
           let props = node.arguments[1];
 
           if (props.type === 'Identifier') {
-            const variable = variableUtil.variablesInScope(context).find((item) => item.name === props.name);
+            const variable = variableUtil.getVariableFromContext(context, node, props.name);
             if (variable && variable.defs.length && variable.defs[0].node.init) {
               props = variable.defs[0].node.init;
             }
diff --git a/lib/rules/no-danger.js b/lib/rules/no-danger.js
index a7cf8b59f8..54dbed49cf 100644
--- a/lib/rules/no-danger.js
+++ b/lib/rules/no-danger.js
@@ -5,8 +5,9 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const fromEntries = require('object.fromentries/polyfill')();
+const minimatch = require('minimatch');
 
 const docsUrl = require('../util/docsUrl');
 const jsxUtil = require('../util/jsx');
@@ -28,7 +29,7 @@ const DANGEROUS_PROPERTIES = fromEntries(DANGEROUS_PROPERTY_NAMES.map((prop) =>
 
 /**
  * Checks if a JSX attribute is dangerous.
- * @param {String} name - Name of the attribute to check.
+ * @param {string} name - Name of the attribute to check.
  * @returns {boolean} Whether or not the attribute is dangerous.
  */
 function isDangerous(name) {
@@ -43,6 +44,7 @@ const messages = {
   dangerousProp: 'Dangerous property \'{{name}}\' found',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -54,13 +56,33 @@ module.exports = {
 
     messages,
 
-    schema: [],
+    schema: [{
+      type: 'object',
+      properties: {
+        customComponentNames: {
+          items: {
+            type: 'string',
+          },
+          minItems: 0,
+          type: 'array',
+          uniqueItems: true,
+        },
+      },
+    }],
   },
 
   create(context) {
+    const configuration = context.options[0] || {};
+    const customComponentNames = configuration.customComponentNames || [];
+
     return {
       JSXAttribute(node) {
-        if (jsxUtil.isDOMComponent(node.parent) && isDangerous(node.name.name)) {
+        const nodeName = node.parent.name;
+        const functionName = nodeName.name || `${nodeName.object.name}.${nodeName.property.name}`;
+
+        const enableCheckingCustomComponent = customComponentNames.some((name) => minimatch(functionName, name));
+
+        if ((enableCheckingCustomComponent || jsxUtil.isDOMComponent(node.parent)) && isDangerous(node.name.name)) {
           report(context, messages.dangerousProp, 'dangerousProp', {
             node,
             data: {
diff --git a/lib/rules/no-deprecated.js b/lib/rules/no-deprecated.js
index d37b55bbfd..0c5931345f 100644
--- a/lib/rules/no-deprecated.js
+++ b/lib/rules/no-deprecated.js
@@ -14,6 +14,7 @@ const docsUrl = require('../util/docsUrl');
 const pragmaUtil = require('../util/pragma');
 const testReactVersion = require('../util/version').testReactVersion;
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
 
 // ------------------------------------------------------------------------------
 // Constants
@@ -114,6 +115,7 @@ const messages = {
   deprecated: '{{oldMethod}} is deprecated since React {{version}}{{newMethod}}{{refs}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -217,7 +219,7 @@ module.exports = {
 
     return {
       MemberExpression(node) {
-        checkDeprecation(node, context.getSourceCode().getText(node));
+        checkDeprecation(node, getText(context, node));
       },
 
       ImportDeclaration(node) {
@@ -225,18 +227,24 @@ module.exports = {
         if (!isReactImport) {
           return;
         }
-        node.specifiers.filter(((s) => s.imported)).forEach((specifier) => {
-          checkDeprecation(node, `${MODULES[node.source.value][0]}.${specifier.imported.name}`, specifier);
+        node.specifiers.filter(((s) => 'imported' in s && s.imported)).forEach((specifier) => {
+          // TODO, semver-major: remove `in` check as part of jsdoc->tsdoc migration
+          checkDeprecation(node, 'imported' in specifier && 'name' in specifier.imported && `${MODULES[node.source.value][0]}.${specifier.imported.name}`, specifier);
         });
       },
 
       VariableDeclarator(node) {
         const reactModuleName = getReactModuleName(node);
-        const isRequire = node.init && node.init.callee && node.init.callee.name === 'require';
+        const isRequire = node.init
+          && 'callee' in node.init
+          && node.init.callee
+          && 'name' in node.init.callee
+          && node.init.callee.name === 'require';
         const isReactRequire = node.init
+          && 'arguments' in node.init
           && node.init.arguments
           && node.init.arguments.length
-          && typeof MODULES[node.init.arguments[0].value] !== 'undefined';
+          && typeof MODULES['value' in node.init.arguments[0] ? node.init.arguments[0].value : undefined] !== 'undefined';
         const isDestructuring = node.id && node.id.type === 'ObjectPattern';
 
         if (
@@ -245,8 +253,13 @@ module.exports = {
         ) {
           return;
         }
-        node.id.properties.filter((p) => p.type !== 'RestElement' && p.key).forEach((property) => {
-          checkDeprecation(node, `${reactModuleName || pragma}.${property.key.name}`, property);
+
+        ('properties' in node.id ? node.id.properties : undefined).filter((p) => p.type !== 'RestElement' && p.key).forEach((property) => {
+          checkDeprecation(
+            node,
+            'key' in property && 'name' in property.key && `${reactModuleName || pragma}.${property.key.name}`,
+            property
+          );
         });
       },
 
diff --git a/lib/rules/no-did-mount-set-state.js b/lib/rules/no-did-mount-set-state.js
index a5705ef2df..ad70c3eb7b 100644
--- a/lib/rules/no-did-mount-set-state.js
+++ b/lib/rules/no-did-mount-set-state.js
@@ -7,4 +7,5 @@
 
 const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = makeNoMethodSetStateRule('componentDidMount');
diff --git a/lib/rules/no-did-update-set-state.js b/lib/rules/no-did-update-set-state.js
index 5c76a1ff5b..d297fb2648 100644
--- a/lib/rules/no-did-update-set-state.js
+++ b/lib/rules/no-did-update-set-state.js
@@ -7,4 +7,5 @@
 
 const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = makeNoMethodSetStateRule('componentDidUpdate');
diff --git a/lib/rules/no-direct-mutation-state.js b/lib/rules/no-direct-mutation-state.js
index 08d77e9bca..761151fbb8 100644
--- a/lib/rules/no-direct-mutation-state.js
+++ b/lib/rules/no-direct-mutation-state.js
@@ -21,6 +21,7 @@ const messages = {
   noDirectMutation: 'Do not mutate state directly. Use setState().',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -37,10 +38,10 @@ module.exports = {
     /**
      * Checks if the component is valid
      * @param {Object} component The component to process
-     * @returns {Boolean} True if the component is valid, false if not.
+     * @returns {boolean} True if the component is valid, false if not.
      */
     function isValid(component) {
-      return Boolean(component && !component.mutateSetState);
+      return !!component && !component.mutateSetState;
     }
 
     /**
@@ -72,7 +73,7 @@ module.exports = {
     /**
      * Determine if we should currently ignore assignments in this component.
      * @param {?Object} component The component to process
-     * @returns {Boolean} True if we should skip assignment checks.
+     * @returns {boolean} True if we should skip assignment checks.
      */
     function shouldIgnoreComponent(component) {
       return !component || (component.inConstructor && !component.inCallExpression);
@@ -97,7 +98,7 @@ module.exports = {
       },
 
       AssignmentExpression(node) {
-        const component = components.get(utils.getParentComponent());
+        const component = components.get(utils.getParentComponent(node));
         if (shouldIgnoreComponent(component) || !node.left || !node.left.object) {
           return;
         }
@@ -113,7 +114,7 @@ module.exports = {
       },
 
       UpdateExpression(node) {
-        const component = components.get(utils.getParentComponent());
+        const component = components.get(utils.getParentComponent(node));
         if (shouldIgnoreComponent(component) || node.argument.type !== 'MemberExpression') {
           return;
         }
diff --git a/lib/rules/no-find-dom-node.js b/lib/rules/no-find-dom-node.js
index 0dae59da43..eaf9e53a46 100644
--- a/lib/rules/no-find-dom-node.js
+++ b/lib/rules/no-find-dom-node.js
@@ -16,6 +16,7 @@ const messages = {
   noFindDOMNode: 'Do not use findDOMNode. It doesn’t work with function components and is deprecated in StrictMode. See https://reactjs.org/docs/react-dom.html#finddomnode',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -35,9 +36,14 @@ module.exports = {
       CallExpression(node) {
         const callee = node.callee;
 
-        const isfindDOMNode = (callee.name === 'findDOMNode')
-          || (callee.property && callee.property.name === 'findDOMNode');
-        if (!isfindDOMNode) {
+        const isFindDOMNode = ('name' in callee && callee.name === 'findDOMNode') || (
+          'property' in callee
+          && callee.property
+          && 'name' in callee.property
+          && callee.property.name === 'findDOMNode'
+        );
+
+        if (!isFindDOMNode) {
           return;
         }
 
diff --git a/lib/rules/no-invalid-html-attribute.js b/lib/rules/no-invalid-html-attribute.js
index 1dd4d0f44b..b8a14d1ab1 100644
--- a/lib/rules/no-invalid-html-attribute.js
+++ b/lib/rules/no-invalid-html-attribute.js
@@ -8,7 +8,6 @@
 const matchAll = require('string.prototype.matchall');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
-const getMessageData = require('../util/message');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -224,6 +223,7 @@ const COMPONENT_ATTRIBUTE_MAP = new Map([
   ['rel', new Set(['link', 'a', 'area', 'form'])],
 ]);
 
+/* eslint-disable eslint-plugin/no-unused-message-ids -- false positives, these messageIds are used */
 const messages = {
   emptyIsMeaningless: 'An empty “{{attributeName}}” attribute is meaningless.',
   neverValid: '“{{reportingValue}}” is never a valid “{{attributeName}}” attribute value.',
@@ -238,8 +238,8 @@ const messages = {
   suggestRemoveDefault: '"remove {{attributeName}}"',
   suggestRemoveEmpty: '"remove empty attribute {{attributeName}}"',
   suggestRemoveInvalid: '“remove invalid attribute {{reportingValue}}”',
-  suggestRemoveWhitespaces: 'remove whitespaces in “{{reportingValue}}”',
-  suggestRemoveNonString: 'remove non-string value in “{{reportingValue}}”',
+  suggestRemoveWhitespaces: 'remove whitespaces in “{{attributeName}}”',
+  suggestRemoveNonString: 'remove non-string value in “{{attributeName}}”',
 };
 
 function splitIntoRangedParts(node, regex) {
@@ -259,75 +259,83 @@ function splitIntoRangedParts(node, regex) {
 
 function checkLiteralValueNode(context, attributeName, node, parentNode, parentNodeName) {
   if (typeof node.value !== 'string') {
+    const data = { attributeName, reportingValue: node.value };
+
     report(context, messages.onlyStrings, 'onlyStrings', {
       node,
-      data: { attributeName },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveNonString', messages.suggestRemoveNonString),
-          { fix(fixer) { return fixer.remove(parentNode); } }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveNonString',
+        data,
+        fix(fixer) { return fixer.remove(parentNode); },
+      }],
     });
     return;
   }
 
   if (!node.value.trim()) {
+    const data = { attributeName, reportingValue: node.value };
+
     report(context, messages.noEmpty, 'noEmpty', {
       node,
-      data: { attributeName },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveEmpty', messages.suggestRemoveEmpty),
-          { fix(fixer) { return fixer.remove(node.parent); } }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveEmpty',
+        data,
+        fix(fixer) { return fixer.remove(node.parent); },
+      }],
     });
     return;
   }
 
   const singleAttributeParts = splitIntoRangedParts(node, /(\S+)/g);
-  for (const singlePart of singleAttributeParts) {
+  singleAttributeParts.forEach((singlePart) => {
     const allowedTags = VALID_VALUES.get(attributeName).get(singlePart.value);
     const reportingValue = singlePart.reportingValue;
 
-    const suggest = [
-      Object.assign(
-        getMessageData('suggestRemoveInvalid', messages.suggestRemoveInvalid),
-        { fix(fixer) { return fixer.removeRange(singlePart.range); } }
-      ),
-    ];
-
     if (!allowedTags) {
       const data = {
         attributeName,
         reportingValue,
       };
+
+      const suggest = [{
+        messageId: 'suggestRemoveInvalid',
+        data,
+        fix(fixer) { return fixer.removeRange(singlePart.range); },
+      }];
+
       report(context, messages.neverValid, 'neverValid', {
         node,
         data,
         suggest,
       });
     } else if (!allowedTags.has(parentNodeName)) {
+      const data = {
+        attributeName,
+        reportingValue,
+        elementName: parentNodeName,
+      };
+
+      const suggest = [{
+        messageId: 'suggestRemoveInvalid',
+        data,
+        fix(fixer) { return fixer.removeRange(singlePart.range); },
+      }];
+
       report(context, messages.notValidFor, 'notValidFor', {
         node,
-        data: {
-          attributeName,
-          reportingValue,
-          elementName: parentNodeName,
-        },
+        data,
         suggest,
       });
     }
-  }
+  });
 
   const allowedPairsForAttribute = VALID_PAIR_VALUES.get(attributeName);
   if (allowedPairsForAttribute) {
     const pairAttributeParts = splitIntoRangedParts(node, /(?=(\b\S+\s*\S+))/g);
-    for (const pairPart of pairAttributeParts) {
-      for (const allowedPair of allowedPairsForAttribute) {
-        const pairing = allowedPair[0];
-        const siblings = allowedPair[1];
+    pairAttributeParts.forEach((pairPart) => {
+      allowedPairsForAttribute.forEach((siblings, pairing) => {
         const attributes = pairPart.reportingValue.split('\u0020');
         const firstValue = attributes[0];
         const secondValue = attributes[1];
@@ -347,36 +355,36 @@ function checkLiteralValueNode(context, attributeName, node, parentNode, parentN
             });
           }
         }
-      }
-    }
+      });
+    });
   }
 
   const whitespaceParts = splitIntoRangedParts(node, /(\s+)/g);
-  for (const whitespacePart of whitespaceParts) {
+  whitespaceParts.forEach((whitespacePart) => {
+    const data = { attributeName };
+
     if (whitespacePart.range[0] === (node.range[0] + 1) || whitespacePart.range[1] === (node.range[1] - 1)) {
       report(context, messages.spaceDelimited, 'spaceDelimited', {
         node,
-        data: { attributeName },
-        suggest: [
-          Object.assign(
-            getMessageData('suggestRemoveWhitespaces', messages.suggestRemoveWhitespaces),
-            { fix(fixer) { return fixer.removeRange(whitespacePart.range); } }
-          ),
-        ],
+        data,
+        suggest: [{
+          messageId: 'suggestRemoveWhitespaces',
+          data,
+          fix(fixer) { return fixer.removeRange(whitespacePart.range); },
+        }],
       });
     } else if (whitespacePart.value !== '\u0020') {
       report(context, messages.spaceDelimited, 'spaceDelimited', {
         node,
-        data: { attributeName },
-        suggest: [
-          Object.assign(
-            getMessageData('suggestRemoveWhitespaces', messages.suggestRemoveWhitespaces),
-            { fix(fixer) { return fixer.replaceTextRange(whitespacePart.range, '\u0020'); } }
-          ),
-        ],
+        data,
+        suggest: [{
+          messageId: 'suggestRemoveWhitespaces',
+          data,
+          fix(fixer) { return fixer.replaceTextRange(whitespacePart.range, '\u0020'); },
+        }],
       });
     }
-  }
+  });
 }
 
 const DEFAULT_ATTRIBUTES = ['rel'];
@@ -390,18 +398,19 @@ function checkAttribute(context, node) {
       COMPONENT_ATTRIBUTE_MAP.get(attribute).values(),
       (tagName) => `"<${tagName}>"`
     ).join(', ');
+    const data = {
+      attributeName: attribute,
+      tagNames,
+    };
+
     report(context, messages.onlyMeaningfulFor, 'onlyMeaningfulFor', {
       node: node.name,
-      data: {
-        attributeName: attribute,
-        tagNames,
-      },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveDefault', messages.suggestRemoveDefault),
-          { fix(fixer) { return fixer.remove(node); } }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveDefault',
+        data,
+        fix(fixer) { return fixer.remove(node); },
+      }],
     });
     return;
   }
@@ -409,15 +418,16 @@ function checkAttribute(context, node) {
   function fix(fixer) { return fixer.remove(node); }
 
   if (!node.value) {
+    const data = { attributeName: attribute };
+
     report(context, messages.emptyIsMeaningless, 'emptyIsMeaningless', {
       node: node.name,
-      data: { attributeName: attribute },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveEmpty', messages.suggestRemoveEmpty),
-          { fix }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveEmpty',
+        data,
+        fix,
+      }],
     });
     return;
   }
@@ -435,26 +445,28 @@ function checkAttribute(context, node) {
   }
 
   if (node.value.expression.type === 'ObjectExpression') {
+    const data = { attributeName: attribute };
+
     report(context, messages.onlyStrings, 'onlyStrings', {
       node: node.value,
-      data: { attributeName: attribute },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveDefault', messages.suggestRemoveDefault),
-          { fix }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveDefault',
+        data,
+        fix,
+      }],
     });
   } else if (node.value.expression.type === 'Identifier' && node.value.expression.name === 'undefined') {
+    const data = { attributeName: attribute };
+
     report(context, messages.onlyStrings, 'onlyStrings', {
       node: node.value,
-      data: { attributeName: attribute },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveDefault', messages.suggestRemoveDefault),
-          { fix }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveDefault',
+        data,
+        fix,
+      }],
     });
   }
 }
@@ -476,18 +488,19 @@ function checkPropValidValue(context, node, value, attribute) {
 
   const validTagSet = validTags.get(value.value);
   if (!validTagSet) {
+    const data = {
+      attributeName: attribute,
+      reportingValue: value.value,
+    };
+
     report(context, messages.neverValid, 'neverValid', {
       node: value,
-      data: {
-        attributeName: attribute,
-        reportingValue: value.value,
-      },
-      suggest: [
-        Object.assign(
-          getMessageData('suggestRemoveInvalid', messages.suggestRemoveInvalid),
-          { fix(fixer) { return fixer.replaceText(value, value.raw.replace(value.value, '')); } }
-        ),
-      ],
+      data,
+      suggest: [{
+        messageId: 'suggestRemoveInvalid',
+        data,
+        fix(fixer) { return fixer.replaceText(value, value.raw.replace(value.value, '')); },
+      }],
     });
   } else if (!validTagSet.has(node.arguments[0].value)) {
     report(context, messages.notValidFor, 'notValidFor', {
@@ -564,9 +577,9 @@ function checkCreateProps(context, node, attribute) {
     }
 
     if (prop.value.type === 'ArrayExpression') {
-      for (const value of prop.value.elements) {
+      prop.value.elements.forEach((value) => {
         checkPropValidValue(context, node, value, attribute);
-      }
+      });
 
       // eslint-disable-next-line no-continue
       continue;
@@ -576,6 +589,7 @@ function checkCreateProps(context, node, attribute) {
   }
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -625,15 +639,15 @@ module.exports = {
         }
 
         // ignore non-HTML elements
-        if (!HTML_ELEMENTS.has(elemNameArg.value)) {
+        if (typeof elemNameArg.value === 'string' && !HTML_ELEMENTS.has(elemNameArg.value)) {
           return;
         }
 
         const attributes = new Set(context.options[0] || DEFAULT_ATTRIBUTES);
 
-        for (const attribute of attributes) {
+        attributes.forEach((attribute) => {
           checkCreateProps(context, node, attribute);
-        }
+        });
       },
     };
   },
diff --git a/lib/rules/no-is-mounted.js b/lib/rules/no-is-mounted.js
index c15b6e81a4..24d9a37d02 100644
--- a/lib/rules/no-is-mounted.js
+++ b/lib/rules/no-is-mounted.js
@@ -6,6 +6,7 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getAncestors = require('../util/eslint').getAncestors;
 const report = require('../util/report');
 
 // ------------------------------------------------------------------------------
@@ -16,6 +17,7 @@ const messages = {
   noIsMounted: 'Do not use isMounted',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -37,10 +39,14 @@ module.exports = {
         if (callee.type !== 'MemberExpression') {
           return;
         }
-        if (callee.object.type !== 'ThisExpression' || callee.property.name !== 'isMounted') {
+        if (
+          callee.object.type !== 'ThisExpression'
+          || !('name' in callee.property)
+          || callee.property.name !== 'isMounted'
+        ) {
           return;
         }
-        const ancestors = context.getAncestors(callee);
+        const ancestors = getAncestors(context, node);
         for (let i = 0, j = ancestors.length; i < j; i++) {
           if (ancestors[i].type === 'Property' || ancestors[i].type === 'MethodDefinition') {
             report(context, messages.noIsMounted, 'noIsMounted', {
diff --git a/lib/rules/no-multi-comp.js b/lib/rules/no-multi-comp.js
index 31b9ef0d4e..8cf73c90bc 100644
--- a/lib/rules/no-multi-comp.js
+++ b/lib/rules/no-multi-comp.js
@@ -19,6 +19,7 @@ const messages = {
   onlyOneComponent: 'Declare only one React component per file',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -49,7 +50,7 @@ module.exports = {
     /**
      * Checks if the component is ignored
      * @param {Object} component The component being checked.
-     * @returns {Boolean} True if the component is ignored, false if not.
+     * @returns {boolean} True if the component is ignored, false if not.
      */
     function isIgnored(component) {
       return (
diff --git a/lib/rules/no-namespace.js b/lib/rules/no-namespace.js
index 64bbc8d521..20ca5d9324 100644
--- a/lib/rules/no-namespace.js
+++ b/lib/rules/no-namespace.js
@@ -18,6 +18,7 @@ const messages = {
   noNamespace: 'React component {{name}} must not be in a namespace, as React does not support them',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -35,7 +36,7 @@ module.exports = {
   create(context) {
     return {
       CallExpression(node) {
-        if (isCreateElement(node, context) && node.arguments.length > 0 && node.arguments[0].type === 'Literal') {
+        if (isCreateElement(context, node) && node.arguments.length > 0 && node.arguments[0].type === 'Literal') {
           const name = node.arguments[0].value;
           if (typeof name !== 'string' || name.indexOf(':') === -1) return undefined;
           report(context, messages.noNamespace, 'noNamespace', {
diff --git a/lib/rules/no-object-type-as-default-prop.js b/lib/rules/no-object-type-as-default-prop.js
index 2ba25889d8..2683bfea4c 100644
--- a/lib/rules/no-object-type-as-default-prop.js
+++ b/lib/rules/no-object-type-as-default-prop.js
@@ -9,6 +9,7 @@ const values = require('object.values');
 
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const report = require('../util/report');
 
 const FORBIDDEN_TYPES_MAP = {
@@ -30,7 +31,7 @@ const messages = {
 function hasUsedObjectDestructuringSyntax(params) {
   return (
     params != null
-    && params.length === 1
+    && params.length >= 1
     && params[0].type === 'ObjectPattern'
   );
 }
@@ -55,7 +56,7 @@ function verifyDefaultPropsDestructuring(context, properties) {
         },
       });
     } else if (
-      propDefaultValueType === 'CallExpression'
+      astUtil.isCallExpression(propDefaultValue.right)
       && propDefaultValue.right.callee.type === 'Identifier'
       && propDefaultValue.right.callee.name === 'Symbol'
     ) {
@@ -78,6 +79,7 @@ function verifyDefaultPropsDestructuring(context, properties) {
   });
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/no-redundant-should-component-update.js b/lib/rules/no-redundant-should-component-update.js
index bf7601a2c4..e7a439d8e8 100644
--- a/lib/rules/no-redundant-should-component-update.js
+++ b/lib/rules/no-redundant-should-component-update.js
@@ -17,6 +17,7 @@ const messages = {
   noShouldCompUpdate: '{{component}} does not need shouldComponentUpdate when extending React.PureComponent.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -35,7 +36,7 @@ module.exports = {
     /**
      * Checks for shouldComponentUpdate property
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} Whether or not the property exists.
+     * @returns {boolean} Whether or not the property exists.
      */
     function hasShouldComponentUpdate(node) {
       const properties = astUtil.getComponentProperties(node);
@@ -48,7 +49,7 @@ module.exports = {
     /**
      * Get name of node if available
      * @param {ASTNode} node The AST node being checked.
-     * @return {String} The name of the node
+     * @return {string} The name of the node
      */
     function getNodeName(node) {
       if (node.id) {
diff --git a/lib/rules/no-render-return-value.js b/lib/rules/no-render-return-value.js
index 61818a92aa..9e0f9d4046 100644
--- a/lib/rules/no-render-return-value.js
+++ b/lib/rules/no-render-return-value.js
@@ -17,6 +17,7 @@ const messages = {
   noReturnValue: 'Do not depend on the return value from {{node}}.render',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -56,7 +57,7 @@ module.exports = {
         if (
           callee.object.type !== 'Identifier'
           || !calleeObjectName.test(callee.object.name)
-          || callee.property.name !== 'render'
+          || (!('name' in callee.property) || callee.property.name !== 'render')
         ) {
           return;
         }
diff --git a/lib/rules/no-set-state.js b/lib/rules/no-set-state.js
index 486eb211ff..44967bf03c 100644
--- a/lib/rules/no-set-state.js
+++ b/lib/rules/no-set-state.js
@@ -19,6 +19,7 @@ const messages = {
   noSetState: 'Do not use setState',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -37,10 +38,10 @@ module.exports = {
     /**
      * Checks if the component is valid
      * @param {Object} component The component to process
-     * @returns {Boolean} True if the component is valid, false if not.
+     * @returns {boolean} True if the component is valid, false if not.
      */
     function isValid(component) {
-      return Boolean(component && !component.useSetState);
+      return !!component && !component.useSetState;
     }
 
     /**
@@ -48,9 +49,8 @@ module.exports = {
      * @param {Object} component The component to process
      */
     function reportSetStateUsages(component) {
-      let setStateUsage;
       for (let i = 0, j = component.setStateUsages.length; i < j; i++) {
-        setStateUsage = component.setStateUsages[i];
+        const setStateUsage = component.setStateUsages[i];
         report(context, messages.noSetState, 'noSetState', {
           node: setStateUsage,
         });
@@ -67,7 +67,7 @@ module.exports = {
         ) {
           return;
         }
-        const component = components.get(utils.getParentComponent());
+        const component = components.get(utils.getParentComponent(node));
         const setStateUsages = (component && component.setStateUsages) || [];
         setStateUsages.push(callee);
         components.set(node, {
diff --git a/lib/rules/no-string-refs.js b/lib/rules/no-string-refs.js
index 2decbbe6bb..145ad25780 100644
--- a/lib/rules/no-string-refs.js
+++ b/lib/rules/no-string-refs.js
@@ -8,6 +8,7 @@
 const componentUtil = require('../util/componentUtil');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const testReactVersion = require('../util/version').testReactVersion;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -18,6 +19,7 @@ const messages = {
   stringInRefDeprecated: 'Using string literals in ref attributes is deprecated.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -41,15 +43,16 @@ module.exports = {
   },
 
   create(context) {
+    const checkRefsUsage = testReactVersion(context, '< 18.3.0'); // `this.refs` is writable in React 18.3.0 and later, see https://github.com/facebook/react/pull/28867
     const detectTemplateLiterals = context.options[0] ? context.options[0].noTemplateLiterals : false;
     /**
      * Checks if we are using refs
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if we are using refs, false if not.
+     * @returns {boolean} True if we are using refs, false if not.
      */
     function isRefsUsage(node) {
       return !!(
-        (componentUtil.getParentES6Component(context) || componentUtil.getParentES5Component(context))
+        (componentUtil.getParentES6Component(context, node) || componentUtil.getParentES5Component(context, node))
         && node.object.type === 'ThisExpression'
         && node.property.name === 'refs'
       );
@@ -58,52 +61,47 @@ module.exports = {
     /**
      * Checks if we are using a ref attribute
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if we are using a ref attribute, false if not.
+     * @returns {boolean} True if we are using a ref attribute, false if not.
      */
     function isRefAttribute(node) {
-      return !!(
-        node.type === 'JSXAttribute'
-        && node.name
-        && node.name.name === 'ref'
-      );
+      return node.type === 'JSXAttribute'
+        && !!node.name
+        && node.name.name === 'ref';
     }
 
     /**
      * Checks if a node contains a string value
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if the node contains a string value, false if not.
+     * @returns {boolean} True if the node contains a string value, false if not.
      */
     function containsStringLiteral(node) {
-      return !!(
-        node.value
+      return !!node.value
         && node.value.type === 'Literal'
-        && typeof node.value.value === 'string'
-      );
+        && typeof node.value.value === 'string';
     }
 
     /**
      * Checks if a node contains a string value within a jsx expression
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if the node contains a string value within a jsx expression, false if not.
+     * @returns {boolean} True if the node contains a string value within a jsx expression, false if not.
      */
     function containsStringExpressionContainer(node) {
-      return !!(
-        node.value
+      return !!node.value
         && node.value.type === 'JSXExpressionContainer'
         && node.value.expression
         && ((node.value.expression.type === 'Literal' && typeof node.value.expression.value === 'string')
-        || (node.value.expression.type === 'TemplateLiteral' && detectTemplateLiterals))
-      );
+        || (node.value.expression.type === 'TemplateLiteral' && detectTemplateLiterals));
     }
 
     return {
       MemberExpression(node) {
-        if (isRefsUsage(node)) {
+        if (checkRefsUsage && isRefsUsage(node)) {
           report(context, messages.thisRefsDeprecated, 'thisRefsDeprecated', {
             node,
           });
         }
       },
+
       JSXAttribute(node) {
         if (
           isRefAttribute(node)
diff --git a/lib/rules/no-this-in-sfc.js b/lib/rules/no-this-in-sfc.js
index 9c1535ef0b..c520abd31c 100644
--- a/lib/rules/no-this-in-sfc.js
+++ b/lib/rules/no-this-in-sfc.js
@@ -16,6 +16,7 @@ const messages = {
   noThisInSFC: 'Stateless functional components should not use `this`',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -33,7 +34,7 @@ module.exports = {
   create: Components.detect((context, components, utils) => ({
     MemberExpression(node) {
       if (node.object.type === 'ThisExpression') {
-        const component = components.get(utils.getParentStatelessComponent());
+        const component = components.get(utils.getParentStatelessComponent(node));
         if (!component || (component.node && component.node.parent && component.node.parent.type === 'Property')) {
           return;
         }
diff --git a/lib/rules/no-typos.js b/lib/rules/no-typos.js
index ba826d523d..a598a8e114 100644
--- a/lib/rules/no-typos.js
+++ b/lib/rules/no-typos.js
@@ -7,6 +7,7 @@
 const PROP_TYPES = Object.keys(require('prop-types'));
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const report = require('../util/report');
 const lifecycleMethods = require('../util/lifecycleMethods');
@@ -28,6 +29,7 @@ const messages = {
   noReactBinding: '`\'react\'` imported without a local `React` binding.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -108,11 +110,11 @@ module.exports = {
           && node.property.name !== 'isRequired'
         ) { // PropTypes.myProp
           checkValidPropType(node.property);
-        } else if (node.object.type === 'CallExpression') {
+        } else if (astUtil.isCallExpression(node.object)) {
           checkValidPropTypeQualifier(node.property);
           checkValidCallExpression(node.object);
         }
-      } else if (node.type === 'CallExpression') {
+      } else if (astUtil.isCallExpression(node)) {
         checkValidCallExpression(node);
       }
     }
@@ -193,7 +195,8 @@ module.exports = {
           }
           if (node.specifiers.length >= 1) {
             const propTypesSpecifier = node.specifiers.find((specifier) => (
-              specifier.imported && specifier.imported.name === 'PropTypes'
+              specifier.imported
+              && specifier.imported.name === 'PropTypes'
             ));
             if (propTypesSpecifier) {
               propTypesPackageName = propTypesSpecifier.local.name;
diff --git a/lib/rules/no-unescaped-entities.js b/lib/rules/no-unescaped-entities.js
index 3eaa7cd757..3ec2cb23b6 100644
--- a/lib/rules/no-unescaped-entities.js
+++ b/lib/rules/no-unescaped-entities.js
@@ -6,8 +6,10 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
+const getSourceCode = require('../util/eslint').getSourceCode;
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
+const getMessageData = require('../util/message');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -33,10 +35,13 @@ const DEFAULTS = [{
 const messages = {
   unescapedEntity: 'HTML entity, `{{entity}}` , must be escaped.',
   unescapedEntityAlts: '`{{entity}}` can be escaped with {{alts}}.',
+  replaceWithAlt: 'Replace with `{{alt}}`.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
+    hasSuggestions: true,
     docs: {
       description: 'Disallow unescaped HTML entities from appearing in markup',
       category: 'Possible Errors',
@@ -82,9 +87,9 @@ module.exports = {
       const entities = configuration.forbid || DEFAULTS;
 
       // HTML entities are already escaped in node.value (as well as node.raw),
-      // so pull the raw text from context.getSourceCode()
+      // so pull the raw text from getSourceCode(context)
       for (let i = node.loc.start.line; i <= node.loc.end.line; i++) {
-        let rawLine = context.getSourceCode().lines[i - 1];
+        let rawLine = getSourceCode(context).lines[i - 1];
         let start = 0;
         let end = rawLine.length;
         if (i === node.loc.start.line) {
@@ -115,6 +120,25 @@ module.exports = {
                   entity: entities[j].char,
                   alts: entities[j].alternatives.map((alt) => `\`${alt}\``).join(', '),
                 },
+                suggest: entities[j].alternatives.map((alt) => Object.assign(
+                  getMessageData('replaceWithAlt', messages.replaceWithAlt),
+                  {
+                    data: { alt },
+                    fix(fixer) {
+                      const lineToChange = i - node.loc.start.line;
+
+                      const newText = node.raw.split('\n').map((line, idx) => {
+                        if (idx === lineToChange) {
+                          return line.slice(0, index) + alt + line.slice(index + 1);
+                        }
+
+                        return line;
+                      }).join('\n');
+
+                      return fixer.replaceText(node, newText);
+                    },
+                  }
+                )),
               });
             }
           }
diff --git a/lib/rules/no-unknown-property.js b/lib/rules/no-unknown-property.js
index 2e77f2898b..ff87d2f0ff 100644
--- a/lib/rules/no-unknown-property.js
+++ b/lib/rules/no-unknown-property.js
@@ -5,8 +5,9 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const docsUrl = require('../util/docsUrl');
+const getText = require('../util/eslint').getText;
 const testReactVersion = require('../util/version').testReactVersion;
 const report = require('../util/report');
 
@@ -84,7 +85,7 @@ const ATTRIBUTE_TAGS_MAP = {
   onEncrypted: ['audio', 'video'],
   onEnded: ['audio', 'video'],
   onError: ['audio', 'video', 'img', 'link', 'source', 'script', 'picture', 'iframe'],
-  onLoad: ['script', 'img', 'link', 'picture', 'iframe', 'object', 'source'],
+  onLoad: ['script', 'img', 'link', 'picture', 'iframe', 'object', 'source', 'body'],
   onLoadedData: ['audio', 'video'],
   onLoadedMetadata: ['audio', 'video'],
   onLoadStart: ['audio', 'video'],
@@ -117,6 +118,11 @@ const ATTRIBUTE_TAGS_MAP = {
   scrolling: ['iframe'],
   returnValue: ['dialog'],
   webkitDirectory: ['input'],
+  shadowrootmode: ['template'],
+  shadowrootclonable: ['template'],
+  shadowrootdelegatesfocus: ['template'],
+  shadowrootserializable: ['template'],
+  'transform-origin': ['rect'],
 };
 
 const SVGDOM_ATTRIBUTE_NAMES = {
@@ -238,6 +244,8 @@ const DOM_PROPERTY_NAMES_ONE_WORD = [
   'results', 'security',
   // Video specific
   'controls',
+  // popovers
+  'popover', 'popovertarget', 'popovertargetaction',
 ];
 
 const DOM_PROPERTY_NAMES_TWO_WORDS = [
@@ -256,8 +264,8 @@ const DOM_PROPERTY_NAMES_TWO_WORDS = [
   'onCompositionUpdate', 'onCut', 'onDoubleClick', 'onDrag', 'onDragEnd', 'onDragEnter', 'onDragExit', 'onDragLeave',
   'onError', 'onFocus', 'onInput', 'onKeyDown', 'onKeyPress', 'onKeyUp', 'onLoad', 'onWheel', 'onDragOver',
   'onDragStart', 'onDrop', 'onMouseDown', 'onMouseEnter', 'onMouseLeave', 'onMouseMove', 'onMouseOut', 'onMouseOver',
-  'onMouseUp', 'onPaste', 'onScroll', 'onSelect', 'onSubmit', 'onToggle', 'onTransitionEnd', 'radioGroup', 'readOnly', 'referrerPolicy',
-  'rowSpan', 'srcDoc', 'srcLang', 'srcSet', 'useMap',
+  'onMouseUp', 'onPaste', 'onScroll', 'onSelect', 'onSubmit', 'onBeforeToggle', 'onToggle', 'onTransitionEnd', 'radioGroup',
+  'readOnly', 'referrerPolicy', 'rowSpan', 'srcDoc', 'srcLang', 'srcSet', 'useMap', 'fetchPriority',
   // SVG attributes
   // See https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
   'crossOrigin', 'accentHeight', 'alignmentBaseline', 'arabicForm', 'attributeName',
@@ -314,9 +322,11 @@ const DOM_PROPERTY_NAMES_TWO_WORDS = [
   'onMouseMoveCapture', 'onMouseOutCapture', 'onMouseOverCapture', 'onMouseUpCapture',
   // Video specific
   'autoPictureInPicture', 'controlsList', 'disablePictureInPicture', 'disableRemotePlayback',
+  // popovers
+  'popoverTarget', 'popoverTargetAction',
 ];
 
-const DOM_PROPERTIES_IGNORE_CASE = ['charset', 'allowFullScreen', 'webkitAllowFullScreen', 'mozAllowFullScreen', 'webkitDirectory'];
+const DOM_PROPERTIES_IGNORE_CASE = ['charset', 'allowFullScreen', 'webkitAllowFullScreen', 'mozAllowFullScreen', 'webkitDirectory', 'popoverTarget', 'popoverTargetAction'];
 
 const ARIA_PROPERTIES = [
   // See https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes
@@ -360,16 +370,24 @@ const REACT_ON_PROPS = [
 ];
 
 function getDOMPropertyNames(context) {
-  const ALL_DOM_PROPERTY_NAMES = DOM_PROPERTY_NAMES_TWO_WORDS.concat(DOM_PROPERTY_NAMES_ONE_WORD);
-  // this was removed in React v16.1+, see https://github.com/facebook/react/pull/10823
-  if (!testReactVersion(context, '>= 16.1.0')) {
-    return ALL_DOM_PROPERTY_NAMES.concat('allowTransparency');
-  }
-  // these were added in React v16.4.0, see https://reactjs.org/blog/2018/05/23/react-v-16-4.html and https://github.com/facebook/react/pull/12507
-  if (testReactVersion(context, '>= 16.4.0')) {
-    return ALL_DOM_PROPERTY_NAMES.concat(REACT_ON_PROPS);
-  }
-  return ALL_DOM_PROPERTY_NAMES;
+  return [].concat(
+    DOM_PROPERTY_NAMES_TWO_WORDS,
+    DOM_PROPERTY_NAMES_ONE_WORD,
+
+    testReactVersion(context, '>= 16.1.0') ? [].concat(
+      testReactVersion(context, '>= 16.4.0') ? [].concat(
+        // these were added in React v16.4.0, see https://reactjs.org/blog/2018/05/23/react-v-16-4.html and https://github.com/facebook/react/pull/12507
+        REACT_ON_PROPS,
+        testReactVersion(context, '>= 19') ? [
+          // precedence was added in React v19, see https://react.dev/blog/2024/04/25/react-19#support-for-stylesheets
+          'precedence',
+        ] : []
+      ) : []
+    ) : [
+      // this was removed in React v16.1+, see https://github.com/facebook/react/pull/10823
+      'allowTransparency',
+    ]
+  );
 }
 
 // ------------------------------------------------------------------------------
@@ -412,8 +430,8 @@ function isValidHTMLTagInJSX(childNode) {
  *
  * Note - these exclusions are not made by React core team, but `eslint-plugin-react` community.
  *
- * @param {String} name - Attribute name to be normalized
- * @returns {String} Result
+ * @param {string} name - Attribute name to be normalized
+ * @returns {string} Result
  */
 function normalizeAttributeCase(name) {
   return DOM_PROPERTIES_IGNORE_CASE.find((element) => element.toLowerCase() === name.toLowerCase()) || name;
@@ -425,17 +443,17 @@ function normalizeAttributeCase(name) {
  * not start with any casing of "xml", and separated by hyphens (-) (which is also called "kebab case" or "dash case"),
  * then the attribute is a valid data attribute.
  *
- * @param {String} name - Attribute name to be tested
+ * @param {string} name - Attribute name to be tested
  * @returns {boolean} Result
  */
 function isValidDataAttribute(name) {
-  return !/^data-xml/i.test(name) && /^data(-?[^:]*)$/.test(name);
+  return !/^data-xml/i.test(name) && /^data-[^:]*$/.test(name);
 }
 
 /**
  * Checks if an attribute name has at least one uppercase characters
  *
- * @param {String} name
+ * @param {string} name
  * @returns {boolean} Result
  */
 function hasUpperCaseCharacter(name) {
@@ -446,8 +464,8 @@ function hasUpperCaseCharacter(name) {
  * Checks if an attribute name is a standard aria attribute by compering it to a list
  * of standard aria property names
  *
- * @param {String} name - Attribute name to be tested
- * @returns {Boolean} Result
+ * @param {string} name - Attribute name to be tested
+ * @returns {boolean} Result
  */
 
 function isValidAriaAttribute(name) {
@@ -457,10 +475,14 @@ function isValidAriaAttribute(name) {
 /**
  * Extracts the tag name for the JSXAttribute
  * @param {JSXAttribute} node - JSXAttribute being tested.
- * @returns {String|null} tag name
+ * @returns {string | null} tag name
  */
 function getTagName(node) {
-  if (node && node.parent && node.parent.name && node.parent.name) {
+  if (
+    node
+    && node.parent
+    && node.parent.name
+  ) {
     return node.parent.name.name;
   }
   return null;
@@ -470,7 +492,7 @@ function getTagName(node) {
  * Test wether the tag name for the JSXAttribute is
  * something like <Foo.bar />
  * @param {JSXAttribute} node - JSXAttribute being tested.
- * @returns {Boolean} result
+ * @returns {boolean} result
  */
 function tagNameHasDot(node) {
   return !!(
@@ -482,18 +504,19 @@ function tagNameHasDot(node) {
 
 /**
  * Get the standard name of the attribute.
- * @param {String} name - Name of the attribute.
- * @param {String} context - eslint context
- * @returns {String | undefined} The standard name of the attribute, or undefined if no standard name was found.
+ * @param {string} name - Name of the attribute.
+ * @param {object} context - eslint context
+ * @returns {string | undefined} The standard name of the attribute, or undefined if no standard name was found.
  */
 function getStandardName(name, context) {
   if (has(DOM_ATTRIBUTE_NAMES, name)) {
-    return DOM_ATTRIBUTE_NAMES[name];
+    return DOM_ATTRIBUTE_NAMES[/** @type {keyof DOM_ATTRIBUTE_NAMES} */ (name)];
   }
   if (has(SVGDOM_ATTRIBUTE_NAMES, name)) {
-    return SVGDOM_ATTRIBUTE_NAMES[name];
+    return SVGDOM_ATTRIBUTE_NAMES[/** @type {keyof SVGDOM_ATTRIBUTE_NAMES} */ (name)];
   }
   const names = getDOMPropertyNames(context);
+
   // Let's find a possible attribute match with a case-insensitive search.
   return names.find((element) => element.toLowerCase() === name.toLowerCase());
 }
@@ -509,6 +532,7 @@ const messages = {
   dataLowercaseRequired: 'React does not recognize data-* props with uppercase characters on a DOM element. Found \'{{name}}\', use \'{{lowerCaseName}}\' instead',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -553,7 +577,7 @@ module.exports = {
     return {
       JSXAttribute(node) {
         const ignoreNames = getIgnoreConfig();
-        const actualName = context.getSourceCode().getText(node.name);
+        const actualName = getText(context, node.name);
         if (ignoreNames.indexOf(actualName) >= 0) {
           return;
         }
@@ -589,7 +613,9 @@ module.exports = {
         // Let's dive deeper into tags that are HTML/DOM elements (`<button>`), and not React components (`<Button />`)
 
         // Some attributes are allowed on some tags only
-        const allowedTags = has(ATTRIBUTE_TAGS_MAP, name) ? ATTRIBUTE_TAGS_MAP[name] : null;
+        const allowedTags = has(ATTRIBUTE_TAGS_MAP, name)
+          ? ATTRIBUTE_TAGS_MAP[/** @type {keyof ATTRIBUTE_TAGS_MAP} */ (name)]
+          : null;
         if (tagName && allowedTags) {
           // Scenario 1A: Allowed attribute found where not supposed to, report it
           if (allowedTags.indexOf(tagName) === -1) {
diff --git a/lib/rules/no-unsafe.js b/lib/rules/no-unsafe.js
index 3cfa48968e..ae59b88095 100644
--- a/lib/rules/no-unsafe.js
+++ b/lib/rules/no-unsafe.js
@@ -19,6 +19,7 @@ const messages = {
   unsafeMethod: '{{method}} is unsafe for use in async rendering. Update the component to use {{newMethod}} instead. {{details}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -56,18 +57,15 @@ module.exports = {
     const unsafe = {
       UNSAFE_componentWillMount: {
         newMethod: 'componentDidMount',
-        details:
-          'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
       },
       UNSAFE_componentWillReceiveProps: {
         newMethod: 'getDerivedStateFromProps',
-        details:
-          'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
       },
       UNSAFE_componentWillUpdate: {
         newMethod: 'componentDidUpdate',
-        details:
-          'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
+        details: 'See https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html.',
       },
     };
     if (checkAliases) {
diff --git a/lib/rules/no-unstable-nested-components.js b/lib/rules/no-unstable-nested-components.js
index 9b60e496bf..c330795ff0 100644
--- a/lib/rules/no-unstable-nested-components.js
+++ b/lib/rules/no-unstable-nested-components.js
@@ -5,8 +5,10 @@
 
 'use strict';
 
+const minimatch = require('minimatch');
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const isCreateElement = require('../util/isCreateElement');
 const report = require('../util/report');
 
@@ -23,20 +25,21 @@ const HOOK_REGEXP = /^use[A-Z0-9].*$/;
 
 /**
  * Generate error message with given parent component name
- * @param {String} parentName Name of the parent component, if known
- * @returns {String} Error message with parent component name
+ * @param {string} parentName Name of the parent component, if known
+ * @returns {string} Error message with parent component name
  */
 function generateErrorMessageWithParentName(parentName) {
   return `Do not define components during render. React will see a new component type on every render and destroy the entire subtree’s DOM nodes and state (https://reactjs.org/docs/reconciliation.html#elements-of-different-types). Instead, move this component definition out of the parent component${parentName ? ` “${parentName}” ` : ' '}and pass data as props.`;
 }
 
 /**
- * Check whether given text starts with `render`. Comparison is case-sensitive.
- * @param {String} text Text to validate
- * @returns {Boolean}
+ * Check whether given text matches the pattern passed in.
+ * @param {string} text Text to validate
+ * @param {string} pattern Pattern to match against
+ * @returns {boolean}
  */
-function startsWithRender(text) {
-  return (text || '').startsWith('render');
+function propMatchesRenderPropPattern(text, pattern) {
+  return typeof text === 'string' && minimatch(text, pattern);
 }
 
 /**
@@ -62,20 +65,19 @@ function getClosestMatchingParent(node, context, matcher) {
  * Matcher used to check whether given node is a `createElement` call
  * @param {ASTNode} node The AST node
  * @param {Context} context eslint context
- * @returns {Boolean} True if node is a `createElement` call, false if not
+ * @returns {boolean} True if node is a `createElement` call, false if not
  */
 function isCreateElementMatcher(node, context) {
   return (
-    node
-    && node.type === 'CallExpression'
-    && isCreateElement(node, context)
+    astUtil.isCallExpression(node)
+    && isCreateElement(context, node)
   );
 }
 
 /**
  * Matcher used to check whether given node is a `ObjectExpression`
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is a `ObjectExpression`, false if not
+ * @returns {boolean} True if node is a `ObjectExpression`, false if not
  */
 function isObjectExpressionMatcher(node) {
   return node && node.type === 'ObjectExpression';
@@ -84,7 +86,7 @@ function isObjectExpressionMatcher(node) {
 /**
  * Matcher used to check whether given node is a `JSXExpressionContainer`
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is a `JSXExpressionContainer`, false if not
+ * @returns {boolean} True if node is a `JSXExpressionContainer`, false if not
  */
 function isJSXExpressionContainerMatcher(node) {
   return node && node.type === 'JSXExpressionContainer';
@@ -93,7 +95,7 @@ function isJSXExpressionContainerMatcher(node) {
 /**
  * Matcher used to check whether given node is a `JSXAttribute` of `JSXExpressionContainer`
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is a `JSXAttribute` of `JSXExpressionContainer`, false if not
+ * @returns {boolean} True if node is a `JSXAttribute` of `JSXExpressionContainer`, false if not
  */
 function isJSXAttributeOfExpressionContainerMatcher(node) {
   return (
@@ -107,7 +109,7 @@ function isJSXAttributeOfExpressionContainerMatcher(node) {
 /**
  * Matcher used to check whether given node is an object `Property`
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is a `Property`, false if not
+ * @returns {boolean} True if node is a `Property`, false if not
  */
 function isPropertyOfObjectExpressionMatcher(node) {
   return (
@@ -117,22 +119,13 @@ function isPropertyOfObjectExpressionMatcher(node) {
   );
 }
 
-/**
- * Matcher used to check whether given node is a `CallExpression`
- * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is a `CallExpression`, false if not
- */
-function isCallExpressionMatcher(node) {
-  return node && node.type === 'CallExpression';
-}
-
 /**
  * Check whether given node or its parent is directly inside `map` call
  * ```jsx
  * {items.map(item => <li />)}
  * ```
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if node is directly inside `map` call, false if not
+ * @returns {boolean} True if node is directly inside `map` call, false if not
  */
 function isMapCall(node) {
   return (
@@ -147,7 +140,7 @@ function isMapCall(node) {
  * Check whether given node is `ReturnStatement` of a React hook
  * @param {ASTNode} node The AST node
  * @param {Context} context eslint context
- * @returns {Boolean} True if node is a `ReturnStatement` of a React hook, false if not
+ * @returns {boolean} True if node is a `ReturnStatement` of a React hook, false if not
  */
 function isReturnStatementOfHook(node, context) {
   if (
@@ -158,7 +151,7 @@ function isReturnStatementOfHook(node, context) {
     return false;
   }
 
-  const callExpression = getClosestMatchingParent(node, context, isCallExpressionMatcher);
+  const callExpression = getClosestMatchingParent(node, context, astUtil.isCallExpression);
   return (
     callExpression
     && callExpression.callee
@@ -174,15 +167,16 @@ function isReturnStatementOfHook(node, context) {
  * ```
  * @param {ASTNode} node The AST node
  * @param {Context} context eslint context
- * @returns {Boolean} True if component is declared inside a render prop, false if not
+ * @param {string} propNamePattern a pattern to match render props against
+ * @returns {boolean} True if component is declared inside a render prop, false if not
  */
-function isComponentInRenderProp(node, context) {
+function isComponentInRenderProp(node, context, propNamePattern) {
   if (
     node
     && node.parent
     && node.parent.type === 'Property'
     && node.parent.key
-    && startsWithRender(node.parent.key.name)
+    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
   ) {
     return true;
   }
@@ -211,7 +205,7 @@ function isComponentInRenderProp(node, context) {
     const propName = jsxExpressionContainer.parent.name.name;
 
     // Starts with render, e.g. <Component renderFooter={() => <div />} />
-    if (startsWithRender(propName)) {
+    if (propMatchesRenderPropPattern(propName, propNamePattern)) {
       return true;
     }
 
@@ -231,23 +225,24 @@ function isComponentInRenderProp(node, context) {
  * <Component rows={ [{ render: () => <div /> }] } />
  *  ```
  * @param {ASTNode} node The AST node
- * @returns {Boolean} True if component is declared inside a render property, false if not
+ * @param {string} propNamePattern The pattern to match render props against
+ * @returns {boolean} True if component is declared inside a render property, false if not
  */
-function isDirectValueOfRenderProperty(node) {
+function isDirectValueOfRenderProperty(node, propNamePattern) {
   return (
     node
     && node.parent
     && node.parent.type === 'Property'
     && node.parent.key
     && node.parent.key.type === 'Identifier'
-    && startsWithRender(node.parent.key.name)
+    && propMatchesRenderPropPattern(node.parent.key.name, propNamePattern)
   );
 }
 
 /**
  * Resolve the component name of given node
  * @param {ASTNode} node The AST node of the component
- * @returns {String} Name of the component, if any
+ * @returns {string} Name of the component, if any
  */
 function resolveComponentName(node) {
   const parentName = node.id && node.id.name;
@@ -265,6 +260,7 @@ function resolveComponentName(node) {
 // Rule Definition
 // ------------------------------------------------------------------------------
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -285,6 +281,9 @@ module.exports = {
         allowAsProps: {
           type: 'boolean',
         },
+        propNamePattern: {
+          type: 'string',
+        },
       },
       additionalProperties: false,
     }],
@@ -292,6 +291,7 @@ module.exports = {
 
   create: Components.detect((context, components, utils) => {
     const allowAsProps = context.options.some((option) => option && option.allowAsProps);
+    const propNamePattern = (context.options[0] || {}).propNamePattern || 'render*';
 
     /**
      * Check whether given node is declared inside class component's render block
@@ -302,10 +302,10 @@ module.exports = {
      * ...
      * ```
      * @param {ASTNode} node The AST node being checked
-     * @returns {Boolean} True if node is inside class component's render block, false if not
+     * @returns {boolean} True if node is inside class component's render block, false if not
      */
     function isInsideRenderMethod(node) {
-      const parentComponent = utils.getParentComponent();
+      const parentComponent = utils.getParentComponent(node);
 
       if (!parentComponent || parentComponent.type !== 'ClassDeclaration') {
         return false;
@@ -330,11 +330,11 @@ module.exports = {
      * ...
      * ```
      * @param {ASTNode} node The AST node being checked
-     * @returns {Boolean} True if given node a function component declared inside class component, false if not
+     * @returns {boolean} True if given node a function component declared inside class component, false if not
      */
     function isFunctionComponentInsideClassComponent(node) {
-      const parentComponent = utils.getParentComponent();
-      const parentStatelessComponent = utils.getParentStatelessComponent();
+      const parentComponent = utils.getParentComponent(node);
+      const parentStatelessComponent = utils.getParentStatelessComponent(node);
 
       return (
         parentComponent
@@ -353,7 +353,7 @@ module.exports = {
      * })
      * ```
      * @param {ASTNode} node The AST node
-     * @returns {Boolean} True if node is declare inside `createElement` call's props, false if not
+     * @returns {boolean} True if node is declare inside `createElement` call's props, false if not
      */
     function isComponentInsideCreateElementsProp(node) {
       if (!components.get(node)) {
@@ -376,7 +376,7 @@ module.exports = {
      * { footer: () => <div /> }
      * ```
      * @param {ASTNode} node The AST node being checked
-     * @returns {Boolean} True if node is a component declared inside prop, false if not
+     * @returns {boolean} True if node is a component declared inside prop, false if not
      */
     function isComponentInProp(node) {
       if (isPropertyOfObjectExpressionMatcher(node)) {
@@ -398,7 +398,7 @@ module.exports = {
      * {{ a: () => null }}
      * ```
      * @param {ASTNode} node The AST node being checked
-     * @returns {Boolean} True if node is a stateless component returning non-JSX, false if not
+     * @returns {boolean} True if node is a stateless component returning non-JSX, false if not
      */
     function isStatelessComponentReturningNull(node) {
       const component = utils.getStatelessComponent(node);
@@ -426,7 +426,7 @@ module.exports = {
 
       if (
         // Support allowAsProps option
-        (isDeclaredInsideProps && (allowAsProps || isComponentInRenderProp(node, context)))
+        (isDeclaredInsideProps && (allowAsProps || isComponentInRenderProp(node, context, propNamePattern)))
 
         // Prevent reporting components created inside Array.map calls
         || isMapCall(node)
@@ -436,7 +436,7 @@ module.exports = {
         || isReturnStatementOfHook(node, context)
 
         // Do not mark objects containing render methods
-        || isDirectValueOfRenderProperty(node)
+        || isDirectValueOfRenderProperty(node, propNamePattern)
 
         // Prevent reporting nested class components twice
         || isInsideRenderMethod(node)
diff --git a/lib/rules/no-unused-class-component-methods.js b/lib/rules/no-unused-class-component-methods.js
index 96664d6c52..4356cc2a5e 100644
--- a/lib/rules/no-unused-class-component-methods.js
+++ b/lib/rules/no-unused-class-component-methods.js
@@ -98,6 +98,7 @@ const messages = {
   unusedWithClass: 'Unused method or property "{{name}}" of class "{{className}}"',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -248,7 +249,7 @@ module.exports = {
           node.id.properties
             .filter((prop) => prop.type === 'Property' && isKeyLiteralLike(prop, prop.key))
             .forEach((prop) => {
-              addUsedProperty(prop.key);
+              addUsedProperty('key' in prop ? prop.key : undefined);
             });
         }
       },
diff --git a/lib/rules/no-unused-prop-types.js b/lib/rules/no-unused-prop-types.js
index a3cf352aac..09dcfb5b58 100644
--- a/lib/rules/no-unused-prop-types.js
+++ b/lib/rules/no-unused-prop-types.js
@@ -14,6 +14,15 @@ const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
 
+/**
+ * Checks if the component must be validated
+ * @param {Object} component The component to process
+ * @returns {boolean} True if the component must be validated, false if not.
+ */
+function mustBeValidated(component) {
+  return !!component && !component.ignoreUnusedPropTypesValidation;
+}
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -22,6 +31,7 @@ const messages = {
   unusedPropType: '\'{{name}}\' PropType is defined but prop is never used',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -63,30 +73,18 @@ module.exports = {
 
     /**
      * Checks if the prop is ignored
-     * @param {String} name Name of the prop to check.
-     * @returns {Boolean} True if the prop is ignored, false if not.
+     * @param {string} name Name of the prop to check.
+     * @returns {boolean} True if the prop is ignored, false if not.
      */
     function isIgnored(name) {
       return configuration.ignore.indexOf(name) !== -1;
     }
 
-    /**
-     * Checks if the component must be validated
-     * @param {Object} component The component to process
-     * @returns {Boolean} True if the component must be validated, false if not.
-     */
-    function mustBeValidated(component) {
-      return Boolean(
-        component
-        && !component.ignoreUnusedPropTypesValidation
-      );
-    }
-
     /**
      * Checks if a prop is used
      * @param {ASTNode} node The AST node being checked.
      * @param {Object} prop Declared prop object
-     * @returns {Boolean} True if the prop is used, false if not.
+     * @returns {boolean} True if the prop is used, false if not.
      */
     function isPropUsed(node, prop) {
       const usedPropTypes = node.usedPropTypes || [];
diff --git a/lib/rules/no-unused-state.js b/lib/rules/no-unused-state.js
index 73a0e52163..c1986755c4 100644
--- a/lib/rules/no-unused-state.js
+++ b/lib/rules/no-unused-state.js
@@ -10,9 +10,10 @@
 'use strict';
 
 const docsUrl = require('../util/docsUrl');
-const ast = require('../util/ast');
+const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
 
 // Descend through all wrapping TypeCastExpressions and return the expression
 // that was cast.
@@ -43,7 +44,7 @@ function getName(node) {
 }
 
 function isThisExpression(node) {
-  return ast.unwrapTSAsExpression(uncast(node)).type === 'ThisExpression';
+  return astUtil.unwrapTSAsExpression(uncast(node)).type === 'ThisExpression';
 }
 
 function getInitialClassInfo() {
@@ -64,7 +65,7 @@ function getInitialClassInfo() {
 }
 
 function isSetStateCall(node) {
-  const unwrappedCalleeNode = ast.unwrapTSAsExpression(node.callee);
+  const unwrappedCalleeNode = astUtil.unwrapTSAsExpression(node.callee);
 
   return (
     unwrappedCalleeNode.type === 'MemberExpression'
@@ -77,6 +78,7 @@ const messages = {
   unusedStateField: 'Unused state field: \'{{name}}\'',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -107,7 +109,7 @@ module.exports = {
         'componentDidUpdate',
       ];
 
-      let scope = context.getScope();
+      let scope = getScope(context, node);
       while (scope) {
         const parent = scope.block && scope.block.parent;
         if (
@@ -173,7 +175,7 @@ module.exports = {
     // Records used state fields and new aliases for an ObjectPattern which
     // destructures `this.state`.
     function handleStateDestructuring(node) {
-      for (const prop of node.properties) {
+      node.properties.forEach((prop) => {
         if (prop.type === 'Property') {
           addUsedStateField(prop.key);
         } else if (
@@ -182,13 +184,13 @@ module.exports = {
         ) {
           classInfo.aliases.add(getName(prop.argument));
         }
-      }
+      });
     }
 
     // Used to record used state fields and new aliases for both
     // AssignmentExpressions and VariableDeclarators.
     function handleAssignment(left, right) {
-      const unwrappedRight = ast.unwrapTSAsExpression(right);
+      const unwrappedRight = astUtil.unwrapTSAsExpression(right);
 
       switch (left.type) {
         case 'Identifier':
@@ -200,7 +202,7 @@ module.exports = {
           if (isStateReference(unwrappedRight)) {
             handleStateDestructuring(left);
           } else if (isThisExpression(unwrappedRight) && classInfo.aliases) {
-            for (const prop of left.properties) {
+            left.properties.forEach((prop) => {
               if (prop.type === 'Property' && getName(prop.key) === 'state') {
                 const name = getName(prop.value);
                 if (name) {
@@ -209,7 +211,7 @@ module.exports = {
                   handleStateDestructuring(prop.value);
                 }
               }
-            }
+            });
           }
           break;
         default:
@@ -219,7 +221,7 @@ module.exports = {
 
     function reportUnusedFields() {
       // Report all unused state fields.
-      for (const node of classInfo.stateFields) {
+      classInfo.stateFields.forEach((node) => {
         const name = getName(node.key);
         if (!classInfo.usedStateFields.has(name)) {
           report(context, messages.unusedStateField, 'unusedStateField', {
@@ -229,7 +231,7 @@ module.exports = {
             },
           });
         }
-      }
+      });
     }
 
     function handleES6ComponentEnter(node) {
@@ -291,8 +293,8 @@ module.exports = {
           return;
         }
 
-        const unwrappedNode = ast.unwrapTSAsExpression(node);
-        const unwrappedArgumentNode = ast.unwrapTSAsExpression(unwrappedNode.arguments[0]);
+        const unwrappedNode = astUtil.unwrapTSAsExpression(node);
+        const unwrappedArgumentNode = astUtil.unwrapTSAsExpression(unwrappedNode.arguments[0]);
 
         // If we're looking at a `this.setState({})` invocation, record all the
         // properties as state fields.
@@ -307,7 +309,7 @@ module.exports = {
           && unwrappedNode.arguments.length > 0
           && unwrappedArgumentNode.type === 'ArrowFunctionExpression'
         ) {
-          const unwrappedBodyNode = ast.unwrapTSAsExpression(unwrappedArgumentNode.body);
+          const unwrappedBodyNode = astUtil.unwrapTSAsExpression(unwrappedArgumentNode.body);
 
           if (unwrappedBodyNode.type === 'ObjectExpression') {
             addStateFields(unwrappedBodyNode);
@@ -329,7 +331,7 @@ module.exports = {
         }
         // If we see state being assigned as a class property using an object
         // expression, record all the fields of that object as state fields.
-        const unwrappedValueNode = ast.unwrapTSAsExpression(node.value);
+        const unwrappedValueNode = astUtil.unwrapTSAsExpression(node.value);
 
         const name = getName(node.key);
         if (
@@ -368,7 +370,7 @@ module.exports = {
           return;
         }
 
-        const childScope = context.getScope().childScopes.find((x) => x.block === node.value);
+        const childScope = getScope(context, node).childScopes.find((x) => x.block === node.value);
         if (!childScope) {
           return;
         }
@@ -430,7 +432,11 @@ module.exports = {
           return;
         }
 
-        if (parent.key.name === 'getInitialState') {
+        if (
+          'key' in parent
+          && 'name' in parent.key
+          && parent.key.name === 'getInitialState'
+        ) {
           const body = node.body.body;
           const lastBodyNode = body[body.length - 1];
 
@@ -451,8 +457,8 @@ module.exports = {
           return;
         }
 
-        const unwrappedLeft = ast.unwrapTSAsExpression(node.left);
-        const unwrappedRight = ast.unwrapTSAsExpression(node.right);
+        const unwrappedLeft = astUtil.unwrapTSAsExpression(node.left);
+        const unwrappedRight = astUtil.unwrapTSAsExpression(node.right);
 
         // Check for assignments like `this.state = {}`
         if (
@@ -462,6 +468,7 @@ module.exports = {
           && unwrappedRight.type === 'ObjectExpression'
         ) {
           // Find the nearest function expression containing this assignment.
+          /** @type {import('eslint').Rule.Node} */
           let fn = node;
           while (fn.type !== 'FunctionExpression' && fn.parent) {
             fn = fn.parent;
@@ -492,7 +499,7 @@ module.exports = {
         if (!classInfo) {
           return;
         }
-        if (isStateReference(ast.unwrapTSAsExpression(node.object))) {
+        if (isStateReference(astUtil.unwrapTSAsExpression(node.object))) {
           // If we see this.state[foo] access, give up.
           if (node.computed && node.property.type !== 'Literal') {
             classInfo = null;
@@ -501,7 +508,7 @@ module.exports = {
           // Otherwise, record that we saw this property being accessed.
           addUsedStateField(node.property);
         // If we see a `this.state` access in a CallExpression, give up.
-        } else if (isStateReference(node) && node.parent.type === 'CallExpression') {
+        } else if (isStateReference(node) && astUtil.isCallExpression(node.parent)) {
           classInfo = null;
         }
       },
diff --git a/lib/rules/no-will-update-set-state.js b/lib/rules/no-will-update-set-state.js
index 4f84ee6724..16e6be43b9 100644
--- a/lib/rules/no-will-update-set-state.js
+++ b/lib/rules/no-will-update-set-state.js
@@ -8,6 +8,7 @@
 const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 const testReactVersion = require('../util/version').testReactVersion;
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = makeNoMethodSetStateRule(
   'componentWillUpdate',
   (context) => testReactVersion(context, '>= 16.3.0')
diff --git a/lib/rules/prefer-es6-class.js b/lib/rules/prefer-es6-class.js
index 5ca020ebba..a7c1ff56fc 100644
--- a/lib/rules/prefer-es6-class.js
+++ b/lib/rules/prefer-es6-class.js
@@ -18,6 +18,7 @@ const messages = {
   shouldUseCreateClass: 'Component should use createClass instead of es6 class',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/prefer-exact-props.js b/lib/rules/prefer-exact-props.js
index 037fa29914..5227d9448b 100644
--- a/lib/rules/prefer-exact-props.js
+++ b/lib/rules/prefer-exact-props.js
@@ -6,10 +6,12 @@
 
 const Components = require('../util/Components');
 const docsUrl = require('../util/docsUrl');
+const astUtil = require('../util/ast');
 const propsUtil = require('../util/props');
 const propWrapperUtil = require('../util/propWrapper');
 const variableUtil = require('../util/variable');
 const report = require('../util/report');
+const getText = require('../util/eslint').getText;
 
 // -----------------------------------------------------------------------------
 // Rule Definition
@@ -20,6 +22,7 @@ const messages = {
   flow: 'Component flow props should be set with exact objects.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -35,7 +38,6 @@ module.exports = {
   create: Components.detect((context, components, utils) => {
     const typeAliases = {};
     const exactWrappers = propWrapperUtil.getExactPropWrapperFunctions(context);
-    const sourceCode = context.getSourceCode();
 
     function getPropTypesErrorMessage() {
       const formattedWrappers = propWrapperUtil.formatPropWrapperFunctions(exactWrappers);
@@ -80,9 +82,8 @@ module.exports = {
 
     function isNonExactPropWrapperFunction(node) {
       return (
-        node
-        && node.type === 'CallExpression'
-        && !propWrapperUtil.isExactPropWrapperFunction(context, sourceCode.getText(node.callee))
+        astUtil.isCallExpression(node)
+        && !propWrapperUtil.isExactPropWrapperFunction(context, getText(context, node.callee))
       );
     }
 
@@ -148,7 +149,7 @@ module.exports = {
           reportPropTypesError(node);
         } else if (right.type === 'Identifier') {
           const identifier = right.name;
-          const propsDefinition = variableUtil.findVariableByName(context, identifier);
+          const propsDefinition = variableUtil.findVariableByName(context, node, identifier);
           if (isNonEmptyObjectExpression(propsDefinition)) {
             reportPropTypesError(node);
           } else if (isNonExactPropWrapperFunction(propsDefinition)) {
diff --git a/lib/rules/prefer-read-only-props.js b/lib/rules/prefer-read-only-props.js
index 31d7114643..c00b09f9e4 100644
--- a/lib/rules/prefer-read-only-props.js
+++ b/lib/rules/prefer-read-only-props.js
@@ -47,6 +47,7 @@ const messages = {
   readOnlyProp: 'Prop \'{{name}}\' should be read-only.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
diff --git a/lib/rules/prefer-stateless-function.js b/lib/rules/prefer-stateless-function.js
index 2743ea38aa..46847cb195 100644
--- a/lib/rules/prefer-stateless-function.js
+++ b/lib/rules/prefer-stateless-function.js
@@ -15,6 +15,10 @@ const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getScope = eslintUtil.getScope;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -24,6 +28,7 @@ const messages = {
   componentShouldBePure: 'Component should be written as a pure function',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -65,7 +70,7 @@ module.exports = {
       return (
         body.length === 1
         && body[0].type === 'ExpressionStatement'
-        && body[0].expression.type === 'CallExpression'
+        && astUtil.isCallExpression(body[0].expression)
         && body[0].expression.callee.type === 'Super'
       );
     }
@@ -186,7 +191,7 @@ module.exports = {
     /**
      * Check if a given AST node have any other properties the ones available in stateless components
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if the node has at least one other property, false if not.
+     * @returns {boolean} True if the node has at least one other property, false if not.
      */
     function hasOtherProperties(node) {
       const properties = astUtil.getComponentProperties(node);
@@ -331,7 +336,7 @@ module.exports = {
 
       // Mark `ref` usage
       JSXAttribute(node) {
-        const name = context.getSourceCode().getText(node.name);
+        const name = getText(context, node.name);
         if (name !== 'ref') {
           return;
         }
@@ -341,7 +346,7 @@ module.exports = {
       // Mark `render` that do not return some JSX
       ReturnStatement(node) {
         let blockNode;
-        let scope = context.getScope();
+        let scope = getScope(context, node);
         while (scope) {
           blockNode = scope.block && scope.block.parent;
           if (blockNode && (blockNode.type === 'MethodDefinition' || blockNode.type === 'Property')) {
@@ -349,7 +354,9 @@ module.exports = {
           }
           scope = scope.upper;
         }
-        const isRender = blockNode && blockNode.key && blockNode.key.name === 'render';
+        const isRender = blockNode
+          && blockNode.key
+          && blockNode.key.name === 'render';
         const allowNull = testReactVersion(context, '>= 15.0.0'); // Stateless components can return null since React 15
         const isReturningJSX = utils.isReturningJSX(node, !allowNull);
         const isReturningNull = node.argument && (node.argument.value === null || node.argument.value === false);
diff --git a/lib/rules/prop-types.js b/lib/rules/prop-types.js
index bb317a2467..dabe5b0e7b 100644
--- a/lib/rules/prop-types.js
+++ b/lib/rules/prop-types.js
@@ -22,6 +22,7 @@ const messages = {
   missingPropType: '\'{{name}}\' is missing in props validation',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -63,8 +64,8 @@ module.exports = {
 
     /**
      * Checks if the prop is ignored
-     * @param {String} name Name of the prop to check.
-     * @returns {Boolean} True if the prop is ignored, false if not.
+     * @param {string} name Name of the prop to check.
+     * @returns {boolean} True if the prop is ignored, false if not.
      */
     function isIgnored(name) {
       return ignored.indexOf(name) !== -1;
@@ -73,11 +74,11 @@ module.exports = {
     /**
      * Checks if the component must be validated
      * @param {Object} component The component to process
-     * @returns {Boolean} True if the component must be validated, false if not.
+     * @returns {boolean} True if the component must be validated, false if not.
      */
     function mustBeValidated(component) {
       const isSkippedByConfig = skipUndeclared && typeof component.declaredPropTypes === 'undefined';
-      return Boolean(
+      return !!(
         component
         && component.usedPropTypes
         && !component.ignorePropsValidation
@@ -88,8 +89,8 @@ module.exports = {
     /**
      * Internal: Checks if the prop is declared
      * @param {Object} declaredPropTypes Description of propTypes declared in the current component
-     * @param {String[]} keyList Dot separated name of the prop to check.
-     * @returns {Boolean} True if the prop is declared, false if not.
+     * @param {string[]} keyList Dot separated name of the prop to check.
+     * @returns {boolean} True if the prop is declared, false if not.
      */
     function internalIsDeclaredInComponent(declaredPropTypes, keyList) {
       for (let i = 0, j = keyList.length; i < j; i++) {
@@ -147,14 +148,14 @@ module.exports = {
     /**
      * Checks if the prop is declared
      * @param {ASTNode} node The AST node being checked.
-     * @param {String[]} names List of names of the prop to check.
-     * @returns {Boolean} True if the prop is declared, false if not.
+     * @param {string[]} names List of names of the prop to check.
+     * @returns {boolean} True if the prop is declared, false if not.
      */
     function isDeclaredInComponent(node, names) {
       while (node) {
         const component = components.get(node);
 
-        const isDeclared = component && component.confidence === 2
+        const isDeclared = component && component.confidence >= 2
           && internalIsDeclaredInComponent(component.declaredPropTypes || {}, names);
 
         if (isDeclared) {
@@ -186,6 +187,28 @@ module.exports = {
       });
     }
 
+    /**
+     * @param {Object} component The current component to process
+     * @param {Array} list The all components to process
+     * @returns {boolean} True if the component is nested False if not.
+     */
+    function checkNestedComponent(component, list) {
+      const componentIsMemo = component.node.callee && component.node.callee.name === 'memo';
+      const argumentIsForwardRef = component.node.arguments && component.node.arguments[0].callee && component.node.arguments[0].callee.name === 'forwardRef';
+      if (componentIsMemo && argumentIsForwardRef) {
+        const forwardComponent = list.find(
+          (innerComponent) => (
+            innerComponent.node.range[0] === component.node.arguments[0].range[0]
+            && innerComponent.node.range[0] === component.node.arguments[0].range[0]
+          ));
+
+        const isValidated = mustBeValidated(forwardComponent);
+        const isIgnorePropsValidation = forwardComponent.ignorePropsValidation;
+
+        return isIgnorePropsValidation || isValidated;
+      }
+    }
+
     return {
       'Program:exit'() {
         const list = components.list();
@@ -193,6 +216,7 @@ module.exports = {
         values(list)
           .filter((component) => mustBeValidated(component))
           .forEach((component) => {
+            if (checkNestedComponent(component, values(list))) return;
             reportUndeclaredPropTypes(component);
           });
       },
diff --git a/lib/rules/react-in-jsx-scope.js b/lib/rules/react-in-jsx-scope.js
index e1ee1b6d8c..097e647764 100644
--- a/lib/rules/react-in-jsx-scope.js
+++ b/lib/rules/react-in-jsx-scope.js
@@ -18,6 +18,7 @@ const messages = {
   notInScope: '\'{{name}}\' must be in scope when using JSX',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -36,8 +37,7 @@ module.exports = {
     const pragma = pragmaUtil.getFromContext(context);
 
     function checkIfReactIsInScope(node) {
-      const variables = variableUtil.variablesInScope(context);
-      if (variableUtil.findVariable(variables, pragma)) {
+      if (variableUtil.getVariableFromContext(context, node, pragma)) {
         return;
       }
       report(context, messages.notInScope, 'notInScope', {
diff --git a/lib/rules/require-default-props.js b/lib/rules/require-default-props.js
index c1b83bcff0..c186279cd4 100644
--- a/lib/rules/require-default-props.js
+++ b/lib/rules/require-default-props.js
@@ -24,6 +24,14 @@ const messages = {
   destructureInSignature: 'Must destructure props in the function signature to initialize an optional prop.',
 };
 
+function isPropWithNoDefaulVal(prop) {
+  if (prop.type === 'RestElement' || prop.type === 'ExperimentalRestProperty') {
+    return false;
+  }
+  return prop.value.type !== 'AssignmentPattern';
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -133,15 +141,23 @@ module.exports = {
           });
         }
       } else if (props.type === 'ObjectPattern') {
+        // Filter required props with default value and report error
         props.properties.filter((prop) => {
-          if (prop.type === 'RestElement' || prop.type === 'ExperimentalRestProperty') {
-            return false;
-          }
-          const propType = propTypes[prop.key.name];
-          if (!propType || propType.isRequired) {
-            return false;
-          }
-          return prop.value.type !== 'AssignmentPattern';
+          const propName = prop && prop.key && prop.key.name;
+          const isPropRequired = propTypes[propName] && propTypes[propName].isRequired;
+          return propTypes[propName] && isPropRequired && !isPropWithNoDefaulVal(prop);
+        }).forEach((prop) => {
+          report(context, messages.noDefaultWithRequired, 'noDefaultWithRequired', {
+            node: prop,
+            data: { name: prop.key.name },
+          });
+        });
+
+        // Filter non required props with no default value and report error
+        props.properties.filter((prop) => {
+          const propName = prop && prop.key && prop.key.name;
+          const isPropRequired = propTypes[propName] && propTypes[propName].isRequired;
+          return propTypes[propName] && !isPropRequired && isPropWithNoDefaulVal(prop);
         }).forEach((prop) => {
           report(context, messages.shouldAssignObjectDefault, 'shouldAssignObjectDefault', {
             node: prop,
diff --git a/lib/rules/require-optimization.js b/lib/rules/require-optimization.js
index 05bd071fc6..add2ccf95a 100644
--- a/lib/rules/require-optimization.js
+++ b/lib/rules/require-optimization.js
@@ -11,11 +11,13 @@ const Components = require('../util/Components');
 const componentUtil = require('../util/componentUtil');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
 
 const messages = {
   noShouldComponentUpdate: 'Component is not optimized. Please add a shouldComponentUpdate method.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -48,7 +50,7 @@ module.exports = {
     /**
      * Checks to see if our component is decorated by PureRenderMixin via reactMixin
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if node is decorated with a PureRenderMixin, false if not.
+     * @returns {boolean} True if node is decorated with a PureRenderMixin, false if not.
      */
     function hasPureRenderDecorator(node) {
       if (node.decorators && node.decorators.length) {
@@ -75,7 +77,7 @@ module.exports = {
     /**
      * Checks to see if our component is custom decorated
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if node is decorated name with a custom decorated, false if not.
+     * @returns {boolean} True if node is decorated name with a custom decorated, false if not.
      */
     function hasCustomDecorator(node) {
       const allowLength = allowDecorators.length;
@@ -83,9 +85,10 @@ module.exports = {
       if (allowLength && node.decorators && node.decorators.length) {
         for (let i = 0; i < allowLength; i++) {
           for (let j = 0, l = node.decorators.length; j < l; j++) {
+            const expression = node.decorators[j].expression;
             if (
-              node.decorators[j].expression
-              && node.decorators[j].expression.name === allowDecorators[i]
+              expression
+              && expression.name === allowDecorators[i]
             ) {
               return true;
             }
@@ -99,19 +102,16 @@ module.exports = {
     /**
      * Checks if we are declaring a shouldComponentUpdate method
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if we are declaring a shouldComponentUpdate method, false if not.
+     * @returns {boolean} True if we are declaring a shouldComponentUpdate method, false if not.
      */
     function isSCUDeclared(node) {
-      return Boolean(
-        node
-        && node.name === 'shouldComponentUpdate'
-      );
+      return !!node && node.name === 'shouldComponentUpdate';
     }
 
     /**
      * Checks if we are declaring a PureRenderMixin mixin
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if we are declaring a PureRenderMixin method, false if not.
+     * @returns {boolean} True if we are declaring a PureRenderMixin method, false if not.
      */
     function isPureRenderDeclared(node) {
       let hasPR = false;
@@ -124,8 +124,8 @@ module.exports = {
         }
       }
 
-      return Boolean(
-        node
+      return (
+        !!node
         && node.key.name === 'mixins'
         && hasPR
       );
@@ -153,11 +153,12 @@ module.exports = {
 
     /**
      * Checks if we are declaring function in class
-     * @returns {Boolean} True if we are declaring function in class, false if not.
+     * @param {ASTNode} node
+     * @returns {boolean} True if we are declaring function in class, false if not.
      */
-    function isFunctionInClass() {
+    function isFunctionInClass(node) {
       let blockNode;
-      let scope = context.getScope();
+      let scope = getScope(context, node);
       while (scope) {
         blockNode = scope.block;
         if (blockNode && blockNode.type === 'ClassDeclaration') {
@@ -172,7 +173,7 @@ module.exports = {
     return {
       ArrowFunctionExpression(node) {
         // Skip if the function is declared in the class
-        if (isFunctionInClass()) {
+        if (isFunctionInClass(node)) {
           return;
         }
         // Stateless Functional Components cannot be optimized (yet)
@@ -192,7 +193,7 @@ module.exports = {
 
       FunctionDeclaration(node) {
         // Skip if the function is declared in the class
-        if (isFunctionInClass()) {
+        if (isFunctionInClass(node)) {
           return;
         }
         // Stateless Functional Components cannot be optimized (yet)
@@ -201,7 +202,7 @@ module.exports = {
 
       FunctionExpression(node) {
         // Skip if the function is declared in the class
-        if (isFunctionInClass()) {
+        if (isFunctionInClass(node)) {
           return;
         }
         // Stateless Functional Components cannot be optimized (yet)
diff --git a/lib/rules/require-render-return.js b/lib/rules/require-render-return.js
index cb06206952..c46613e420 100644
--- a/lib/rules/require-render-return.js
+++ b/lib/rules/require-render-return.js
@@ -12,6 +12,7 @@ const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const getAncestors = require('../util/eslint').getAncestors;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -21,6 +22,7 @@ const messages = {
   noRenderReturn: 'Your render method should have a return statement',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -60,7 +62,7 @@ module.exports = {
 
     return {
       ReturnStatement(node) {
-        const ancestors = context.getAncestors(node).reverse();
+        const ancestors = getAncestors(context, node).reverse();
         let depth = 0;
         ancestors.forEach((ancestor) => {
           if (/Function(Expression|Declaration)$/.test(ancestor.type)) {
diff --git a/lib/rules/self-closing-comp.js b/lib/rules/self-closing-comp.js
index 2144db599e..23e168605f 100644
--- a/lib/rules/self-closing-comp.js
+++ b/lib/rules/self-closing-comp.js
@@ -9,16 +9,40 @@ const docsUrl = require('../util/docsUrl');
 const jsxUtil = require('../util/jsx');
 const report = require('../util/report');
 
+const optionDefaults = { component: true, html: true };
+
+function isComponent(node) {
+  return (
+    node.name
+    && (node.name.type === 'JSXIdentifier' || node.name.type === 'JSXMemberExpression')
+    && !jsxUtil.isDOMComponent(node)
+  );
+}
+
+function childrenIsEmpty(node) {
+  return node.parent.children.length === 0;
+}
+
+function childrenIsMultilineSpaces(node) {
+  const childrens = node.parent.children;
+
+  return (
+    childrens.length === 1
+    && (childrens[0].type === 'Literal' || childrens[0].type === 'JSXText')
+    && childrens[0].value.indexOf('\n') !== -1
+    && childrens[0].value.replace(/(?!\xA0)\s/g, '') === ''
+  );
+}
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-const optionDefaults = { component: true, html: true };
-
 const messages = {
   notSelfClosing: 'Empty components are self-closing',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -48,29 +72,6 @@ module.exports = {
   },
 
   create(context) {
-    function isComponent(node) {
-      return (
-        node.name
-        && (node.name.type === 'JSXIdentifier' || node.name.type === 'JSXMemberExpression')
-        && !jsxUtil.isDOMComponent(node)
-      );
-    }
-
-    function childrenIsEmpty(node) {
-      return node.parent.children.length === 0;
-    }
-
-    function childrenIsMultilineSpaces(node) {
-      const childrens = node.parent.children;
-
-      return (
-        childrens.length === 1
-        && (childrens[0].type === 'Literal' || childrens[0].type === 'JSXText')
-        && childrens[0].value.indexOf('\n') !== -1
-        && childrens[0].value.replace(/(?!\xA0)\s/g, '') === ''
-      );
-    }
-
     function isShouldBeSelfClosed(node) {
       const configuration = Object.assign({}, optionDefaults, context.options[0]);
       return (
diff --git a/lib/rules/sort-comp.js b/lib/rules/sort-comp.js
index b56187a298..ee409b780d 100644
--- a/lib/rules/sort-comp.js
+++ b/lib/rules/sort-comp.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 const entries = require('object.entries');
 const values = require('object.values');
 const arrayIncludes = require('array-includes');
@@ -86,6 +86,7 @@ const messages = {
   unsortedProps: '{{propA}} should be placed {{position}} {{propB}}',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -123,6 +124,7 @@ module.exports = {
   },
 
   create: Components.detect((context, components) => {
+    /** @satisfies {Record<string, { node: ASTNode, score: number, closest: { distance: number, ref: { node: null | ASTNode, index: number } } }>} */
     const errors = {};
     const methodsOrder = getMethodsOrder(context.options[0]);
 
@@ -232,7 +234,7 @@ module.exports = {
     /**
      * Get properties name
      * @param {Object} node - Property.
-     * @returns {String} Property name.
+     * @returns {string} Property name.
      */
     function getPropertyName(node) {
       if (node.kind === 'get') {
@@ -286,18 +288,19 @@ module.exports = {
      * Dedupe errors, only keep the ones with the highest score and delete the others
      */
     function dedupeErrors() {
-      for (const i in errors) {
-        if (has(errors, i)) {
-          const index = errors[i].closest.ref.index;
-          if (errors[index]) {
-            if (errors[i].score > errors[index].score) {
-              delete errors[index];
-            } else {
-              delete errors[i];
-            }
+      entries(errors).forEach((entry) => {
+        const i = entry[0];
+        const error = entry[1];
+
+        const index = error.closest.ref.index;
+        if (errors[index]) {
+          if (error.score > errors[index].score) {
+            delete errors[index];
+          } else {
+            delete errors[i];
           }
         }
-      }
+      });
     }
 
     /**
diff --git a/lib/rules/sort-default-props.js b/lib/rules/sort-default-props.js
index aae419ba18..3f3c6ea9b3 100644
--- a/lib/rules/sort-default-props.js
+++ b/lib/rules/sort-default-props.js
@@ -9,6 +9,10 @@
 const variableUtil = require('../util/variable');
 const docsUrl = require('../util/docsUrl');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getFirstTokens = eslintUtil.getFirstTokens;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -18,6 +22,7 @@ const messages = {
   propsNotSorted: 'Default prop types declarations should be sorted alphabetically',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -48,7 +53,7 @@ module.exports = {
     /**
      * Get properties name
      * @param {Object} node - Property.
-     * @returns {String} Property name.
+     * @returns {string} Property name.
      */
     function getPropertyName(node) {
       if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
@@ -60,7 +65,7 @@ module.exports = {
       // (babel-eslint@5 does not expose property name so we have to rely on tokens)
       }
       if (node.type === 'ClassProperty') {
-        const tokens = context.getSourceCode().getFirstTokens(node, 2);
+        const tokens = getFirstTokens(context, node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
       return '';
@@ -69,7 +74,7 @@ module.exports = {
     /**
      * Checks if the Identifier node passed in looks like a defaultProps declaration.
      * @param   {ASTNode}  node The node to check. Must be an Identifier node.
-     * @returns {Boolean}       `true` if the node is a defaultProps declaration, `false` if not
+     * @returns {boolean}       `true` if the node is a defaultProps declaration, `false` if not
      */
     function isDefaultPropsDeclaration(node) {
       const propName = getPropertyName(node);
@@ -77,16 +82,17 @@ module.exports = {
     }
 
     function getKey(node) {
-      return context.getSourceCode().getText(node.key || node.argument);
+      return getText(context, node.key || node.argument);
     }
 
     /**
      * Find a variable by name in the current scope.
+     * @param  {ASTNode} node The node to look for.
      * @param  {string} name Name of the variable to look for.
      * @returns {ASTNode|null} Return null if the variable could not be found, ASTNode otherwise.
      */
-    function findVariableByName(name) {
-      const variable = variableUtil.variablesInScope(context).find((item) => item.name === name);
+    function findVariableByName(node, name) {
+      const variable = variableUtil.getVariableFromContext(context, node, name);
 
       if (!variable || !variable.defs[0] || !variable.defs[0].node) {
         return null;
@@ -106,7 +112,7 @@ module.exports = {
      */
     function checkSorted(declarations) {
       // function fix(fixer) {
-      //   return propTypesSortUtil.fixPropTypesSort(fixer, context, declarations, ignoreCase);
+      //   return propTypesSortUtil.fixPropTypesSort(context, fixer, declarations, ignoreCase);
       // }
 
       declarations.reduce((prev, curr, idx, decls) => {
@@ -142,7 +148,7 @@ module.exports = {
       if (node.type === 'ObjectExpression') {
         checkSorted(node.properties);
       } else if (node.type === 'Identifier') {
-        const propTypesObject = findVariableByName(node.name);
+        const propTypesObject = findVariableByName(node, node.name);
         if (propTypesObject && propTypesObject.properties) {
           checkSorted(propTypesObject.properties);
         }
@@ -167,7 +173,7 @@ module.exports = {
           return;
         }
 
-        checkNode(node.parent.right);
+        checkNode('right' in node.parent && node.parent.right);
       },
     };
   },
diff --git a/lib/rules/sort-prop-types.js b/lib/rules/sort-prop-types.js
index 4a79aa5407..6aaebea184 100644
--- a/lib/rules/sort-prop-types.js
+++ b/lib/rules/sort-prop-types.js
@@ -4,12 +4,17 @@
 
 'use strict';
 
+const astUtil = require('../util/ast');
 const variableUtil = require('../util/variable');
 const propsUtil = require('../util/props');
 const docsUrl = require('../util/docsUrl');
 const propWrapperUtil = require('../util/propWrapper');
 const propTypesSortUtil = require('../util/propTypesSort');
 const report = require('../util/report');
+const eslintUtil = require('../util/eslint');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -23,36 +28,15 @@ const messages = {
 
 function getKey(context, node) {
   if (node.type === 'ObjectTypeProperty') {
-    return context.getSourceCode().getFirstToken(node).value;
+    return getSourceCode(context).getFirstToken(node).value;
   }
   if (node.key && node.key.value) {
     return node.key.value;
   }
-  return context.getSourceCode().getText(node.key || node.argument);
-}
-
-function getValueName(node) {
-  return node.type === 'Property' && node.value.property && node.value.property.name;
-}
-
-function isCallbackPropName(propName) {
-  return /^on[A-Z]/.test(propName);
-}
-
-function isRequiredProp(node) {
-  return getValueName(node) === 'isRequired';
-}
-
-function isShapeProp(node) {
-  return Boolean(
-    node && node.callee && node.callee.property && node.callee.property.name === 'shape'
-  );
-}
-
-function toLowerCase(item) {
-  return String(item).toLowerCase();
+  return getText(context, node.key || node.argument);
 }
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -117,14 +101,15 @@ module.exports = {
 
       function fix(fixer) {
         return propTypesSortUtil.fixPropTypesSort(
-          fixer,
           context,
+          fixer,
           declarations,
           ignoreCase,
           requiredFirst,
           callbacksLast,
           noSortAlphabetically,
-          sortShapeProp
+          sortShapeProp,
+          checkTypes
         );
       }
 
@@ -139,14 +124,14 @@ module.exports = {
 
         let prevPropName = getKey(context, prev);
         let currentPropName = getKey(context, curr);
-        const previousIsRequired = isRequiredProp(prev);
-        const currentIsRequired = isRequiredProp(curr);
-        const previousIsCallback = isCallbackPropName(prevPropName);
-        const currentIsCallback = isCallbackPropName(currentPropName);
+        const previousIsRequired = propTypesSortUtil.isRequiredProp(prev);
+        const currentIsRequired = propTypesSortUtil.isRequiredProp(curr);
+        const previousIsCallback = propTypesSortUtil.isCallbackPropName(prevPropName);
+        const currentIsCallback = propTypesSortUtil.isCallbackPropName(currentPropName);
 
         if (ignoreCase) {
-          prevPropName = toLowerCase(prevPropName);
-          currentPropName = toLowerCase(currentPropName);
+          prevPropName = String(prevPropName).toLowerCase();
+          currentPropName = String(currentPropName).toLowerCase();
         }
 
         if (requiredFirst) {
@@ -201,31 +186,30 @@ module.exports = {
     }
 
     function checkNode(node) {
-      switch (node && node.type) {
-        case 'ObjectExpression':
-          checkSorted(node.properties);
-          break;
-        case 'Identifier': {
-          const propTypesObject = variableUtil.findVariableByName(context, node.name);
-          if (propTypesObject && propTypesObject.properties) {
-            checkSorted(propTypesObject.properties);
-          }
-          break;
+      if (!node) {
+        return;
+      }
+
+      if (node.type === 'ObjectExpression') {
+        checkSorted(node.properties);
+      } else if (node.type === 'Identifier') {
+        const propTypesObject = variableUtil.findVariableByName(context, node, node.name);
+        if (propTypesObject && propTypesObject.properties) {
+          checkSorted(propTypesObject.properties);
         }
-        case 'CallExpression': {
-          const innerNode = node.arguments && node.arguments[0];
-          if (propWrapperUtil.isPropWrapperFunction(context, node.callee.name) && innerNode) {
-            checkNode(innerNode);
-          }
-          break;
+      } else if (astUtil.isCallExpression(node)) {
+        const innerNode = node.arguments && node.arguments[0];
+        if (propWrapperUtil.isPropWrapperFunction(context, node.callee.name) && innerNode) {
+          checkNode(innerNode);
         }
-        default:
-          break;
       }
     }
 
     function handleFunctionComponent(node) {
-      const firstArg = node.params[0].typeAnnotation && node.params[0].typeAnnotation.typeAnnotation;
+      const firstArg = node.params
+        && node.params.length > 0
+        && node.params[0].typeAnnotation
+        && node.params[0].typeAnnotation.typeAnnotation;
       if (firstArg && firstArg.type === 'TSTypeReference') {
         const propType = typeAnnotations.get(firstArg.typeName.name)
           && typeAnnotations.get(firstArg.typeName.name)[0];
@@ -251,7 +235,7 @@ module.exports = {
 
     return Object.assign({
       CallExpression(node) {
-        if (!sortShapeProp || !isShapeProp(node) || !(node.arguments && node.arguments[0])) {
+        if (!sortShapeProp || !propTypesSortUtil.isShapeProp(node) || !(node.arguments && node.arguments[0])) {
           return;
         }
 
@@ -259,7 +243,7 @@ module.exports = {
         if (firstArg.properties) {
           checkSorted(firstArg.properties);
         } else if (firstArg.type === 'Identifier') {
-          const variable = variableUtil.findVariableByName(context, firstArg.name);
+          const variable = variableUtil.findVariableByName(context, node, firstArg.name);
           if (variable && variable.properties) {
             checkSorted(variable.properties);
           }
diff --git a/lib/rules/state-in-constructor.js b/lib/rules/state-in-constructor.js
index e6cc87b283..9dd756b4d2 100644
--- a/lib/rules/state-in-constructor.js
+++ b/lib/rules/state-in-constructor.js
@@ -19,6 +19,7 @@ const messages = {
   stateInitClassProp: 'State initialization should be in a class property',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -43,7 +44,7 @@ module.exports = {
           option === 'always'
           && !node.static
           && node.key.name === 'state'
-          && componentUtil.getParentES6Component(context)
+          && componentUtil.getParentES6Component(context, node)
         ) {
           report(context, messages.stateInitConstructor, 'stateInitConstructor', {
             node,
@@ -54,8 +55,8 @@ module.exports = {
         if (
           option === 'never'
           && componentUtil.isStateMemberExpression(node.left)
-          && astUtil.inConstructor(context)
-          && componentUtil.getParentES6Component(context)
+          && astUtil.inConstructor(context, node)
+          && componentUtil.getParentES6Component(context, node)
         ) {
           report(context, messages.stateInitClassProp, 'stateInitClassProp', {
             node,
diff --git a/lib/rules/static-property-placement.js b/lib/rules/static-property-placement.js
index 59f559121b..ce38a8e42e 100644
--- a/lib/rules/static-property-placement.js
+++ b/lib/rules/static-property-placement.js
@@ -12,6 +12,7 @@ const astUtil = require('../util/ast');
 const componentUtil = require('../util/componentUtil');
 const propsUtil = require('../util/props');
 const report = require('../util/report');
+const getScope = require('../util/eslint').getScope;
 
 // ------------------------------------------------------------------------------
 // Positioning Options
@@ -55,6 +56,7 @@ const messages = {
   declareOutsideClass: '\'{{name}}\' should be declared outside the class body.',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -96,11 +98,12 @@ module.exports = {
 
     /**
       * Checks if we are declaring context in class
-      * @returns {Boolean} True if we are declaring context in class, false if not.
+      * @param {ASTNode} node
+      * @returns {boolean} True if we are declaring context in class, false if not.
      */
-    function isContextInClass() {
+    function isContextInClass(node) {
       let blockNode;
-      let scope = context.getScope();
+      let scope = getScope(context, node);
       while (scope) {
         blockNode = scope.block;
         if (blockNode && blockNode.type === 'ClassDeclaration') {
@@ -148,7 +151,7 @@ module.exports = {
     // ----------------------------------------------------------------------
     return {
       'ClassProperty, PropertyDefinition'(node) {
-        if (!componentUtil.getParentES6Component(context)) {
+        if (!componentUtil.getParentES6Component(context, node)) {
           return;
         }
 
@@ -159,7 +162,7 @@ module.exports = {
         // If definition type is undefined then it must not be a defining expression or if the definition is inside a
         // class body then skip this node.
         const right = node.parent.right;
-        if (!right || right.type === 'undefined' || isContextInClass()) {
+        if (!right || right.type === 'undefined' || isContextInClass(node)) {
           return;
         }
 
@@ -177,7 +180,11 @@ module.exports = {
 
       MethodDefinition(node) {
         // If the function is inside a class and is static getter then check if correctly positioned
-        if (componentUtil.getParentES6Component(context) && node.static && node.kind === 'get') {
+        if (
+          componentUtil.getParentES6Component(context, node)
+          && node.static
+          && node.kind === 'get'
+        ) {
           // Report error if needed
           reportNodeIncorrectlyPositioned(node, STATIC_GETTER);
         }
diff --git a/lib/rules/style-prop-object.js b/lib/rules/style-prop-object.js
index 4d6684a6f1..f2c63e525f 100644
--- a/lib/rules/style-prop-object.js
+++ b/lib/rules/style-prop-object.js
@@ -18,6 +18,7 @@ const messages = {
   stylePropNotObject: 'Style prop value must be an object',
 };
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -61,7 +62,7 @@ module.exports = {
      * @param {object} node A Identifier node
      */
     function checkIdentifiers(node) {
-      const variable = variableUtil.variablesInScope(context).find((item) => item.name === node.name);
+      const variable = variableUtil.getVariableFromContext(context, node, node.name);
 
       if (!variable || !variable.defs[0] || !variable.defs[0].node.init) {
         return;
@@ -77,10 +78,10 @@ module.exports = {
     return {
       CallExpression(node) {
         if (
-          isCreateElement(node, context)
+          isCreateElement(context, node)
           && node.arguments.length > 1
         ) {
-          if (node.arguments[0].name) {
+          if ('name' in node.arguments[0] && node.arguments[0].name) {
             // store name of component
             const componentName = node.arguments[0].name;
 
@@ -91,8 +92,15 @@ module.exports = {
             }
           }
           if (node.arguments[1].type === 'ObjectExpression') {
-            const style = node.arguments[1].properties.find((property) => property.key && property.key.name === 'style' && !property.computed);
-            if (style) {
+            const style = node.arguments[1].properties.find((property) => (
+              'key' in property
+              && property.key
+              && 'name' in property.key
+              && property.key.name === 'style'
+              && !property.computed
+            ));
+
+            if (style && 'value' in style) {
               if (style.value.type === 'Identifier') {
                 checkIdentifiers(style.value);
               } else if (isNonNullaryLiteral(style.value)) {
diff --git a/lib/rules/void-dom-elements-no-children.js b/lib/rules/void-dom-elements-no-children.js
index 721ffae872..f8187b09ea 100644
--- a/lib/rules/void-dom-elements-no-children.js
+++ b/lib/rules/void-dom-elements-no-children.js
@@ -6,7 +6,7 @@
 
 'use strict';
 
-const has = require('object.hasown/polyfill')();
+const has = require('hasown');
 
 const docsUrl = require('../util/docsUrl');
 const isCreateElement = require('../util/isCreateElement');
@@ -47,6 +47,7 @@ function isVoidDOMElement(elementName) {
 
 const noChildrenInVoidEl = 'Void DOM element <{{element}} /> cannot receive children.';
 
+/** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
     docs: {
@@ -108,7 +109,7 @@ module.exports = {
         return;
       }
 
-      if (!isCreateElement(node, context)) {
+      if (!isCreateElement(context, node)) {
         return;
       }
 
@@ -119,7 +120,7 @@ module.exports = {
         return;
       }
 
-      const elementName = args[0].value;
+      const elementName = 'value' in args[0] ? args[0].value : undefined;
 
       if (!isVoidDOMElement(elementName)) {
         // e.g. React.createElement('div');
@@ -144,7 +145,7 @@ module.exports = {
       const props = args[1].properties;
 
       const hasChildrenPropOrDanger = props.some((prop) => {
-        if (!prop.key) {
+        if (!('key' in prop) || !prop.key || !('name' in prop.key)) {
           return false;
         }
 
diff --git a/lib/types.d.ts b/lib/types.d.ts
index e13e204524..30df9c02c1 100644
--- a/lib/types.d.ts
+++ b/lib/types.d.ts
@@ -11,9 +11,10 @@ declare global {
   type JSXAttribute = ASTNode;
   type JSXElement = ASTNode;
   type JSXFragment = ASTNode;
+  type JSXOpeningElement = ASTNode;
   type JSXSpreadAttribute = ASTNode;
 
-  type Context = eslint.Rule.RuleContext
+  type Context = eslint.Rule.RuleContext;
 
   type TypeDeclarationBuilder = (annotation: ASTNode, parentName: string, seen: Set<typeof annotation>) => object;
 
diff --git a/lib/util/Components.js b/lib/util/Components.js
index a31989702f..446fd9022a 100644
--- a/lib/util/Components.js
+++ b/lib/util/Components.js
@@ -21,6 +21,10 @@ const usedPropTypesUtil = require('./usedPropTypes');
 const defaultPropsUtil = require('./defaultProps');
 const isFirstLetterCapitalized = require('./isFirstLetterCapitalized');
 const isDestructuredFromPragmaImport = require('./isDestructuredFromPragmaImport');
+const eslintUtil = require('./eslint');
+
+const getScope = eslintUtil.getScope;
+const getText = eslintUtil.getText;
 
 function getId(node) {
   return node ? `${node.range[0]}:${node.range[1]}` : '';
@@ -66,7 +70,7 @@ class Components {
    * Add a node to the components list, or update it if it's already in the list
    *
    * @param {ASTNode} node The AST node being added.
-   * @param {Number} confidence Confidence in the component detection (0=banned, 1=maybe, 2=yes)
+   * @param {number} confidence Confidence in the component detection (0=banned, 1=maybe, 2=yes)
    * @returns {Object} Added component object
    */
   add(node, confidence) {
@@ -179,7 +183,7 @@ class Components {
    * Return the length of the components list
    * Components for which we are not confident are not counted
    *
-   * @returns {Number} Components list length
+   * @returns {number} Components list length
    */
   length() {
     const list = Lists.get(this);
@@ -282,7 +286,6 @@ function mergeRules(rules) {
 
 function componentRule(rule, context) {
   const pragma = pragmaUtil.getFromContext(context);
-  const sourceCode = context.getSourceCode();
   const components = new Components();
   const wrapperFunctions = getWrapperFunctions(context, pragma);
 
@@ -291,23 +294,29 @@ function componentRule(rule, context) {
     /**
      * Check if variable is destructured from pragma import
      *
+     * @param {ASTNode} node The AST node to check
      * @param {string} variable The variable name to check
-     * @returns {Boolean} True if createElement is destructured from the pragma
+     * @returns {boolean} True if createElement is destructured from the pragma
      */
-    isDestructuredFromPragmaImport(variable) {
-      return isDestructuredFromPragmaImport(variable, context);
+    isDestructuredFromPragmaImport(node, variable) {
+      return isDestructuredFromPragmaImport(context, node, variable);
     },
 
-    isReturningJSX(ASTNode, strict) {
-      return jsxUtil.isReturningJSX(ASTNode, context, strict, true);
+    /**
+     * @param {ASTNode} node
+     * @param {boolean=} strict
+     * @returns {boolean}
+     */
+    isReturningJSX(node, strict) {
+      return jsxUtil.isReturningJSX(context, node, strict, true);
     },
 
-    isReturningJSXOrNull(ASTNode, strict) {
-      return jsxUtil.isReturningJSX(ASTNode, context, strict);
+    isReturningJSXOrNull(node, strict) {
+      return jsxUtil.isReturningJSX(context, node, strict);
     },
 
-    isReturningOnlyNull(ASTNode) {
-      return jsxUtil.isReturningOnlyNull(ASTNode, context);
+    isReturningOnlyNull(node) {
+      return jsxUtil.isReturningOnlyNull(node, context);
     },
 
     getPragmaComponentWrapper(node) {
@@ -398,7 +407,7 @@ function componentRule(rule, context) {
     },
 
     isPragmaComponentWrapper(node) {
-      if (!node || node.type !== 'CallExpression') {
+      if (!astUtil.isCallExpression(node)) {
         return false;
       }
 
@@ -412,7 +421,7 @@ function componentRule(rule, context) {
         return wrapperFunction.property === node.callee.name
           && (!wrapperFunction.object
             // Functions coming from the current pragma need special handling
-            || (wrapperFunction.object === pragma && this.isDestructuredFromPragmaImport(node.callee.name))
+            || (wrapperFunction.object === pragma && this.isDestructuredFromPragmaImport(node, node.callee.name))
           );
       });
     },
@@ -426,14 +435,15 @@ function componentRule(rule, context) {
 
     /**
      * Get the parent component node from the current scope
+     * @param {ASTNode} node
      *
      * @returns {ASTNode} component node, null if we are not in a component
      */
-    getParentComponent() {
+    getParentComponent(node) {
       return (
-        componentUtil.getParentES6Component(context)
-        || componentUtil.getParentES5Component(context)
-        || utils.getParentStatelessComponent()
+        componentUtil.getParentES6Component(context, node)
+        || componentUtil.getParentES5Component(context, node)
+        || utils.getParentStatelessComponent(node)
       );
     },
 
@@ -557,7 +567,13 @@ function componentRule(rule, context) {
         }
 
         // for case abc = { [someobject.somekey]: props => { ... return not-jsx } }
-        if (node.parent && node.parent.key && node.parent.key.type === 'MemberExpression' && !utils.isReturningJSX(node) && !utils.isReturningOnlyNull(node)) {
+        if (
+          node.parent
+          && node.parent.key
+          && node.parent.key.type === 'MemberExpression'
+          && !utils.isReturningJSX(node)
+          && !utils.isReturningOnlyNull(node)
+        ) {
           return undefined;
         }
 
@@ -567,7 +583,10 @@ function componentRule(rule, context) {
             || (!node.id && !node.parent.computed) // case: { f: () => ... }
           )
         ) {
-          if (isFirstLetterCapitalized(node.parent.key.name) && utils.isReturningJSX(node)) {
+          if (
+            isFirstLetterCapitalized(node.parent.key.name)
+            && utils.isReturningJSX(node)
+          ) {
             return node;
           }
           return undefined;
@@ -612,13 +631,13 @@ function componentRule(rule, context) {
     /**
      * Get the parent stateless component node from the current scope
      *
+     * @param {ASTNode} node The AST node being checked
      * @returns {ASTNode} component node, null if we are not in a component
      */
-    getParentStatelessComponent() {
-      let scope = context.getScope();
+    getParentStatelessComponent(node) {
+      let scope = getScope(context, node);
       while (scope) {
-        const node = scope.block;
-        const statelessComponent = utils.getStatelessComponent(node);
+        const statelessComponent = utils.getStatelessComponent(scope.block);
         if (statelessComponent) {
           return statelessComponent;
         }
@@ -631,7 +650,7 @@ function componentRule(rule, context) {
      * Get the related component from a node
      *
      * @param {ASTNode} node The AST node being checked (must be a MemberExpression).
-     * @returns {ASTNode} component node, null if we cannot find the component
+     * @returns {ASTNode | null} component node, null if we cannot find the component
      */
     getRelatedComponent(node) {
       let i;
@@ -641,14 +660,15 @@ function componentRule(rule, context) {
       let componentNode;
       // Get the component path
       const componentPath = [];
-      while (node) {
-        if (node.property && node.property.type === 'Identifier') {
-          componentPath.push(node.property.name);
+      let nodeTemp = node;
+      while (nodeTemp) {
+        if (nodeTemp.property && nodeTemp.property.type === 'Identifier') {
+          componentPath.push(nodeTemp.property.name);
         }
-        if (node.object && node.object.type === 'Identifier') {
-          componentPath.push(node.object.name);
+        if (nodeTemp.object && nodeTemp.object.type === 'Identifier') {
+          componentPath.push(nodeTemp.object.name);
         }
-        node = node.object;
+        nodeTemp = nodeTemp.object;
       }
       componentPath.reverse();
       const componentName = componentPath.slice(0, componentPath.length - 1).join('.');
@@ -658,14 +678,7 @@ function componentRule(rule, context) {
       if (!variableName) {
         return null;
       }
-      let variableInScope;
-      const variables = variableUtil.variablesInScope(context);
-      for (i = 0, j = variables.length; i < j; i++) {
-        if (variables[i].name === variableName) {
-          variableInScope = variables[i];
-          break;
-        }
-      }
+      const variableInScope = variableUtil.getVariableFromContext(context, node, variableName);
       if (!variableInScope) {
         return null;
       }
@@ -676,7 +689,7 @@ function componentRule(rule, context) {
         if (refId.parent && refId.parent.type === 'MemberExpression') {
           refId = refId.parent;
         }
-        if (sourceCode.getText(refId) !== componentName) {
+        if (getText(context, refId) !== componentName) {
           return false;
         }
         if (refId.type === 'MemberExpression') {
@@ -747,10 +760,10 @@ function componentRule(rule, context) {
      *
      * @param {ASTNode} node The AST node being searched. (expects CallExpression)
      * @param {('useCallback'|'useContext'|'useDebugValue'|'useEffect'|'useImperativeHandle'|'useLayoutEffect'|'useMemo'|'useReducer'|'useRef'|'useState')[]} [expectedHookNames] React hook names to which search is limited.
-     * @returns {Boolean} True if the node is a call to a React hook
+     * @returns {boolean} True if the node is a call to a React hook
      */
     isReactHookCall(node, expectedHookNames) {
-      if (node.type !== 'CallExpression') {
+      if (!astUtil.isCallExpression(node)) {
         return false;
       }
 
@@ -776,7 +789,7 @@ function componentRule(rule, context) {
         && node.callee.type === 'Identifier'
         && node.callee.name.match(USE_HOOK_PREFIX_REGEX);
 
-      const scope = (isPotentialReactHookCall || isPotentialHookCall) && context.getScope();
+      const scope = (isPotentialReactHookCall || isPotentialHookCall) && getScope(context, node);
 
       const reactResolvedDefs = isPotentialReactHookCall
         && scope.references
@@ -794,8 +807,14 @@ function componentRule(rule, context) {
         );
 
       const hookResolvedDefs = potentialHookReference && potentialHookReference.resolved.defs;
-      const localHookName = (isPotentialReactHookCall && node.callee.property.name)
-        || (isPotentialHookCall && potentialHookReference && node.callee.name);
+      const localHookName = (
+        isPotentialReactHookCall
+        && node.callee.property.name
+      ) || (
+        isPotentialHookCall
+        && potentialHookReference
+        && node.callee.name
+      );
       const isHookShadowed = isPotentialHookCall
         && hookResolvedDefs
         && hookResolvedDefs.some(
@@ -872,11 +891,11 @@ function componentRule(rule, context) {
         return;
       }
 
-      node = utils.getStatelessComponent(node);
-      if (!node) {
+      const cNode = utils.getStatelessComponent(node);
+      if (!cNode) {
         return;
       }
-      components.add(node, 2);
+      components.add(cNode, 2);
     },
 
     ArrowFunctionExpression(node) {
@@ -888,7 +907,7 @@ function componentRule(rule, context) {
     },
 
     ThisExpression(node) {
-      const component = utils.getParentStatelessComponent();
+      const component = utils.getParentStatelessComponent(node);
       if (!component || !/Function/.test(component.type) || !node.parent.property) {
         return;
       }
diff --git a/lib/util/annotations.js b/lib/util/annotations.js
index 60aaef8cd0..2bc1437ff1 100644
--- a/lib/util/annotations.js
+++ b/lib/util/annotations.js
@@ -6,11 +6,13 @@
 
 'use strict';
 
+const getFirstTokens = require('./eslint').getFirstTokens;
+
 /**
  * Checks if we are declaring a `props` argument with a flow type annotation.
  * @param {ASTNode} node The AST node being checked.
  * @param {Object} context
- * @returns {Boolean} True if the node is a type annotated props declaration, false if not.
+ * @returns {boolean} True if the node is a type annotated props declaration, false if not.
  */
 function isAnnotatedFunctionPropsDeclaration(node, context) {
   if (!node || !node.params || !node.params.length) {
@@ -19,7 +21,7 @@ function isAnnotatedFunctionPropsDeclaration(node, context) {
 
   const typeNode = node.params[0].type === 'AssignmentPattern' ? node.params[0].left : node.params[0];
 
-  const tokens = context.getFirstTokens(typeNode, 2);
+  const tokens = getFirstTokens(context, typeNode, 2);
   const isAnnotated = typeNode.typeAnnotation;
   const isDestructuredProps = typeNode.type === 'ObjectPattern';
   const isProps = tokens[0].value === 'props' || (tokens[1] && tokens[1].value === 'props');
diff --git a/lib/util/ast.js b/lib/util/ast.js
index fd6019a3f2..4cc140254c 100644
--- a/lib/util/ast.js
+++ b/lib/util/ast.js
@@ -5,6 +5,11 @@
 'use strict';
 
 const estraverse = require('estraverse');
+const eslintUtil = require('./eslint');
+
+const getFirstTokens = eslintUtil.getFirstTokens;
+const getScope = eslintUtil.getScope;
+const getSourceCode = eslintUtil.getSourceCode;
 // const pragmaUtil = require('./pragma');
 
 /**
@@ -87,7 +92,7 @@ function traverseReturns(ASTNode, context, onReturn) {
   }
 
   /* TODO: properly warn on React.forwardRefs having typo properties
-  if (nodeType === 'CallExpression') {
+  if (astUtil.isCallExpression(ASTNode)) {
     const callee = ASTNode.callee;
     const pragma = pragmaUtil.getFromContext(context);
     if (
@@ -143,7 +148,11 @@ function traverseReturns(ASTNode, context, onReturn) {
  * @returns {Object} Property name node.
  */
 function getPropertyNameNode(node) {
-  if (node.key || ['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
+  if (
+    node.key
+    || node.type === 'MethodDefinition'
+    || node.type === 'Property'
+  ) {
     return node.key;
   }
   if (node.type === 'MemberExpression') {
@@ -155,7 +164,7 @@ function getPropertyNameNode(node) {
 /**
  * Get properties name
  * @param {Object} node - Property.
- * @returns {String} Property name.
+ * @returns {string} Property name.
  */
 function getPropertyName(node) {
   const nameNode = getPropertyNameNode(node);
@@ -186,7 +195,7 @@ function getComponentProperties(node) {
  * @return {ASTNode} the first node in the line
  */
 function getFirstNodeInLine(context, node) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   let token = node;
   let lines;
   do {
@@ -205,7 +214,7 @@ function getFirstNodeInLine(context, node) {
  * Checks if the node is the first in its line, excluding whitespace.
  * @param {Object} context The node to check
  * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's the first node in its line
+ * @return {boolean} true if it's the first node in its line
  */
 function isNodeFirstInLine(context, node) {
   const token = getFirstNodeInLine(context, node);
@@ -217,7 +226,7 @@ function isNodeFirstInLine(context, node) {
 /**
  * Checks if the node is a function or arrow function expression.
  * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function-like expression
+ * @return {boolean} true if it's a function-like expression
  */
 function isFunctionLikeExpression(node) {
   return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
@@ -226,7 +235,7 @@ function isFunctionLikeExpression(node) {
 /**
  * Checks if the node is a function.
  * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function
+ * @return {boolean} true if it's a function
  */
 function isFunction(node) {
   return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
@@ -235,7 +244,7 @@ function isFunction(node) {
 /**
  * Checks if node is a function declaration or expression or arrow function.
  * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a function-like
+ * @return {boolean} true if it's a function-like
  */
 function isFunctionLike(node) {
   return node.type === 'FunctionDeclaration' || isFunctionLikeExpression(node);
@@ -244,7 +253,7 @@ function isFunctionLike(node) {
 /**
  * Checks if the node is a class.
  * @param {ASTNode} node The node to check
- * @return {Boolean} true if it's a class
+ * @return {boolean} true if it's a class
  */
 function isClass(node) {
   return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
@@ -253,10 +262,11 @@ function isClass(node) {
 /**
  * Check if we are in a class constructor
  * @param {Context} context
+ * @param {ASTNode} node The AST node being checked.
  * @return {boolean}
  */
-function inConstructor(context) {
-  let scope = context.getScope();
+function inConstructor(context, node) {
+  let scope = getScope(context, node);
   while (scope) {
     // @ts-ignore
     if (scope.block && scope.block.parent && scope.block.parent.kind === 'constructor') {
@@ -284,7 +294,7 @@ function stripQuotes(string) {
  */
 function getKeyValue(context, node) {
   if (node.type === 'ObjectTypeProperty') {
-    const tokens = context.getSourceCode().getFirstTokens(node, 2);
+    const tokens = getFirstTokens(context, node, 2);
     return (tokens[0].value === '+' || tokens[0].value === '-'
       ? tokens[1].value
       : stripQuotes(tokens[0].value)
@@ -311,7 +321,7 @@ function getKeyValue(context, node) {
  * @returns {boolean}
  */
 function isParenthesized(context, node) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   const previousToken = sourceCode.getTokenBefore(node);
   const nextToken = sourceCode.getTokenAfter(node);
 
@@ -323,7 +333,7 @@ function isParenthesized(context, node) {
 /**
  * Checks if a node is being assigned a value: props.bar = 'bar'
  * @param {ASTNode} node The AST node being checked.
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function isAssignmentLHS(node) {
   return (
@@ -333,6 +343,19 @@ function isAssignmentLHS(node) {
   );
 }
 
+function isTSAsExpression(node) {
+  return node && node.type === 'TSAsExpression';
+}
+
+/**
+ * Matcher used to check whether given node is a `CallExpression`
+ * @param {ASTNode} node The AST node
+ * @returns {boolean} True if node is a `CallExpression`, false if not
+ */
+function isCallExpression(node) {
+  return node && node.type === 'CallExpression';
+}
+
 /**
  * Extracts the expression node that is wrapped inside a TS type assertion
  *
@@ -340,122 +363,142 @@ function isAssignmentLHS(node) {
  * @returns {ASTNode} - unwrapped expression node
  */
 function unwrapTSAsExpression(node) {
-  if (node && node.type === 'TSAsExpression') return node.expression;
-  return node;
+  return isTSAsExpression(node) ? node.expression : node;
 }
 
 function isTSTypeReference(node) {
   if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeReference';
+
+  return node.type === 'TSTypeReference';
 }
 
 function isTSTypeAnnotation(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeAnnotation';
+  if (!node) { return false; }
+
+  return node.type === 'TSTypeAnnotation';
 }
 
 function isTSTypeLiteral(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeLiteral';
+  if (!node) { return false; }
+
+  return node.type === 'TSTypeLiteral';
 }
 
 function isTSIntersectionType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSIntersectionType';
+  if (!node) { return false; }
+
+  return node.type === 'TSIntersectionType';
 }
 
 function isTSInterfaceHeritage(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSInterfaceHeritage';
+  if (!node) { return false; }
+
+  return node.type === 'TSInterfaceHeritage';
 }
 
 function isTSInterfaceDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
-  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-  }
-  return nodeType === 'TSInterfaceDeclaration';
+  if (!node) { return false; }
+
+  return (node.type === 'ExportNamedDeclaration' && node.declaration
+    ? node.declaration.type
+    : node.type
+  ) === 'TSInterfaceDeclaration';
 }
 
 function isTSTypeDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
-  let nodeKind = node.kind;
-  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-    nodeKind = node.declaration.kind;
-  }
-  return nodeType === 'VariableDeclaration' && nodeKind === 'type';
+  if (!node) { return false; }
+
+  const nodeToCheck = node.type === 'ExportNamedDeclaration' && node.declaration
+    ? node.declaration
+    : node;
+
+  return nodeToCheck.type === 'VariableDeclaration' && nodeToCheck.kind === 'type';
 }
 
 function isTSTypeAliasDeclaration(node) {
-  if (!node) return false;
-  let nodeType = node.type;
+  if (!node) { return false; }
+
   if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-    nodeType = node.declaration.type;
-    return nodeType === 'TSTypeAliasDeclaration' && node.exportKind === 'type';
+    return node.declaration.type === 'TSTypeAliasDeclaration' && node.exportKind === 'type';
   }
-  return nodeType === 'TSTypeAliasDeclaration';
+  return node.type === 'TSTypeAliasDeclaration';
 }
 
 function isTSParenthesizedType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeAliasDeclaration';
+  if (!node) { return false; }
+
+  return node.type === 'TSTypeAliasDeclaration';
 }
 
 function isTSFunctionType(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSFunctionType';
+  if (!node) { return false; }
+
+  return node.type === 'TSFunctionType';
 }
 
 function isTSTypeQuery(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeQuery';
+  if (!node) { return false; }
+
+  return node.type === 'TSTypeQuery';
 }
 
 function isTSTypeParameterInstantiation(node) {
-  if (!node) return false;
-  const nodeType = node.type;
-  return nodeType === 'TSTypeParameterInstantiation';
+  if (!node) { return false; }
+
+  return node.type === 'TSTypeParameterInstantiation';
+}
+
+function isMemberExpression(node) {
+  if (!node) { return false; }
+
+  return node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression';
+}
+
+function isObjectPattern(node) {
+  if (!node) { return false; }
+
+  return node.type === 'ObjectPattern';
+}
+
+function isVariableDeclarator(node) {
+  if (!node) { return false; }
+
+  return node.type === 'VariableDeclarator';
 }
 
 module.exports = {
-  traverse,
   findReturnStatement,
+  getComponentProperties,
   getFirstNodeInLine,
+  getKeyValue,
   getPropertyName,
   getPropertyNameNode,
-  getComponentProperties,
-  getKeyValue,
-  isParenthesized,
+  inConstructor,
   isAssignmentLHS,
+  isCallExpression,
   isClass,
   isFunction,
-  isFunctionLikeExpression,
   isFunctionLike,
-  inConstructor,
+  isFunctionLikeExpression,
+  isMemberExpression,
   isNodeFirstInLine,
-  unwrapTSAsExpression,
-  traverseReturns,
-  isTSTypeReference,
-  isTSTypeAnnotation,
-  isTSTypeLiteral,
-  isTSIntersectionType,
-  isTSInterfaceHeritage,
+  isObjectPattern,
+  isParenthesized,
+  isTSAsExpression,
+  isTSFunctionType,
   isTSInterfaceDeclaration,
-  isTSTypeAliasDeclaration,
+  isTSInterfaceHeritage,
+  isTSIntersectionType,
   isTSParenthesizedType,
-  isTSFunctionType,
-  isTSTypeQuery,
-  isTSTypeParameterInstantiation,
+  isTSTypeAliasDeclaration,
+  isTSTypeAnnotation,
   isTSTypeDeclaration,
+  isTSTypeLiteral,
+  isTSTypeParameterInstantiation,
+  isTSTypeQuery,
+  isTSTypeReference,
+  isVariableDeclarator,
+  traverse,
+  traverseReturns,
+  unwrapTSAsExpression,
 };
diff --git a/lib/util/componentUtil.js b/lib/util/componentUtil.js
index 35d54edcc5..8bd2c720de 100644
--- a/lib/util/componentUtil.js
+++ b/lib/util/componentUtil.js
@@ -2,6 +2,11 @@
 
 const doctrine = require('doctrine');
 const pragmaUtil = require('./pragma');
+const eslintUtil = require('./eslint');
+
+const getScope = eslintUtil.getScope;
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 // eslint-disable-next-line valid-jsdoc
 /**
@@ -57,7 +62,7 @@ function isES5Component(node, context) {
  * @returns {boolean}
  */
 function isExplicitComponent(node, context) {
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   let comment;
   // Sometimes the passed node may not have been parsed yet by eslint, and this function call crashes.
   // Can be removed when eslint sets "parent" property for all nodes on initial AST traversal: https://github.com/eslint/eslint-scope/issues/27
@@ -116,13 +121,14 @@ function isES6Component(node, context) {
 /**
  * Get the parent ES5 component node from the current scope
  * @param {Context} context
+ * @param {ASTNode} node
  * @returns {ASTNode|null}
  */
-function getParentES5Component(context) {
-  let scope = context.getScope();
+function getParentES5Component(context, node) {
+  let scope = getScope(context, node);
   while (scope) {
     // @ts-ignore
-    const node = scope.block && scope.block.parent && scope.block.parent.parent;
+    node = scope.block && scope.block.parent && scope.block.parent.parent;
     if (node && isES5Component(node, context)) {
       return node;
     }
@@ -134,14 +140,15 @@ function getParentES5Component(context) {
 /**
  * Get the parent ES6 component node from the current scope
  * @param {Context} context
+ * @param {ASTNode} node
  * @returns {ASTNode | null}
  */
-function getParentES6Component(context) {
-  let scope = context.getScope();
+function getParentES6Component(context, node) {
+  let scope = getScope(context, node);
   while (scope && scope.type !== 'class') {
     scope = scope.upper;
   }
-  const node = scope && scope.block;
+  node = scope && scope.block;
   if (!node || !isES6Component(node, context)) {
     return null;
   }
@@ -156,9 +163,8 @@ function getParentES6Component(context) {
  */
 function isPureComponent(node, context) {
   const pragma = getPragma(context);
-  const sourceCode = context.getSourceCode();
   if (node.superClass) {
-    return new RegExp(`^(${pragma}\\.)?PureComponent$`).test(sourceCode.getText(node.superClass));
+    return new RegExp(`^(${pragma}\\.)?PureComponent$`).test(getText(context, node.superClass));
   }
   return false;
 }
@@ -168,7 +174,9 @@ function isPureComponent(node, context) {
  * @returns {boolean}
  */
 function isStateMemberExpression(node) {
-  return node.type === 'MemberExpression' && node.object.type === 'ThisExpression' && node.property.name === 'state';
+  return node.type === 'MemberExpression'
+    && node.object.type === 'ThisExpression'
+    && node.property.name === 'state';
 }
 
 module.exports = {
diff --git a/lib/util/defaultProps.js b/lib/util/defaultProps.js
index 44b42454ce..b0e88844d5 100644
--- a/lib/util/defaultProps.js
+++ b/lib/util/defaultProps.js
@@ -10,12 +10,11 @@ const componentUtil = require('./componentUtil');
 const propsUtil = require('./props');
 const variableUtil = require('./variable');
 const propWrapperUtil = require('./propWrapper');
+const getText = require('./eslint').getText;
 
 const QUOTES_REGEX = /^["']|["']$/g;
 
 module.exports = function defaultPropsInstructions(context, components, utils) {
-  const sourceCode = context.getSourceCode();
-
   /**
    * Try to resolve the node passed in to a variable in the current scope. If the node passed in is not
    * an Identifier, then the node is simply returned.
@@ -24,10 +23,10 @@ module.exports = function defaultPropsInstructions(context, components, utils) {
    */
   function resolveNodeValue(node) {
     if (node.type === 'Identifier') {
-      return variableUtil.findVariableByName(context, node.name);
+      return variableUtil.findVariableByName(context, node, node.name);
     }
     if (
-      node.type === 'CallExpression'
+      astUtil.isCallExpression(node)
       && propWrapperUtil.isPropWrapperFunction(context, node.callee.name)
       && node.arguments && node.arguments[0]
     ) {
@@ -51,7 +50,7 @@ module.exports = function defaultPropsInstructions(context, components, utils) {
     }
 
     return objectExpression.properties.map((defaultProp) => ({
-      name: sourceCode.getText(defaultProp.key).replace(QUOTES_REGEX, ''),
+      name: getText(context, defaultProp.key).replace(QUOTES_REGEX, ''),
       node: defaultProp,
     }));
   }
@@ -172,7 +171,7 @@ module.exports = function defaultPropsInstructions(context, components, utils) {
       }
 
       // find component this propTypes/defaultProps belongs to
-      const component = components.get(componentUtil.getParentES6Component(context));
+      const component = components.get(componentUtil.getParentES6Component(context, node));
       if (!component) {
         return;
       }
@@ -215,7 +214,7 @@ module.exports = function defaultPropsInstructions(context, components, utils) {
       }
 
       // find component this propTypes/defaultProps belongs to
-      const component = components.get(componentUtil.getParentES6Component(context));
+      const component = components.get(componentUtil.getParentES6Component(context, node));
       if (!component) {
         return;
       }
diff --git a/lib/util/error.js b/lib/util/error.js
index bbfc3d6f09..cca6e6c13f 100644
--- a/lib/util/error.js
+++ b/lib/util/error.js
@@ -2,7 +2,7 @@
 
 /**
  * Logs out a message if there is no format option set.
- * @param {String} message - Message to log.
+ * @param {string} message - Message to log.
  */
 function error(message) {
   if (!/=-(f|-format)=/.test(process.argv.join('='))) {
diff --git a/lib/util/eslint.js b/lib/util/eslint.js
new file mode 100644
index 0000000000..79a0537f3b
--- /dev/null
+++ b/lib/util/eslint.js
@@ -0,0 +1,46 @@
+'use strict';
+
+function getSourceCode(context) {
+  return context.getSourceCode ? context.getSourceCode() : context.sourceCode;
+}
+
+function getAncestors(context, node) {
+  const sourceCode = getSourceCode(context);
+  return sourceCode.getAncestors ? sourceCode.getAncestors(node) : context.getAncestors();
+}
+
+function getScope(context, node) {
+  const sourceCode = getSourceCode(context);
+  if (sourceCode.getScope) {
+    return sourceCode.getScope(node);
+  }
+
+  return context.getScope();
+}
+
+function markVariableAsUsed(name, node, context) {
+  const sourceCode = getSourceCode(context);
+  return sourceCode.markVariableAsUsed
+    ? sourceCode.markVariableAsUsed(name, node)
+    : context.markVariableAsUsed(name);
+}
+
+function getFirstTokens(context, node, count) {
+  const sourceCode = getSourceCode(context);
+  return sourceCode.getFirstTokens ? sourceCode.getFirstTokens(node, count) : context.getFirstTokens(node, count);
+}
+
+function getText(context) {
+  const sourceCode = getSourceCode(context);
+  const args = Array.prototype.slice.call(arguments, 1);
+  return sourceCode.getText ? sourceCode.getText.apply(sourceCode, args) : context.getSource.apply(context, args);
+}
+
+module.exports = {
+  getAncestors,
+  getFirstTokens,
+  getScope,
+  getSourceCode,
+  getText,
+  markVariableAsUsed,
+};
diff --git a/lib/util/isCreateContext.js b/lib/util/isCreateContext.js
index d5fdfe4551..fd73ecc31d 100644
--- a/lib/util/isCreateContext.js
+++ b/lib/util/isCreateContext.js
@@ -1,52 +1,53 @@
 'use strict';
 
+const astUtil = require('./ast');
+
 /**
  * Checks if the node is a React.createContext call
  * @param {ASTNode} node - The AST node being checked.
- * @returns {Boolean} - True if node is a React.createContext call, false if not.
+ * @returns {boolean} - True if node is a React.createContext call, false if not.
  */
 module.exports = function isCreateContext(node) {
   if (
     node.init
-    && node.init.type === 'CallExpression'
     && node.init.callee
-    && node.init.callee.name === 'createContext'
   ) {
-    return true;
-  }
+    if (
+      astUtil.isCallExpression(node.init)
+      && node.init.callee.name === 'createContext'
+    ) {
+      return true;
+    }
 
-  if (
-    node.init
-    && node.init.callee
-    && node.init.callee.type === 'MemberExpression'
-    && node.init.callee.property
-    && node.init.callee.property.name === 'createContext'
-  ) {
-    return true;
+    if (
+      node.init.callee.type === 'MemberExpression'
+      && node.init.callee.property
+      && node.init.callee.property.name === 'createContext'
+    ) {
+      return true;
+    }
   }
 
   if (
     node.expression
     && node.expression.type === 'AssignmentExpression'
     && node.expression.operator === '='
-    && node.expression.right.type === 'CallExpression'
+    && astUtil.isCallExpression(node.expression.right)
     && node.expression.right.callee
-    && node.expression.right.callee.name === 'createContext'
   ) {
-    return true;
-  }
+    const right = node.expression.right;
 
-  if (
-    node.expression
-    && node.expression.type === 'AssignmentExpression'
-    && node.expression.operator === '='
-    && node.expression.right.type === 'CallExpression'
-    && node.expression.right.callee
-    && node.expression.right.callee.type === 'MemberExpression'
-    && node.expression.right.callee.property
-    && node.expression.right.callee.property.name === 'createContext'
-  ) {
-    return true;
+    if (right.callee.name === 'createContext') {
+      return true;
+    }
+
+    if (
+      right.callee.type === 'MemberExpression'
+      && right.callee.property
+      && right.callee.property.name === 'createContext'
+    ) {
+      return true;
+    }
   }
 
   return false;
diff --git a/lib/util/isCreateElement.js b/lib/util/isCreateElement.js
index c28dc563fb..be93cec5f7 100644
--- a/lib/util/isCreateElement.js
+++ b/lib/util/isCreateElement.js
@@ -5,14 +5,17 @@ const isDestructuredFromPragmaImport = require('./isDestructuredFromPragmaImport
 
 /**
  * Checks if the node is a createElement call
- * @param {ASTNode} node - The AST node being checked.
  * @param {Context} context - The AST node being checked.
- * @returns {Boolean} - True if node is a createElement call object literal, False if not.
+ * @param {ASTNode} node - The AST node being checked.
+ * @returns {boolean} - True if node is a createElement call object literal, False if not.
 */
-module.exports = function isCreateElement(node, context) {
+module.exports = function isCreateElement(context, node) {
+  if (!node.callee) {
+    return false;
+  }
+
   if (
-    node.callee
-    && node.callee.type === 'MemberExpression'
+    node.callee.type === 'MemberExpression'
     && node.callee.property.name === 'createElement'
     && node.callee.object
     && node.callee.object.name === pragmaUtil.getFromContext(context)
@@ -21,10 +24,8 @@ module.exports = function isCreateElement(node, context) {
   }
 
   if (
-    node
-    && node.callee
-    && node.callee.name === 'createElement'
-    && isDestructuredFromPragmaImport('createElement', context)
+    node.callee.name === 'createElement'
+    && isDestructuredFromPragmaImport(context, node, 'createElement')
   ) {
     return true;
   }
diff --git a/lib/util/isDestructuredFromPragmaImport.js b/lib/util/isDestructuredFromPragmaImport.js
index 6f8deb08bc..122fb545af 100644
--- a/lib/util/isDestructuredFromPragmaImport.js
+++ b/lib/util/isDestructuredFromPragmaImport.js
@@ -1,19 +1,20 @@
 'use strict';
 
+const astUtil = require('./ast');
 const pragmaUtil = require('./pragma');
 const variableUtil = require('./variable');
 
 /**
  * Check if variable is destructured from pragma import
  *
- * @param {string} variable The variable name to check
  * @param {Context} context eslint context
- * @returns {Boolean} True if createElement is destructured from the pragma
+ * @param {ASTNode} node The AST node to check
+ * @param {string} variable The variable name to check
+ * @returns {boolean} True if createElement is destructured from the pragma
  */
-module.exports = function isDestructuredFromPragmaImport(variable, context) {
+module.exports = function isDestructuredFromPragmaImport(context, node, variable) {
   const pragma = pragmaUtil.getFromContext(context);
-  const variables = variableUtil.variablesInScope(context);
-  const variableInScope = variableUtil.getVariable(variables, variable);
+  const variableInScope = variableUtil.getVariableFromContext(context, node, variable);
   if (variableInScope) {
     const latestDef = variableUtil.getLatestVariableDefinition(variableInScope);
     if (latestDef) {
@@ -22,15 +23,15 @@ module.exports = function isDestructuredFromPragmaImport(variable, context) {
         // check for: 'variable = pragma.variable'
         if (
           latestDef.node.init.type === 'MemberExpression'
-              && latestDef.node.init.object.type === 'Identifier'
-              && latestDef.node.init.object.name === pragma
+          && latestDef.node.init.object.type === 'Identifier'
+          && latestDef.node.init.object.name === pragma
         ) {
           return true;
         }
         // check for: '{variable} = pragma'
         if (
           latestDef.node.init.type === 'Identifier'
-              && latestDef.node.init.name === pragma
+          && latestDef.node.init.name === pragma
         ) {
           return true;
         }
@@ -39,14 +40,14 @@ module.exports = function isDestructuredFromPragmaImport(variable, context) {
         let requireExpression = null;
 
         // get "require('react')" from: "{variable} = require('react')"
-        if (latestDef.node.init.type === 'CallExpression') {
+        if (astUtil.isCallExpression(latestDef.node.init)) {
           requireExpression = latestDef.node.init;
         }
         // get "require('react')" from: "variable = require('react').variable"
         if (
           !requireExpression
-              && latestDef.node.init.type === 'MemberExpression'
-              && latestDef.node.init.object.type === 'CallExpression'
+          && latestDef.node.init.type === 'MemberExpression'
+          && astUtil.isCallExpression(latestDef.node.init.object)
         ) {
           requireExpression = latestDef.node.init.object;
         }
@@ -54,10 +55,10 @@ module.exports = function isDestructuredFromPragmaImport(variable, context) {
         // check proper require.
         if (
           requireExpression
-              && requireExpression.callee
-              && requireExpression.callee.name === 'require'
-              && requireExpression.arguments[0]
-              && requireExpression.arguments[0].value === pragma.toLocaleLowerCase()
+          && requireExpression.callee
+          && requireExpression.callee.name === 'require'
+          && requireExpression.arguments[0]
+          && requireExpression.arguments[0].value === pragma.toLocaleLowerCase()
         ) {
           return true;
         }
@@ -68,8 +69,8 @@ module.exports = function isDestructuredFromPragmaImport(variable, context) {
       // latest definition is an import declaration: import {<variable>} from 'react'
       if (
         latestDef.parent
-            && latestDef.parent.type === 'ImportDeclaration'
-            && latestDef.parent.source.value === pragma.toLocaleLowerCase()
+        && latestDef.parent.type === 'ImportDeclaration'
+        && latestDef.parent.source.value === pragma.toLocaleLowerCase()
       ) {
         return true;
       }
diff --git a/lib/util/isFirstLetterCapitalized.js b/lib/util/isFirstLetterCapitalized.js
index bc55a1970b..3d6252168f 100644
--- a/lib/util/isFirstLetterCapitalized.js
+++ b/lib/util/isFirstLetterCapitalized.js
@@ -2,15 +2,13 @@
 
 /**
  * Check if the first letter of a string is capitalized.
- * @param {String} word String to check
- * @returns {Boolean} True if first letter is capitalized.
+ * @param {string} word String to check
+ * @returns {boolean} True if first letter is capitalized.
  */
-function isFirstLetterCapitalized(word) {
+module.exports = function isFirstLetterCapitalized(word) {
   if (!word) {
     return false;
   }
   const firstLetter = word.replace(/^_+/, '').charAt(0);
   return firstLetter.toUpperCase() === firstLetter;
-}
-
-module.exports = isFirstLetterCapitalized;
+};
diff --git a/lib/util/jsx.js b/lib/util/jsx.js
index 55073bfe1e..db3413745a 100644
--- a/lib/util/jsx.js
+++ b/lib/util/jsx.js
@@ -76,7 +76,7 @@ function isJSXAttributeKey(node) {
 
 /**
  * Check if value has only whitespaces
- * @param {string} value
+ * @param {unknown} value
  * @returns {boolean}
  */
 function isWhiteSpaces(value) {
@@ -86,13 +86,13 @@ function isWhiteSpaces(value) {
 /**
  * Check if the node is returning JSX or null
  *
- * @param {ASTNode} ASTnode The AST node being checked
  * @param {Context} context The context of `ASTNode`.
- * @param {Boolean} [strict] If true, in a ternary condition the node must return JSX in both cases
- * @param {Boolean} [ignoreNull] If true, null return values will be ignored
- * @returns {Boolean} True if the node is returning JSX or null, false if not
+ * @param {ASTNode} ASTnode The AST node being checked
+ * @param {boolean} [strict] If true, in a ternary condition the node must return JSX in both cases
+ * @param {boolean} [ignoreNull] If true, null return values will be ignored
+ * @returns {boolean} True if the node is returning JSX or null, false if not
  */
-function isReturningJSX(ASTnode, context, strict, ignoreNull) {
+function isReturningJSX(context, ASTnode, strict, ignoreNull) {
   const isJSXValue = (node) => {
     if (!node) {
       return false;
@@ -114,14 +114,14 @@ function isReturningJSX(ASTnode, context, strict, ignoreNull) {
       case 'JSXFragment':
         return true;
       case 'CallExpression':
-        return isCreateElement(node, context);
+        return isCreateElement(context, node);
       case 'Literal':
         if (!ignoreNull && node.value === null) {
           return true;
         }
         return false;
       case 'Identifier': {
-        const variable = variableUtil.findVariableByName(context, node.name);
+        const variable = variableUtil.findVariableByName(context, node, node.name);
         return isJSX(variable);
       }
       default:
@@ -145,7 +145,7 @@ function isReturningJSX(ASTnode, context, strict, ignoreNull) {
  *
  * @param {ASTNode} ASTnode The AST node being checked
  * @param {Context} context The context of `ASTNode`.
- * @returns {Boolean} True if the node is returning only null values
+ * @returns {boolean} True if the node is returning only null values
  */
 function isReturningOnlyNull(ASTnode, context) {
   let found = false;
diff --git a/lib/util/log.js b/lib/util/log.js
index 9782b21990..55271e15f2 100644
--- a/lib/util/log.js
+++ b/lib/util/log.js
@@ -2,7 +2,7 @@
 
 /**
  * Logs out a message if there is no format option set.
- * @param {String} message - Message to log.
+ * @param {string} message - Message to log.
  */
 function log(message) {
   if (!/=-(f|-format)=/.test(process.argv.join('='))) {
diff --git a/lib/util/makeNoMethodSetStateRule.js b/lib/util/makeNoMethodSetStateRule.js
index 1225092802..b6c55d5cf6 100644
--- a/lib/util/makeNoMethodSetStateRule.js
+++ b/lib/util/makeNoMethodSetStateRule.js
@@ -9,6 +9,7 @@ const findLast = require('array.prototype.findlast');
 
 const docsUrl = require('./docsUrl');
 const report = require('./report');
+const getAncestors = require('./eslint').getAncestors;
 const testReactVersion = require('./version').testReactVersion;
 
 // ------------------------------------------------------------------------------
@@ -43,6 +44,12 @@ function shouldBeNoop(context, methodName) {
     && !testReactVersion(context, '999.999.999'); // for when the version is not specified
 }
 
+// eslint-disable-next-line valid-jsdoc
+/**
+ * @param {string} methodName
+ * @param {(context: import('eslint').Rule.RuleContext) => boolean} [shouldCheckUnsafeCb]
+ * @returns {import('eslint').Rule.RuleModule}
+ */
 module.exports = function makeNoMethodSetStateRule(methodName, shouldCheckUnsafeCb) {
   return {
     meta: {
@@ -89,11 +96,12 @@ module.exports = function makeNoMethodSetStateRule(methodName, shouldCheckUnsafe
           if (
             callee.type !== 'MemberExpression'
             || callee.object.type !== 'ThisExpression'
+            || !('name' in callee.property)
             || callee.property.name !== 'setState'
           ) {
             return;
           }
-          const ancestors = context.getAncestors(callee);
+          const ancestors = getAncestors(context, node);
           let depth = 0;
           findLast(ancestors, (ancestor) => {
           // ancestors.some((ancestor) => {
diff --git a/lib/util/pragma.js b/lib/util/pragma.js
index 2bde47fb37..be96c189b6 100644
--- a/lib/util/pragma.js
+++ b/lib/util/pragma.js
@@ -5,6 +5,8 @@
 
 'use strict';
 
+const getSourceCode = require('./eslint').getSourceCode;
+
 const JSX_ANNOTATION_REGEX = /@jsx\s+([^\s]+)/;
 // Does not check for reserved keywords or unicode characters
 const JS_IDENTIFIER_REGEX = /^[_$a-zA-Z][_$a-zA-Z0-9]*$/;
@@ -48,7 +50,7 @@ function getFragmentFromContext(context) {
 function getFromContext(context) {
   let pragma = 'React';
 
-  const sourceCode = context.getSourceCode();
+  const sourceCode = getSourceCode(context);
   const pragmaNode = sourceCode.getAllComments().find((node) => JSX_ANNOTATION_REGEX.test(node.value));
 
   if (pragmaNode) {
@@ -60,7 +62,8 @@ function getFromContext(context) {
   }
 
   if (!JS_IDENTIFIER_REGEX.test(pragma)) {
-    throw new Error(`React pragma ${pragma} is not a valid identifier`);
+    console.warn(`React pragma ${pragma} is not a valid identifier`);
+    return 'React';
   }
   return pragma;
 }
diff --git a/lib/util/propTypes.js b/lib/util/propTypes.js
index a189f871ca..7cec5abbdd 100644
--- a/lib/util/propTypes.js
+++ b/lib/util/propTypes.js
@@ -13,11 +13,17 @@ const testFlowVersion = require('./version').testFlowVersion;
 const propWrapperUtil = require('./propWrapper');
 const astUtil = require('./ast');
 const isFirstLetterCapitalized = require('./isFirstLetterCapitalized');
+const eslintUtil = require('./eslint');
+
+const getFirstTokens = eslintUtil.getFirstTokens;
+const getScope = eslintUtil.getScope;
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 /**
  * Check if node is function type.
  * @param {ASTNode} node
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function isFunctionType(node) {
   if (!node) return false;
@@ -31,11 +37,12 @@ function isFunctionType(node) {
  * Checks if we are declaring a props as a generic type in a flow-annotated class.
  *
  * @param {ASTNode} node  the AST node being checked.
- * @returns {Boolean} True if the node is a class with generic prop types, false if not.
+ * @returns {boolean} True if the node is a class with generic prop types, false if not.
  */
 function isSuperTypeParameterPropsDeclaration(node) {
   if (node && (node.type === 'ClassDeclaration' || node.type === 'ClassExpression')) {
-    if (node.superTypeParameters && node.superTypeParameters.params.length > 0) {
+    const parameters = propsUtil.getSuperTypeArguments(node);
+    if (parameters && parameters.params.length > 0) {
       return true;
     }
   }
@@ -70,8 +77,8 @@ function iterateProperties(context, properties, fn, handleSpreadFn) {
 /**
  * Checks if a node is inside a class body.
  *
- * @param {ASTNode} node  the AST node being checked.
- * @returns {Boolean} True if the node has a ClassBody ancestor, false if not.
+ * @param {ASTNode} node the AST node being checked.
+ * @returns {boolean} True if the node has a ClassBody ancestor, false if not.
  */
 function isInsideClassBody(node) {
   let parent = node.parent;
@@ -100,8 +107,11 @@ module.exports = function propTypesInstructions(context, components, utils) {
   const defaults = { customValidators: [] };
   const configuration = Object.assign({}, defaults, context.options[0] || {});
   const customValidators = configuration.customValidators;
-  const allowedGenericTypes = new Set(['forwardRef', 'ForwardRefRenderFunction', 'VFC', 'VoidFunctionComponent', 'PropsWithChildren', 'SFC', 'StatelessComponent', 'FunctionComponent', 'FC']);
+  const allowedGenericTypes = new Set(['ComponentProps', 'ComponentPropsWithRef', 'ComponentPropsWithoutRef', 'forwardRef', 'ForwardRefRenderFunction', 'VFC', 'VoidFunctionComponent', 'PropsWithChildren', 'SFC', 'StatelessComponent', 'FunctionComponent', 'FC']);
   const genericTypeParamIndexWherePropsArePresent = {
+    ComponentProps: 0,
+    ComponentPropsWithRef: 0,
+    ComponentPropsWithoutRef: 0,
     ForwardRefRenderFunction: 1,
     forwardRef: 1,
     VoidFunctionComponent: 0,
@@ -146,8 +156,8 @@ module.exports = function propTypesInstructions(context, components, utils) {
 
   /**
    * Checks if prop should be validated by plugin-react-proptypes
-   * @param {String} validator Name of validator to check.
-   * @returns {Boolean} True if validator should be checked by custom validator.
+   * @param {string} validator Name of validator to check.
+   * @returns {boolean} True if validator should be checked by custom validator.
    */
   function hasCustomValidator(validator) {
     return customValidators.indexOf(validator) !== -1;
@@ -166,7 +176,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
     ObjectTypeAnnotation(annotation, parentName, seen) {
       let containsUnresolvedObjectTypeSpread = false;
       let containsSpread = false;
-      const containsIndexers = Boolean(annotation.indexers && annotation.indexers.length);
+      const containsIndexers = !!annotation.indexers && annotation.indexers.length > 0;
       const shapeTypeDefinition = {
         type: 'shape',
         children: {},
@@ -261,7 +271,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
    * Creates the representation of the React props type annotation for the component.
    * The representation is used to verify nested used properties.
    * @param {ASTNode} annotation Type annotation for the props class property.
-   * @param {String} parentName
+   * @param {string} parentName
    * @param {Set<ASTNode>} [seen]
    * @return {Object} The representation of the declaration, empty object means
    *    the property is declared without the need for further analysis.
@@ -290,7 +300,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
    * Modifies the declaredProperties object
    * @param {ASTNode} propTypes
    * @param {Object} declaredPropTypes
-   * @returns {Boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
+   * @returns {boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
    */
   function declarePropTypesForObjectTypeAnnotation(propTypes, declaredPropTypes) {
     let ignorePropsValidation = false;
@@ -328,7 +338,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
    * Modifies the declaredPropTypes object
    * @param {ASTNode} propTypes
    * @param {Object} declaredPropTypes
-   * @returns {Boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
+   * @returns {boolean} True if propTypes should be ignored (e.g. when a type can't be resolved, when it is imported)
    */
   function declarePropTypesForIntersectionTypeAnnotation(propTypes, declaredPropTypes) {
     return propTypes.types.some((annotation) => {
@@ -361,14 +371,16 @@ module.exports = function propTypesInstructions(context, components, utils) {
   /**
    * Resolve node of type Identifier when building declaration types.
    * @param {ASTNode} node
+   * @param {ASTNode} rootNode
    * @param {Function} callback called with the resolved value only if resolved.
    */
-  function resolveValueForIdentifierNode(node, callback) {
+  function resolveValueForIdentifierNode(node, rootNode, callback) {
     if (
-      node
+      rootNode
+      && node
       && node.type === 'Identifier'
     ) {
-      const scope = context.getScope();
+      const scope = getScope(context, rootNode);
       const identVariable = scope.variableScope.variables.find(
         (variable) => variable.name === node.name
       );
@@ -384,10 +396,11 @@ module.exports = function propTypesInstructions(context, components, utils) {
    * The representation is used to verify nested used properties.
    * @param {ASTNode} value Node of the PropTypes for the desired property
    * @param {string} parentName
+   * @param {ASTNode} rootNode
    * @return {Object} The representation of the declaration, empty object means
    *    the property is declared without the need for further analysis.
    */
-  function buildReactDeclarationTypes(value, parentName) {
+  function buildReactDeclarationTypes(value, parentName, rootNode) {
     if (
       value
       && value.callee
@@ -409,7 +422,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
     // propTypes = {
     //   example: variableType
     // }
-    resolveValueForIdentifierNode(value, (newValue) => {
+    resolveValueForIdentifierNode(value, rootNode, (newValue) => {
       identNodeResolved = true;
       value = newValue;
     });
@@ -418,7 +431,6 @@ module.exports = function propTypesInstructions(context, components, utils) {
       value
       && value.type === 'MemberExpression'
       && value.property
-      && value.property.name
       && value.property.name === 'isRequired'
     ) {
       value = value.object;
@@ -431,15 +443,14 @@ module.exports = function propTypesInstructions(context, components, utils) {
     //   example: variableType.isRequired
     // }
     if (!identNodeResolved) {
-      resolveValueForIdentifierNode(value, (newValue) => {
+      resolveValueForIdentifierNode(value, rootNode, (newValue) => {
         value = newValue;
       });
     }
 
     // Verify PropTypes that are functions
     if (
-      value
-      && value.type === 'CallExpression'
+      astUtil.isCallExpression(value)
       && value.callee
       && value.callee.property
       && value.callee.property.name
@@ -462,7 +473,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
           iterateProperties(context, argument.properties, (childKey, childValue, propNode) => {
             if (childValue) { // skip spread propTypes
               const fullName = [parentName, childKey].join('.');
-              const types = buildReactDeclarationTypes(childValue, fullName);
+              const types = buildReactDeclarationTypes(childValue, fullName, rootNode);
               types.fullName = fullName;
               types.name = childKey;
               types.node = propNode;
@@ -474,7 +485,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
         case 'arrayOf':
         case 'objectOf': {
           const fullName = [parentName, '*'].join('.');
-          const child = buildReactDeclarationTypes(argument, fullName);
+          const child = buildReactDeclarationTypes(argument, fullName, rootNode);
           child.fullName = fullName;
           child.name = '__ANY_KEY__';
           child.node = argument;
@@ -488,7 +499,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
         case 'oneOfType': {
           if (
             !argument.elements
-            || !argument.elements.length
+            || argument.elements.length === 0
           ) {
             // Invalid proptype or cannot analyse statically
             return {};
@@ -497,7 +508,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
           /** @type {UnionTypeDefinition} */
           const unionTypeDefinition = {
             type: 'union',
-            children: argument.elements.map((element) => buildReactDeclarationTypes(element, parentName)),
+            children: argument.elements.map((element) => buildReactDeclarationTypes(element, parentName, rootNode)),
           };
           if (unionTypeDefinition.children.length === 0) {
             // no complex type found, simply accept everything
@@ -567,19 +578,24 @@ module.exports = function propTypesInstructions(context, components, utils) {
    */
   function filterInterfaceOrAliasByName(node, typeName) {
     return (
-      (node.id && node.id.name === typeName)
-      || (node.declaration && node.declaration.id && node.declaration.id.name === typeName)
+      node.id
+      && node.id.name === typeName
+    ) || (
+      node.declaration
+      && node.declaration.id
+      && node.declaration.id.name === typeName
     );
   }
 
   class DeclarePropTypesForTSTypeAnnotation {
-    constructor(propTypes, declaredPropTypes) {
+    constructor(propTypes, declaredPropTypes, rootNode) {
       this.propTypes = propTypes;
       this.declaredPropTypes = declaredPropTypes;
       this.foundDeclaredPropertiesList = [];
       this.referenceNameMap = new Set();
-      this.sourceCode = context.getSourceCode();
+      this.sourceCode = getSourceCode(context);
       this.shouldIgnorePropTypes = false;
+      this.rootNode = rootNode;
       this.visitTSNode(this.propTypes);
       this.endAndStructDeclaredPropTypes();
     }
@@ -609,7 +625,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
         this.visitTSNode(typeAnnotation);
       } else if (astUtil.isTSTypeParameterInstantiation(node)) {
         if (Array.isArray(node.params)) {
-          node.params.forEach(this.visitTSNode, this);
+          node.params.forEach((x) => this.visitTSNode(x));
         }
       } else {
         this.shouldIgnorePropTypes = true;
@@ -627,19 +643,30 @@ module.exports = function propTypesInstructions(context, components, utils) {
         typeName = node.typeName.name;
         const leftMostName = getLeftMostTypeName(node.typeName);
         const shouldTraverseTypeParams = genericReactTypesImport.has(leftMostName);
-        const nodeTypeParams = node.typeParameters;
-        if (shouldTraverseTypeParams && nodeTypeParams && nodeTypeParams.length !== 0) {
+        const nodeTypeArguments = propsUtil.getTypeArguments(node);
+        if (shouldTraverseTypeParams && nodeTypeArguments && nodeTypeArguments.length !== 0) {
           // All react Generic types are derived from:
           // type PropsWithChildren<P> = P & { children?: ReactNode | undefined }
           // So we should construct an optional children prop
           this.shouldSpecifyOptionalChildrenProps = true;
 
           const rightMostName = getRightMostTypeName(node.typeName);
+          if (
+            leftMostName === 'React'
+            && (
+              rightMostName === 'HTMLAttributes'
+              || rightMostName === 'HTMLElement'
+              || rightMostName === 'HTMLProps'
+            )
+          ) {
+            this.shouldSpecifyClassNameProp = true;
+          }
+
           const importedName = localToImportedMap[rightMostName];
           const idx = genericTypeParamIndexWherePropsArePresent[
             leftMostName !== rightMostName ? rightMostName : importedName
           ];
-          const nextNode = nodeTypeParams.params[idx];
+          const nextNode = nodeTypeArguments.params[idx];
           this.visitTSNode(nextNode);
           return;
         }
@@ -655,7 +682,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
         return;
       }
       if (typeName === 'ReturnType') {
-        this.convertReturnTypeToPropTypes(node);
+        this.convertReturnTypeToPropTypes(node, this.rootNode);
         return;
       }
       // Prevent recursive inheritance will cause maximum callstack.
@@ -674,7 +701,15 @@ module.exports = function propTypesInstructions(context, components, utils) {
 
       const declarations = flatMap(
         candidateTypes,
-        (type) => type.declarations || (type.declaration && type.declaration.declarations) || type.declaration);
+        (type) => (
+          type.declarations
+          || (
+            type.declaration
+            && type.declaration.declarations
+          )
+          || type.declaration
+        )
+      );
 
       // we tried to find either an interface or a type with the TypeReference name
       const typeDeclaration = declarations.filter((dec) => dec.id.name === typeName);
@@ -709,29 +744,29 @@ module.exports = function propTypesInstructions(context, components, utils) {
         this.visitTSNode(typeAnnotation);
       }
       if (Array.isArray(node.extends)) {
-        node.extends.forEach(this.visitTSNode, this);
+        node.extends.forEach((x) => this.visitTSNode(x));
         // This line is trying to handle typescript-eslint-parser
         // typescript-eslint-parser extension is name as heritage
       } else if (Array.isArray(node.heritage)) {
-        node.heritage.forEach(this.visitTSNode, this);
+        node.heritage.forEach((x) => this.visitTSNode(x));
       }
     }
 
     convertIntersectionTypeToPropTypes(node) {
       if (!node) return;
       if (Array.isArray(node.types)) {
-        node.types.forEach(this.visitTSNode, this);
+        node.types.forEach((x) => this.visitTSNode(x));
       } else {
         this.shouldIgnorePropTypes = true;
       }
     }
 
-    convertReturnTypeToPropTypes(node) {
+    convertReturnTypeToPropTypes(node, rootNode) {
       // ReturnType<T> should always have one parameter
-      const nodeTypeParams = node.typeParameters;
-      if (nodeTypeParams) {
-        if (nodeTypeParams.params.length === 1) {
-          let returnType = nodeTypeParams.params[0];
+      const nodeTypeArguments = propsUtil.getTypeArguments(node);
+      if (nodeTypeArguments) {
+        if (nodeTypeArguments.params.length === 1) {
+          let returnType = nodeTypeArguments.params[0];
           // This line is trying to handle typescript-eslint-parser
           // typescript-eslint-parser TSTypeQuery is wrapped by TSTypeReference
           if (astUtil.isTSTypeReference(returnType)) {
@@ -762,10 +797,10 @@ module.exports = function propTypesInstructions(context, components, utils) {
                   switch (res.type) {
                     case 'ObjectExpression':
                       iterateProperties(context, res.properties, (key, value, propNode) => {
-                        if (propNode && propNode.argument && propNode.argument.type === 'CallExpression') {
-                          const propNodeTypeParams = propNode.argument.typeParameters;
-                          if (propNodeTypeParams) {
-                            this.visitTSNode(propNodeTypeParams);
+                        if (propNode && astUtil.isCallExpression(propNode.argument)) {
+                          const propNodeTypeArguments = propsUtil.getTypeArguments(propNode.argument);
+                          if (propNodeTypeArguments) {
+                            this.visitTSNode(propNodeTypeArguments);
                           } else {
                             // Ignore this CallExpression return value since it doesn't have any typeParameters to let us know it's types.
                             this.shouldIgnorePropTypes = true;
@@ -776,7 +811,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
                           this.shouldIgnorePropTypes = true;
                           return;
                         }
-                        const types = buildReactDeclarationTypes(value, key);
+                        const types = buildReactDeclarationTypes(value, key, rootNode);
                         types.fullName = key;
                         types.name = key;
                         types.node = propNode;
@@ -785,8 +820,8 @@ module.exports = function propTypesInstructions(context, components, utils) {
                       });
                       break;
                     case 'CallExpression':
-                      if (res.typeParameters) {
-                        this.visitTSNode(res.typeParameters);
+                      if (propsUtil.getTypeArguments(res)) {
+                        this.visitTSNode(propsUtil.getTypeArguments(res));
                       } else {
                         // Ignore this CallExpression return value since it doesn't have any typeParameters to let us know it's types.
                         this.shouldIgnorePropTypes = true;
@@ -825,6 +860,14 @@ module.exports = function propTypesInstructions(context, components, utils) {
           isRequired: false,
         };
       }
+      if (this.shouldSpecifyClassNameProp) {
+        this.declaredPropTypes.className = {
+          fullName: 'className',
+          name: 'className',
+          isRequired: false,
+        };
+      }
+
       this.foundDeclaredPropertiesList.forEach((tsInterfaceBody) => {
         if (tsInterfaceBody && (tsInterfaceBody.type === 'TSPropertySignature' || tsInterfaceBody.type === 'TSMethodSignature')) {
           let accessor = 'name';
@@ -850,8 +893,9 @@ module.exports = function propTypesInstructions(context, components, utils) {
    * Mark a prop type as declared
    * @param {ASTNode} node The AST node being checked.
    * @param {ASTNode} propTypes The AST node containing the proptypes
+   * @param {ASTNode} rootNode
    */
-  function markPropTypesAsDeclared(node, propTypes) {
+  function markPropTypesAsDeclared(node, propTypes, rootNode) {
     let componentNode = node;
     while (componentNode && !components.get(componentNode)) {
       componentNode = componentNode.parent;
@@ -869,7 +913,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
             ignorePropsValidation = true;
             return;
           }
-          const types = buildReactDeclarationTypes(value, key);
+          const types = buildReactDeclarationTypes(value, key, rootNode);
           types.fullName = key;
           types.name = key;
           types.node = propNode;
@@ -903,10 +947,11 @@ module.exports = function propTypesInstructions(context, components, utils) {
             ignorePropsValidation = true;
             break;
           }
-          const parentProp = context.getSource(propTypes.parent.left.object).replace(/^.*\.propTypes\./, '');
+          const parentProp = getText(context, propTypes.parent.left.object).replace(/^.*\.propTypes\./, '');
           const types = buildReactDeclarationTypes(
             propTypes.parent.right,
-            parentProp
+            parentProp,
+            rootNode
           );
 
           types.name = propTypes.property.name;
@@ -934,12 +979,10 @@ module.exports = function propTypesInstructions(context, components, utils) {
         break;
       }
       case 'Identifier': {
-        const variablesInScope = variableUtil.variablesInScope(context);
-        const firstMatchingVariable = variablesInScope
-          .find((variableInScope) => variableInScope.name === propTypes.name);
+        const firstMatchingVariable = variableUtil.getVariableFromContext(context, node, propTypes.name);
         if (firstMatchingVariable) {
           const defInScope = firstMatchingVariable.defs[firstMatchingVariable.defs.length - 1];
-          markPropTypesAsDeclared(node, defInScope.node && defInScope.node.init);
+          markPropTypesAsDeclared(node, defInScope.node && defInScope.node.init, rootNode);
           return;
         }
         ignorePropsValidation = true;
@@ -949,11 +992,11 @@ module.exports = function propTypesInstructions(context, components, utils) {
         if (
           propWrapperUtil.isPropWrapperFunction(
             context,
-            context.getSourceCode().getText(propTypes.callee)
+            getText(context, propTypes.callee)
           )
           && propTypes.arguments && propTypes.arguments[0]
         ) {
-          markPropTypesAsDeclared(node, propTypes.arguments[0]);
+          markPropTypesAsDeclared(node, propTypes.arguments[0], rootNode);
           return;
         }
         break;
@@ -963,9 +1006,9 @@ module.exports = function propTypesInstructions(context, components, utils) {
         break;
       case 'GenericTypeAnnotation':
         if (propTypes.id.name === '$ReadOnly') {
-          const propTypeParams = propTypes.typeParameters;
+          const propTypeArguments = propsUtil.getTypeArguments(propTypes);
           ignorePropsValidation = declarePropTypesForObjectTypeAnnotation(
-            propTypeParams.params[0],
+            propTypeArguments.params[0],
             declaredPropTypes
           );
         } else {
@@ -974,7 +1017,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
         break;
       case 'TSTypeReference':
       case 'TSTypeAnnotation': {
-        const tsTypeAnnotation = new DeclarePropTypesForTSTypeAnnotation(propTypes, declaredPropTypes);
+        const tsTypeAnnotation = new DeclarePropTypesForTSTypeAnnotation(propTypes, declaredPropTypes, rootNode);
         ignorePropsValidation = tsTypeAnnotation.shouldIgnorePropTypes;
         declaredPropTypes = tsTypeAnnotation.declaredPropTypes;
       }
@@ -995,17 +1038,23 @@ module.exports = function propTypesInstructions(context, components, utils) {
   /**
    * @param {ASTNode} node We expect either an ArrowFunctionExpression,
    *   FunctionDeclaration, or FunctionExpression
+   * @param {ASTNode} rootNode
    */
-  function markAnnotatedFunctionArgumentsAsDeclared(node) {
+  function markAnnotatedFunctionArgumentsAsDeclared(node, rootNode) {
     if (!node.params || !node.params.length) {
       return;
     }
 
+    let propTypesArguments = null;
+    if (node.parent) {
+      propTypesArguments = propsUtil.getTypeArguments(node.parent);
+    }
+
     if (
       node.parent
       && node.parent.callee
-      && node.parent.typeParameters
-      && node.parent.typeParameters.params
+      && propTypesArguments
+      && propTypesArguments.params
       && (
         node.parent.callee.name === 'forwardRef' || (
           node.parent.callee.object
@@ -1015,9 +1064,8 @@ module.exports = function propTypesInstructions(context, components, utils) {
         )
       )
     ) {
-      const propTypesParams = node.parent.typeParameters;
       const declaredPropTypes = {};
-      const obj = new DeclarePropTypesForTSTypeAnnotation(propTypesParams.params[1], declaredPropTypes);
+      const obj = new DeclarePropTypesForTSTypeAnnotation(propTypesArguments.params[1], declaredPropTypes, rootNode);
       components.set(node, {
         declaredPropTypes: obj.declaredPropTypes,
         ignorePropsValidation: obj.shouldIgnorePropTypes,
@@ -1048,13 +1096,13 @@ module.exports = function propTypesInstructions(context, components, utils) {
       if (param.typeAnnotation && param.typeAnnotation.typeAnnotation && param.typeAnnotation.typeAnnotation.type === 'UnionTypeAnnotation') {
         param.typeAnnotation.typeAnnotation.types.forEach((annotation) => {
           if (annotation.type === 'GenericTypeAnnotation') {
-            markPropTypesAsDeclared(node, resolveTypeAnnotation(annotation));
+            markPropTypesAsDeclared(node, resolveTypeAnnotation(annotation), rootNode);
           } else {
-            markPropTypesAsDeclared(node, annotation);
+            markPropTypesAsDeclared(node, annotation, rootNode);
           }
         });
       } else {
-        markPropTypesAsDeclared(node, resolveTypeAnnotation(param));
+        markPropTypesAsDeclared(node, resolveTypeAnnotation(param), rootNode);
       }
     } else {
       // implements what's discussed here: https://github.com/jsx-eslint/eslint-plugin-react/issues/2777#issuecomment-683944481
@@ -1063,35 +1111,37 @@ module.exports = function propTypesInstructions(context, components, utils) {
       if (
         annotation
         && annotation.type !== 'TSTypeReference'
-        && annotation.typeParameters == null
+        && propsUtil.getTypeArguments(annotation) == null
       ) {
         return;
       }
 
       if (!isValidReactGenericTypeAnnotation(annotation)) return;
 
-      markPropTypesAsDeclared(node, resolveTypeAnnotation(siblingIdentifier));
+      markPropTypesAsDeclared(node, resolveTypeAnnotation(siblingIdentifier), rootNode);
     }
   }
 
   /**
-   * Resolve the type annotation for a given class declaration node with superTypeParameters.
+   * Resolve the type annotation for a given class declaration node.
    *
    * @param {ASTNode} node The annotation or a node containing the type annotation.
    * @returns {ASTNode} The resolved type annotation for the node.
    */
   function resolveSuperParameterPropsType(node) {
     let propsParameterPosition;
+    const parameters = propsUtil.getSuperTypeArguments(node);
+
     try {
       // Flow <=0.52 had 3 required TypedParameters of which the second one is the Props.
       // Flow >=0.53 has 2 optional TypedParameters of which the first one is the Props.
       propsParameterPosition = testFlowVersion(context, '>= 0.53.0') ? 0 : 1;
     } catch (e) {
       // In case there is no flow version defined, we can safely assume that when there are 3 Props we are dealing with version <= 0.52
-      propsParameterPosition = node.superTypeParameters.params.length <= 2 ? 0 : 1;
+      propsParameterPosition = parameters.params.length <= 2 ? 0 : 1;
     }
 
-    let annotation = node.superTypeParameters.params[propsParameterPosition];
+    let annotation = parameters.params[propsParameterPosition];
     while (annotation && (annotation.type === 'TypeAnnotation' || annotation.type === 'NullableTypeAnnotation')) {
       annotation = annotation.typeAnnotation;
     }
@@ -1105,11 +1155,11 @@ module.exports = function propTypesInstructions(context, components, utils) {
   /**
    * Checks if we are declaring a `props` class property with a flow type annotation.
    * @param {ASTNode} node The AST node being checked.
-   * @returns {Boolean} True if the node is a type annotated props declaration, false if not.
+   * @returns {boolean} True if the node is a type annotated props declaration, false if not.
    */
   function isAnnotatedClassPropsDeclaration(node) {
     if (node && (node.type === 'ClassProperty' || node.type === 'PropertyDefinition')) {
-      const tokens = context.getFirstTokens(node, 2);
+      const tokens = getFirstTokens(context, node, 2);
       if (
         node.typeAnnotation && (
           tokens[0].value === 'props'
@@ -1132,15 +1182,15 @@ module.exports = function propTypesInstructions(context, components, utils) {
 
     ClassDeclaration(node) {
       if (isSuperTypeParameterPropsDeclaration(node)) {
-        markPropTypesAsDeclared(node, resolveSuperParameterPropsType(node));
+        markPropTypesAsDeclared(node, resolveSuperParameterPropsType(node), node);
       }
     },
 
     'ClassProperty, PropertyDefinition'(node) {
       if (isAnnotatedClassPropsDeclaration(node)) {
-        markPropTypesAsDeclared(node, resolveTypeAnnotation(node));
+        markPropTypesAsDeclared(node, resolveTypeAnnotation(node), node);
       } else if (propsUtil.isPropTypesDeclaration(node)) {
-        markPropTypesAsDeclared(node, node.value);
+        markPropTypesAsDeclared(node, node.value, node);
       }
     },
 
@@ -1150,13 +1200,13 @@ module.exports = function propTypesInstructions(context, components, utils) {
         if (!propsUtil.isPropTypesDeclaration(property)) {
           return;
         }
-        markPropTypesAsDeclared(node, property.value);
+        markPropTypesAsDeclared(node, property.value, node);
       });
     },
 
     FunctionExpression(node) {
       if (node.parent.type !== 'MethodDefinition') {
-        markAnnotatedFunctionArgumentsAsDeclared(node);
+        markAnnotatedFunctionArgumentsAsDeclared(node, node);
       }
     },
 
@@ -1193,7 +1243,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
           return;
         }
         try {
-          markPropTypesAsDeclared(component.node, node.parent.right || node.parent);
+          markPropTypesAsDeclared(component.node, node.parent.right || node.parent, node);
         } catch (e) {
           if (e.constructor !== RangeError) { throw e; }
         }
@@ -1213,7 +1263,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
       }
 
       if (i >= 0) {
-        markPropTypesAsDeclared(node, node.value.body.body[i].argument);
+        markPropTypesAsDeclared(node, node.value.body.body[i].argument, node);
       }
     },
 
@@ -1244,7 +1294,7 @@ module.exports = function propTypesInstructions(context, components, utils) {
     'Program:exit'() {
       classExpressions.forEach((node) => {
         if (isSuperTypeParameterPropsDeclaration(node)) {
-          markPropTypesAsDeclared(node, resolveSuperParameterPropsType(node));
+          markPropTypesAsDeclared(node, resolveSuperParameterPropsType(node), node);
         }
       });
     },
diff --git a/lib/util/propTypesSort.js b/lib/util/propTypesSort.js
index 505f346a3b..4b42904c63 100644
--- a/lib/util/propTypesSort.js
+++ b/lib/util/propTypesSort.js
@@ -7,22 +7,28 @@
 const toSorted = require('array.prototype.tosorted');
 
 const astUtil = require('./ast');
+const eslintUtil = require('./eslint');
+
+const getSourceCode = eslintUtil.getSourceCode;
+const getText = eslintUtil.getText;
 
 /**
  * Returns the value name of a node.
  *
  * @param {ASTNode} node the node to check.
- * @returns {String} The name of the node.
+ * @returns {string} The name of the node.
  */
 function getValueName(node) {
-  return node.type === 'Property' && node.value.property && node.value.property.name;
+  return node.type === 'Property'
+    && node.value.property
+    && node.value.property.name;
 }
 
 /**
  * Checks if the prop is required or not.
  *
  * @param {ASTNode} node the prop to check.
- * @returns {Boolean} true if the prop is required.
+ * @returns {boolean} true if the prop is required.
  */
 function isRequiredProp(node) {
   return getValueName(node) === 'isRequired';
@@ -31,8 +37,8 @@ function isRequiredProp(node) {
 /**
  * Checks if the proptype is a callback by checking if it starts with 'on'.
  *
- * @param {String} propName the name of the proptype to check.
- * @returns {Boolean} true if the proptype is a callback.
+ * @param {string} propName the name of the proptype to check.
+ * @returns {boolean} true if the proptype is a callback.
  */
 function isCallbackPropName(propName) {
   return /^on[A-Z]/.test(propName);
@@ -42,11 +48,14 @@ function isCallbackPropName(propName) {
  * Checks if the prop is PropTypes.shape.
  *
  * @param {ASTNode} node the prop to check.
- * @returns {Boolean} true if the prop is PropTypes.shape.
+ * @returns {boolean} true if the prop is PropTypes.shape.
  */
 function isShapeProp(node) {
-  return Boolean(
-    node && node.callee && node.callee.property && node.callee.property.name === 'shape'
+  return !!(
+    node
+    && node.callee
+    && node.callee.property
+    && node.callee.property.name === 'shape'
   );
 }
 
@@ -57,7 +66,9 @@ function isShapeProp(node) {
  * @returns {Array} the properties of the PropTypes.shape node.
  */
 function getShapeProperties(node) {
-  return node.arguments && node.arguments[0] && node.arguments[0].properties;
+  return node.arguments
+    && node.arguments[0]
+    && node.arguments[0].properties;
 }
 
 /**
@@ -66,11 +77,11 @@ function getShapeProperties(node) {
  * @param {ASTNode} a the first element to compare.
  * @param {ASTNode} b the second element to compare.
  * @param {Context} context The context of the two nodes.
- * @param {Boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
- * @param {Boolean=} requiredFirst whether or not to sort required elements first.
- * @param {Boolean=} callbacksLast whether or not to sort callbacks after everything else.
- * @param {Boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
- * @returns {Number} the sort order of the two elements.
+ * @param {boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
+ * @param {boolean=} requiredFirst whether or not to sort required elements first.
+ * @param {boolean=} callbacksLast whether or not to sort callbacks after everything else.
+ * @param {boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
+ * @returns {number} the sort order of the two elements.
  */
 function sorter(a, b, context, ignoreCase, requiredFirst, callbacksLast, noSortAlphabetically) {
   const aKey = String(astUtil.getKeyValue(context, a));
@@ -114,29 +125,31 @@ const commentnodeMap = new WeakMap(); // all nodes reference WeakMap for start a
 /**
  * Fixes sort order of prop types.
  *
+ * @param {Context} context the second element to compare.
  * @param {Fixer} fixer the first element to compare.
- * @param {Object} context the second element to compare.
  * @param {Array} declarations The context of the two nodes.
- * @param {Boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
- * @param {Boolean=} requiredFirst whether or not to sort required elements first.
- * @param {Boolean=} callbacksLast whether or not to sort callbacks after everything else.
- * @param {Boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
- * @param {Boolean=} sortShapeProp whether or not to sort propTypes defined in PropTypes.shape.
+ * @param {boolean=} ignoreCase whether or not to ignore case when comparing the two elements.
+ * @param {boolean=} requiredFirst whether or not to sort required elements first.
+ * @param {boolean=} callbacksLast whether or not to sort callbacks after everything else.
+ * @param {boolean=} noSortAlphabetically whether or not to disable alphabetical sorting of the elements.
+ * @param {boolean=} sortShapeProp whether or not to sort propTypes defined in PropTypes.shape.
+ * @param {boolean=} checkTypes whether or not sorting of prop type definitions are checked.
  * @returns {Object|*|{range, text}} the sort order of the two elements.
  */
 function fixPropTypesSort(
-  fixer,
   context,
+  fixer,
   declarations,
   ignoreCase,
   requiredFirst,
   callbacksLast,
   noSortAlphabetically,
-  sortShapeProp
+  sortShapeProp,
+  checkTypes
 ) {
   function sortInSource(allNodes, source) {
     const originalSource = source;
-    const sourceCode = context.getSourceCode();
+    const sourceCode = getSourceCode(context);
     for (let i = 0; i < allNodes.length; i++) {
       const node = allNodes[i];
       let commentAfter = [];
@@ -178,11 +191,16 @@ function fixPropTypesSort(
         (a, b) => sorter(a, b, context, ignoreCase, requiredFirst, callbacksLast, noSortAlphabetically)
       );
 
+      const sourceCodeText = getText(context);
+      let separator = '';
       source = nodes.reduceRight((acc, attr, index) => {
         const sortedAttr = sortedAttributes[index];
-        const sourceCodeText = sourceCode.getText();
         const commentNode = commentnodeMap.get(sortedAttr);
         let sortedAttrText = sourceCodeText.slice(commentNode.start, commentNode.end);
+        const sortedAttrTextLastChar = sortedAttrText[sortedAttrText.length - 1];
+        if (!separator && [';', ','].some((allowedSep) => sortedAttrTextLastChar === allowedSep)) {
+          separator = sortedAttrTextLastChar;
+        }
         if (sortShapeProp && isShapeProp(sortedAttr.value)) {
           const shape = getShapeProperties(sortedAttr.value);
           if (shape) {
@@ -193,13 +211,14 @@ function fixPropTypesSort(
             sortedAttrText = attrSource.slice(sortedAttr.range[0], sortedAttr.range[1]);
           }
         }
-        return `${acc.slice(0, commentnodeMap.get(attr).start)}${sortedAttrText}${acc.slice(commentnodeMap.get(attr).end)}`;
+        const sortedAttrTextVal = checkTypes && !sortedAttrText.endsWith(separator) ? `${sortedAttrText}${separator}` : sortedAttrText;
+        return `${acc.slice(0, commentnodeMap.get(attr).start)}${sortedAttrTextVal}${acc.slice(commentnodeMap.get(attr).end)}`;
       }, source);
     });
     return source;
   }
 
-  const source = sortInSource(declarations, context.getSourceCode().getText());
+  const source = sortInSource(declarations, getText(context));
 
   const rangeStart = commentnodeMap.get(declarations[0]).start;
   const rangeEnd = commentnodeMap.get(declarations[declarations.length - 1]).end;
@@ -208,4 +227,7 @@ function fixPropTypesSort(
 
 module.exports = {
   fixPropTypesSort,
+  isCallbackPropName,
+  isRequiredProp,
+  isShapeProp,
 };
diff --git a/lib/util/props.js b/lib/util/props.js
index 4cd89584e5..ac4ed8703b 100644
--- a/lib/util/props.js
+++ b/lib/util/props.js
@@ -9,7 +9,7 @@ const astUtil = require('./ast');
 /**
  * Checks if the Identifier node passed in looks like a propTypes declaration.
  * @param {ASTNode} node The node to check. Must be an Identifier node.
- * @returns {Boolean} `true` if the node is a propTypes declaration, `false` if not
+ * @returns {boolean} `true` if the node is a propTypes declaration, `false` if not
  */
 function isPropTypesDeclaration(node) {
   if (node && (node.type === 'ClassProperty' || node.type === 'PropertyDefinition')) {
@@ -24,7 +24,7 @@ function isPropTypesDeclaration(node) {
 /**
  * Checks if the node passed in looks like a contextTypes declaration.
  * @param {ASTNode} node The node to check.
- * @returns {Boolean} `true` if the node is a contextTypes declaration, `false` if not
+ * @returns {boolean} `true` if the node is a contextTypes declaration, `false` if not
  */
 function isContextTypesDeclaration(node) {
   if (node && (node.type === 'ClassProperty' || node.type === 'PropertyDefinition')) {
@@ -39,7 +39,7 @@ function isContextTypesDeclaration(node) {
 /**
  * Checks if the node passed in looks like a contextType declaration.
  * @param {ASTNode} node The node to check.
- * @returns {Boolean} `true` if the node is a contextType declaration, `false` if not
+ * @returns {boolean} `true` if the node is a contextType declaration, `false` if not
  */
 function isContextTypeDeclaration(node) {
   return astUtil.getPropertyName(node) === 'contextType';
@@ -48,7 +48,7 @@ function isContextTypeDeclaration(node) {
 /**
  * Checks if the node passed in looks like a childContextTypes declaration.
  * @param {ASTNode} node The node to check.
- * @returns {Boolean} `true` if the node is a childContextTypes declaration, `false` if not
+ * @returns {boolean} `true` if the node is a childContextTypes declaration, `false` if not
  */
 function isChildContextTypesDeclaration(node) {
   return astUtil.getPropertyName(node) === 'childContextTypes';
@@ -57,7 +57,7 @@ function isChildContextTypesDeclaration(node) {
 /**
  * Checks if the Identifier node passed in looks like a defaultProps declaration.
  * @param {ASTNode} node The node to check. Must be an Identifier node.
- * @returns {Boolean} `true` if the node is a defaultProps declaration, `false` if not
+ * @returns {boolean} `true` if the node is a defaultProps declaration, `false` if not
  */
 function isDefaultPropsDeclaration(node) {
   const propName = astUtil.getPropertyName(node);
@@ -67,7 +67,7 @@ function isDefaultPropsDeclaration(node) {
 /**
  * Checks if we are declaring a display name
  * @param {ASTNode} node The AST node being checked.
- * @returns {Boolean} True if we are declaring a display name, false if not.
+ * @returns {boolean} True if we are declaring a display name, false if not.
  */
 function isDisplayNameDeclaration(node) {
   switch (node.type) {
@@ -86,10 +86,35 @@ function isDisplayNameDeclaration(node) {
 /**
  * Checks if the PropTypes MemberExpression node passed in declares a required propType.
  * @param {ASTNode} propTypeExpression node to check. Must be a `PropTypes` MemberExpression.
- * @returns {Boolean} `true` if this PropType is required, `false` if not.
+ * @returns {boolean} `true` if this PropType is required, `false` if not.
  */
 function isRequiredPropType(propTypeExpression) {
-  return propTypeExpression.type === 'MemberExpression' && propTypeExpression.property.name === 'isRequired';
+  return propTypeExpression.type === 'MemberExpression'
+    && propTypeExpression.property.name === 'isRequired';
+}
+
+/**
+ * Returns the type arguments of a node or type parameters if type arguments are not available.
+ * @param {ASTNode} node The node to get the type arguments from.
+ * @returns {ASTNode} The type arguments or type parameters of the node.
+ */
+function getTypeArguments(node) {
+  if ('typeArguments' in node) {
+    return node.typeArguments;
+  }
+  return node.typeParameters;
+}
+
+/**
+ * Returns the super type arguments of a node or super type parameters if type arguments are not available.
+ * @param {ASTNode} node The node to get the super type arguments from.
+ * @returns {ASTNode} The super type arguments or parameters of the node.
+ */
+function getSuperTypeArguments(node) {
+  if ('superTypeArguments' in node) {
+    return node.superTypeArguments;
+  }
+  return node.superTypeParameters;
 }
 
 module.exports = {
@@ -100,4 +125,6 @@ module.exports = {
   isDefaultPropsDeclaration,
   isDisplayNameDeclaration,
   isRequiredPropType,
+  getTypeArguments,
+  getSuperTypeArguments,
 };
diff --git a/lib/util/usedPropTypes.js b/lib/util/usedPropTypes.js
index 6a0a650333..f0dae34ca4 100644
--- a/lib/util/usedPropTypes.js
+++ b/lib/util/usedPropTypes.js
@@ -9,7 +9,10 @@ const values = require('object.values');
 const astUtil = require('./ast');
 const componentUtil = require('./componentUtil');
 const testReactVersion = require('./version').testReactVersion;
-const ast = require('./ast');
+const eslintUtil = require('./eslint');
+
+const getScope = eslintUtil.getScope;
+const getSourceCode = eslintUtil.getSourceCode;
 
 // ------------------------------------------------------------------------------
 // Constants
@@ -62,7 +65,7 @@ function createPropVariables() {
 /**
  * Checks if the string is one of `props`, `nextProps`, or `prevProps`
  * @param {string} name The AST node being checked.
- * @returns {Boolean} True if the prop name matches
+ * @returns {boolean} True if the prop name matches
  */
 function isCommonVariableNameForProps(name) {
   return name === 'props' || name === 'nextProps' || name === 'prevProps';
@@ -71,7 +74,7 @@ function isCommonVariableNameForProps(name) {
 /**
  * Checks if the component must be validated
  * @param {Object} component The component to process
- * @returns {Boolean} True if the component must be validated, false if not.
+ * @returns {boolean} True if the component must be validated, false if not.
  */
 function mustBeValidated(component) {
   return !!(component && !component.ignorePropsValidation);
@@ -80,11 +83,12 @@ function mustBeValidated(component) {
 /**
  * Check if we are in a lifecycle method
  * @param {object} context
+ * @param {ASTNode} node The AST node being checked.
  * @param {boolean} checkAsyncSafeLifeCycles
  * @return {boolean} true if we are in a class constructor, false if not
  */
-function inLifeCycleMethod(context, checkAsyncSafeLifeCycles) {
-  let scope = context.getScope();
+function inLifeCycleMethod(context, node, checkAsyncSafeLifeCycles) {
+  let scope = getScope(context, node);
   while (scope) {
     if (scope.block && scope.block.parent && scope.block.parent.key) {
       const name = scope.block.parent.key.name;
@@ -105,19 +109,26 @@ function inLifeCycleMethod(context, checkAsyncSafeLifeCycles) {
  * Returns true if the given node is a React Component lifecycle method
  * @param {ASTNode} node The AST node being checked.
  * @param {boolean} checkAsyncSafeLifeCycles
- * @return {Boolean} True if the node is a lifecycle method
+ * @return {boolean} True if the node is a lifecycle method
  */
 function isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles) {
-  const nodeKeyName = (node.key || /** @type {ASTNode} */ ({})).name;
+  if (node.key) {
+    if (node.kind === 'constructor') {
+      return true;
+    }
 
-  if (node.kind === 'constructor') {
-    return true;
-  }
-  if (LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
-    return true;
-  }
-  if (checkAsyncSafeLifeCycles && ASYNC_SAFE_LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
-    return true;
+    const nodeKeyName = node.key.name;
+
+    if (typeof nodeKeyName !== 'string') {
+      return false;
+    }
+
+    if (LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
+      return true;
+    }
+    if (checkAsyncSafeLifeCycles && ASYNC_SAFE_LIFE_CYCLE_METHODS.indexOf(nodeKeyName) >= 0) {
+      return true;
+    }
   }
 
   return false;
@@ -128,10 +139,13 @@ function isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles) {
  * method.
  * @param {ASTNode} node The AST node being checked.
  * @param {boolean} checkAsyncSafeLifeCycles
- * @return {Boolean} True if the node is inside a lifecycle method
+ * @return {boolean} True if the node is inside a lifecycle method
  */
 function isInLifeCycleMethod(node, checkAsyncSafeLifeCycles) {
-  if ((node.type === 'MethodDefinition' || node.type === 'Property') && isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles)) {
+  if (
+    (node.type === 'MethodDefinition' || node.type === 'Property')
+    && isNodeALifeCycleMethod(node, checkAsyncSafeLifeCycles)
+  ) {
     return true;
   }
 
@@ -148,8 +162,8 @@ function isInLifeCycleMethod(node, checkAsyncSafeLifeCycles) {
  * @return {boolean}
  */
 function isSetStateUpdater(node) {
-  const unwrappedParentCalleeNode = node.parent && node.parent.type === 'CallExpression'
-    && ast.unwrapTSAsExpression(node.parent.callee);
+  const unwrappedParentCalleeNode = astUtil.isCallExpression(node.parent)
+    && astUtil.unwrapTSAsExpression(node.parent.callee);
 
   return unwrappedParentCalleeNode
     && unwrappedParentCalleeNode.property
@@ -158,16 +172,15 @@ function isSetStateUpdater(node) {
     && node.parent.arguments[0] === node;
 }
 
-function isPropArgumentInSetStateUpdater(context, name) {
+function isPropArgumentInSetStateUpdater(context, node, name) {
   if (typeof name !== 'string') {
     return;
   }
-  let scope = context.getScope();
+  let scope = getScope(context, node);
   while (scope) {
     const unwrappedParentCalleeNode = scope.block
-      && scope.block.parent
-      && scope.block.parent.type === 'CallExpression'
-      && ast.unwrapTSAsExpression(scope.block.parent.callee);
+      && astUtil.isCallExpression(scope.block.parent)
+      && astUtil.unwrapTSAsExpression(scope.block.parent.callee);
     if (
       unwrappedParentCalleeNode
       && unwrappedParentCalleeNode.property
@@ -186,10 +199,11 @@ function isPropArgumentInSetStateUpdater(context, name) {
 
 /**
  * @param {Context} context
+ * @param {ASTNode} node
  * @returns {boolean}
  */
-function isInClassComponent(context) {
-  return !!(componentUtil.getParentES6Component(context) || componentUtil.getParentES5Component(context));
+function isInClassComponent(context, node) {
+  return !!(componentUtil.getParentES6Component(context, node) || componentUtil.getParentES5Component(context, node));
 }
 
 /**
@@ -200,7 +214,7 @@ function isInClassComponent(context) {
 function isThisDotProps(node) {
   return !!node
     && node.type === 'MemberExpression'
-    && ast.unwrapTSAsExpression(node.object).type === 'ThisExpression'
+    && astUtil.unwrapTSAsExpression(node.object).type === 'ThisExpression'
     && node.property.name === 'props';
 }
 
@@ -208,25 +222,25 @@ function isThisDotProps(node) {
  * Checks if the prop has spread operator.
  * @param {object} context
  * @param {ASTNode} node The AST node being marked.
- * @returns {Boolean} True if the prop has spread operator, false if not.
+ * @returns {boolean} True if the prop has spread operator, false if not.
  */
 function hasSpreadOperator(context, node) {
-  const tokens = context.getSourceCode().getTokens(node);
+  const tokens = getSourceCode(context).getTokens(node);
   return tokens.length && tokens[0].value === '...';
 }
 
 /**
  * Checks if the node is a propTypes usage of the form `this.props.*`, `props.*`, `prevProps.*`, or `nextProps.*`.
- * @param {ASTNode} node
  * @param {Context} context
+ * @param {ASTNode} node
  * @param {Object} utils
  * @param {boolean} checkAsyncSafeLifeCycles
  * @returns {boolean}
  */
-function isPropTypesUsageByMemberExpression(node, context, utils, checkAsyncSafeLifeCycles) {
-  const unwrappedObjectNode = ast.unwrapTSAsExpression(node.object);
+function isPropTypesUsageByMemberExpression(context, node, utils, checkAsyncSafeLifeCycles) {
+  const unwrappedObjectNode = astUtil.unwrapTSAsExpression(node.object);
 
-  if (isInClassComponent(context)) {
+  if (isInClassComponent(context, node)) {
     // this.props.*
     if (isThisDotProps(unwrappedObjectNode)) {
       return true;
@@ -234,29 +248,29 @@ function isPropTypesUsageByMemberExpression(node, context, utils, checkAsyncSafe
     // props.* or prevProps.* or nextProps.*
     if (
       isCommonVariableNameForProps(unwrappedObjectNode.name)
-      && (inLifeCycleMethod(context, checkAsyncSafeLifeCycles) || astUtil.inConstructor(context))
+      && (inLifeCycleMethod(context, node, checkAsyncSafeLifeCycles) || astUtil.inConstructor(context, node))
     ) {
       return true;
     }
     // this.setState((_, props) => props.*))
-    if (isPropArgumentInSetStateUpdater(context, unwrappedObjectNode.name)) {
+    if (isPropArgumentInSetStateUpdater(context, node, unwrappedObjectNode.name)) {
       return true;
     }
     return false;
   }
   // props.* in function component
-  return unwrappedObjectNode.name === 'props' && !ast.isAssignmentLHS(node);
+  return unwrappedObjectNode.name === 'props' && !astUtil.isAssignmentLHS(node);
 }
 
 /**
  * Retrieve the name of a property node
- * @param {ASTNode} node The AST node with the property.
  * @param {Context} context
+ * @param {ASTNode} node The AST node with the property.
  * @param {Object} utils
  * @param {boolean} checkAsyncSafeLifeCycles
  * @return {string|undefined} the name of the property or undefined if not found
  */
-function getPropertyName(node, context, utils, checkAsyncSafeLifeCycles) {
+function getPropertyName(context, node, utils, checkAsyncSafeLifeCycles) {
   const property = node.property;
   if (property) {
     switch (property.type) {
@@ -274,7 +288,7 @@ function getPropertyName(node, context, utils, checkAsyncSafeLifeCycles) {
         }
         // Accept number as well but only accept props[123]
         if (typeof property.value === 'number') {
-          if (isPropTypesUsageByMemberExpression(node, context, utils, checkAsyncSafeLifeCycles)) {
+          if (isPropTypesUsageByMemberExpression(context, node, utils, checkAsyncSafeLifeCycles)) {
             return property.raw;
           }
         }
@@ -306,109 +320,91 @@ module.exports = function usedPropTypesInstructions(context, components, utils)
     let name;
     let allNames;
     let properties;
-    switch (node.type) {
-      case 'OptionalMemberExpression':
-      case 'MemberExpression':
-        name = getPropertyName(node, context, utils, checkAsyncSafeLifeCycles);
-        if (name) {
-          allNames = parentNames.concat(name);
-          if (
-            // Match props.foo.bar, don't match bar[props.foo]
-            node.parent.type === 'MemberExpression'
-            && node.parent.object === node
-          ) {
-            markPropTypesAsUsed(node.parent, allNames);
-          }
-          // Handle the destructuring part of `const {foo} = props.a.b`
-          if (
-            node.parent.type === 'VariableDeclarator'
-            && node.parent.id.type === 'ObjectPattern'
-          ) {
-            node.parent.id.parent = node.parent; // patch for bug in eslint@4 in which ObjectPattern has no parent
-            markPropTypesAsUsed(node.parent.id, allNames);
-          }
-
-          // const a = props.a
-          if (
-            node.parent.type === 'VariableDeclarator'
-            && node.parent.id.type === 'Identifier'
-          ) {
-            propVariables.set(node.parent.id.name, allNames);
-          }
-          // Do not mark computed props as used.
-          type = name !== '__COMPUTED_PROP__' ? 'direct' : null;
+    if (astUtil.isMemberExpression(node)) {
+      name = getPropertyName(context, node, utils, checkAsyncSafeLifeCycles);
+      if (name) {
+        allNames = parentNames.concat(name);
+        const parent = node.parent;
+        if (
+        // Match props.foo.bar, don't match bar[props.foo]
+          parent.type === 'MemberExpression'
+            && 'object' in parent
+            && parent.object === node
+        ) {
+          markPropTypesAsUsed(parent, allNames);
         }
-        break;
-      case 'ArrowFunctionExpression':
-      case 'FunctionDeclaration':
-      case 'FunctionExpression': {
-        if (node.params.length === 0) {
-          break;
+        // Handle the destructuring part of `const {foo} = props.a.b`
+        if (
+          astUtil.isVariableDeclarator(parent)
+            && parent.id.type === 'ObjectPattern'
+        ) {
+          parent.id.parent = parent; // patch for bug in eslint@4 in which ObjectPattern has no parent
+          markPropTypesAsUsed(parent.id, allNames);
+        }
+
+        // const a = props.a
+        if (
+          astUtil.isVariableDeclarator(parent)
+            && parent.id.type === 'Identifier'
+        ) {
+          propVariables.set(parent.id.name, allNames);
         }
+        // Do not mark computed props as used.
+        type = name !== '__COMPUTED_PROP__' ? 'direct' : null;
+      }
+    } else if (astUtil.isFunctionLike(node)) {
+      if (node.params.length > 0) {
         type = 'destructuring';
         const propParam = isSetStateUpdater(node) ? node.params[1] : node.params[0];
         properties = propParam.type === 'AssignmentPattern'
           ? propParam.left.properties
           : propParam.properties;
-        break;
       }
-      case 'ObjectPattern':
-        type = 'destructuring';
-        properties = node.properties;
-        break;
-      case 'TSEmptyBodyFunctionExpression':
-        break;
-      default:
-        throw new Error(`${node.type} ASTNodes are not handled by markPropTypesAsUsed`);
+    } else if (astUtil.isObjectPattern(node)) {
+      type = 'destructuring';
+      properties = node.properties;
+    } else if (node.type !== 'TSEmptyBodyFunctionExpression') {
+      throw new Error(`${node.type} ASTNodes are not handled by markPropTypesAsUsed`);
     }
 
-    const component = components.get(utils.getParentComponent());
+    const component = components.get(utils.getParentComponent(node));
     const usedPropTypes = (component && component.usedPropTypes) || [];
     let ignoreUnusedPropTypesValidation = (component && component.ignoreUnusedPropTypesValidation) || false;
 
-    switch (type) {
-      case 'direct': {
-        // Ignore Object methods
-        if (name in Object.prototype) {
-          break;
-        }
-
+    if (type === 'direct') {
+      // Ignore Object methods
+      if (!(name in Object.prototype)) {
         const reportedNode = node.property;
         usedPropTypes.push({
           name,
           allNames,
           node: reportedNode,
         });
-        break;
       }
-      case 'destructuring': {
-        for (let k = 0, l = (properties || []).length; k < l; k++) {
-          if (hasSpreadOperator(context, properties[k]) || properties[k].computed) {
-            ignoreUnusedPropTypesValidation = true;
-            break;
-          }
-          const propName = ast.getKeyValue(context, properties[k]);
+    } else if (type === 'destructuring') {
+      for (let k = 0, l = (properties || []).length; k < l; k++) {
+        if (hasSpreadOperator(context, properties[k]) || properties[k].computed) {
+          ignoreUnusedPropTypesValidation = true;
+          break;
+        }
+        const propName = astUtil.getKeyValue(context, properties[k]);
 
-          if (!propName || properties[k].type !== 'Property') {
-            break;
-          }
+        if (!propName || properties[k].type !== 'Property') {
+          break;
+        }
 
-          usedPropTypes.push({
-            allNames: parentNames.concat([propName]),
-            name: propName,
-            node: properties[k],
-          });
+        usedPropTypes.push({
+          allNames: parentNames.concat([propName]),
+          name: propName,
+          node: properties[k],
+        });
 
-          if (properties[k].value.type === 'ObjectPattern') {
-            markPropTypesAsUsed(properties[k].value, parentNames.concat([propName]));
-          } else if (properties[k].value.type === 'Identifier') {
-            propVariables.set(properties[k].value.name, parentNames.concat(propName));
-          }
+        if (properties[k].value.type === 'ObjectPattern') {
+          markPropTypesAsUsed(properties[k].value, parentNames.concat([propName]));
+        } else if (properties[k].value.type === 'Identifier') {
+          propVariables.set(properties[k].value.name, parentNames.concat(propName));
         }
-        break;
       }
-      default:
-        break;
     }
 
     components.set(component ? component.node : node, {
@@ -469,10 +465,10 @@ module.exports = function usedPropTypesInstructions(context, components, utils)
 
   return {
     VariableDeclarator(node) {
-      const unwrappedInitNode = ast.unwrapTSAsExpression(node.init);
+      const unwrappedInitNode = astUtil.unwrapTSAsExpression(node.init);
 
       // let props = this.props
-      if (isThisDotProps(unwrappedInitNode) && isInClassComponent(context) && node.id.type === 'Identifier') {
+      if (isThisDotProps(unwrappedInitNode) && isInClassComponent(context, node) && node.id.type === 'Identifier') {
         propVariables.set(node.id.name, []);
       }
 
@@ -501,14 +497,14 @@ module.exports = function usedPropTypesInstructions(context, components, utils)
       // let {firstname} = props
       if (
         isCommonVariableNameForProps(unwrappedInitNode.name)
-        && (utils.getParentStatelessComponent() || isInLifeCycleMethod(node, checkAsyncSafeLifeCycles))
+        && (utils.getParentStatelessComponent(node) || isInLifeCycleMethod(node, checkAsyncSafeLifeCycles))
       ) {
         markPropTypesAsUsed(node.id);
         return;
       }
 
       // let {firstname} = this.props
-      if (isThisDotProps(unwrappedInitNode) && isInClassComponent(context)) {
+      if (isThisDotProps(unwrappedInitNode) && isInClassComponent(context, node)) {
         markPropTypesAsUsed(node.id);
         return;
       }
@@ -532,19 +528,19 @@ module.exports = function usedPropTypesInstructions(context, components, utils)
     'FunctionExpression:exit': popScope,
 
     JSXSpreadAttribute(node) {
-      const component = components.get(utils.getParentComponent());
+      const component = components.get(utils.getParentComponent(node));
       components.set(component ? component.node : node, {
         ignoreUnusedPropTypesValidation: node.argument.type !== 'ObjectExpression',
       });
     },
 
     'MemberExpression, OptionalMemberExpression'(node) {
-      if (isPropTypesUsageByMemberExpression(node, context, utils, checkAsyncSafeLifeCycles)) {
+      if (isPropTypesUsageByMemberExpression(context, node, utils, checkAsyncSafeLifeCycles)) {
         markPropTypesAsUsed(node);
         return;
       }
 
-      const propVariable = propVariables.get(ast.unwrapTSAsExpression(node.object).name);
+      const propVariable = propVariables.get(astUtil.unwrapTSAsExpression(node.object).name);
       if (propVariable) {
         markPropTypesAsUsed(node, propVariable);
       }
diff --git a/lib/util/variable.js b/lib/util/variable.js
index a93cf18b5e..a92a20930f 100644
--- a/lib/util/variable.js
+++ b/lib/util/variable.js
@@ -5,13 +5,13 @@
 
 'use strict';
 
-const toReversed = require('array.prototype.toreversed');
+const getScope = require('./eslint').getScope;
 
 /**
  * Search a particular variable in a list
  * @param {Array} variables The variables list.
  * @param {string} name The name of the variable to search.
- * @returns {Boolean} True if the variable was found, false if not.
+ * @returns {boolean} True if the variable was found, false if not.
  */
 function findVariable(variables, name) {
   return variables.some((variable) => variable.name === name);
@@ -28,39 +28,44 @@ function getVariable(variables, name) {
 }
 
 /**
- * List all variable in a given scope
- *
- * Contain a patch for babel-eslint to avoid https://github.com/babel/babel-eslint/issues/21
+ * Searches for a variable in the given scope.
  *
  * @param {Object} context The current rule context.
- * @returns {Array} The variables list
+ * @param {ASTNode} node The node to start looking from.
+ * @param {string} name The name of the variable to search.
+ * @returns {Object | undefined} Variable if the variable was found, undefined if not.
  */
-function variablesInScope(context) {
-  let scope = context.getScope();
-  let variables = scope.variables;
+function getVariableFromContext(context, node, name) {
+  let scope = getScope(context, node);
 
-  while (scope.type !== 'global') {
-    scope = scope.upper;
-    variables = scope.variables.concat(variables);
-  }
-  if (scope.childScopes.length) {
-    variables = scope.childScopes[0].variables.concat(variables);
-    if (scope.childScopes[0].childScopes.length) {
-      variables = scope.childScopes[0].childScopes[0].variables.concat(variables);
+  while (scope) {
+    let variable = getVariable(scope.variables, name);
+
+    if (!variable && scope.childScopes.length) {
+      variable = getVariable(scope.childScopes[0].variables, name);
+
+      if (!variable && scope.childScopes[0].childScopes.length) {
+        variable = getVariable(scope.childScopes[0].childScopes[0].variables, name);
+      }
     }
-  }
 
-  return toReversed(variables);
+    if (variable) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return undefined;
 }
 
 /**
  * Find a variable by name in the current scope.
  * @param {Object} context The current rule context.
+ * @param {ASTNode} node The node to check. Must be an Identifier node.
  * @param  {string} name Name of the variable to look for.
  * @returns {ASTNode|null} Return null if the variable could not be found, ASTNode otherwise.
  */
-function findVariableByName(context, name) {
-  const variable = getVariable(variablesInScope(context), name);
+function findVariableByName(context, node, name) {
+  const variable = getVariableFromContext(context, node, name);
 
   if (!variable || !variable.defs[0] || !variable.defs[0].node) {
     return null;
@@ -90,6 +95,6 @@ module.exports = {
   findVariable,
   findVariableByName,
   getVariable,
-  variablesInScope,
+  getVariableFromContext,
   getLatestVariableDefinition,
 };
diff --git a/lib/util/version.js b/lib/util/version.js
index cd8490c01f..c9dc683b7d 100644
--- a/lib/util/version.js
+++ b/lib/util/version.js
@@ -12,6 +12,8 @@ const resolve = require('resolve');
 const semver = require('semver');
 const error = require('./error');
 
+const ULTIMATE_LATEST_SEMVER = '999.999.999';
+
 let warnedForMissingVersion = false;
 
 function resetWarningFlag() {
@@ -44,6 +46,36 @@ function resolveBasedir(contextOrFilename) {
   return process.cwd();
 }
 
+function convertConfVerToSemver(confVer) {
+  const fullSemverString = /^[0-9]+\.[0-9]+$/.test(confVer) ? `${confVer}.0` : confVer;
+  return semver.coerce(fullSemverString.split('.').map((part) => Number(part)).join('.'));
+}
+
+let defaultVersion = ULTIMATE_LATEST_SEMVER;
+
+function resetDefaultVersion() {
+  defaultVersion = ULTIMATE_LATEST_SEMVER;
+}
+
+function readDefaultReactVersionFromContext(context) {
+  // .eslintrc shared settings (https://eslint.org/docs/user-guide/configuring#adding-shared-settings)
+  if (context.settings && context.settings.react && context.settings.react.defaultVersion) {
+    let settingsDefaultVersion = context.settings.react.defaultVersion;
+    if (typeof settingsDefaultVersion !== 'string') {
+      error(`Warning: default React version specified in eslint-pluigin-react-settings must be a string; got "${typeof settingsDefaultVersion}"`);
+    }
+    settingsDefaultVersion = String(settingsDefaultVersion);
+    const result = convertConfVerToSemver(settingsDefaultVersion);
+    if (result) {
+      defaultVersion = result.version;
+    } else {
+      error(`Warning: React version specified in eslint-plugin-react-settings must be a valid semver version, or "detect"; got “${settingsDefaultVersion}”. Falling back to latest version as default.`);
+    }
+  } else {
+    defaultVersion = ULTIMATE_LATEST_SEMVER;
+  }
+}
+
 // TODO, semver-major: remove context fallback
 function detectReactVersion(context) {
   if (cachedDetectedReactVersion) {
@@ -60,20 +92,22 @@ function detectReactVersion(context) {
   } catch (e) {
     if (e.code === 'MODULE_NOT_FOUND') {
       if (!warnedForMissingVersion) {
-        error('Warning: React version was set to "detect" in eslint-plugin-react settings, '
-        + 'but the "react" package is not installed. Assuming latest React version for linting.');
+        let sentence2 = 'Assuming latest React version for linting.';
+        if (defaultVersion !== ULTIMATE_LATEST_SEMVER) {
+          sentence2 = `Assuming default React version for linting: "${defaultVersion}".`;
+        }
+        error(`Warning: React version was set to "detect" in eslint-plugin-react settings, but the "react" package is not installed. ${sentence2}`);
         warnedForMissingVersion = true;
       }
-      cachedDetectedReactVersion = '999.999.999';
+      cachedDetectedReactVersion = defaultVersion;
       return cachedDetectedReactVersion;
     }
     throw e;
   }
 }
 
-const defaultVersion = '999.999.999';
-
 function getReactVersionFromContext(context) {
+  readDefaultReactVersionFromContext(context);
   let confVer = defaultVersion;
   // .eslintrc shared settings (https://eslint.org/docs/user-guide/configuring#adding-shared-settings)
   if (context.settings && context.settings.react && context.settings.react.version) {
@@ -82,17 +116,15 @@ function getReactVersionFromContext(context) {
       settingsVersion = detectReactVersion(context);
     }
     if (typeof settingsVersion !== 'string') {
-      error('Warning: React version specified in eslint-plugin-react-settings must be a string; '
-        + `got “${typeof settingsVersion}”`);
+      error(`Warning: React version specified in eslint-plugin-react-settings must be a string; got “${typeof settingsVersion}”`);
     }
     confVer = String(settingsVersion);
   } else if (!warnedForMissingVersion) {
-    error('Warning: React version not specified in eslint-plugin-react settings. '
-      + 'See https://github.com/jsx-eslint/eslint-plugin-react#configuration .');
+    error('Warning: React version not specified in eslint-plugin-react settings. See https://github.com/jsx-eslint/eslint-plugin-react#configuration .');
     warnedForMissingVersion = true;
   }
-  confVer = /^[0-9]+\.[0-9]+$/.test(confVer) ? `${confVer}.0` : confVer;
-  const result = semver.coerce(confVer.split('.').map((part) => Number(part)).join('.'));
+
+  const result = convertConfVerToSemver(confVer);
   if (!result) {
     error(`Warning: React version specified in eslint-plugin-react-settings must be a valid semver version, or "detect"; got “${confVer}”`);
   }
@@ -111,7 +143,7 @@ function detectFlowVersion(context) {
     if (e.code === 'MODULE_NOT_FOUND') {
       error('Warning: Flow version was set to "detect" in eslint-plugin-react settings, '
         + 'but the "flow-bin" package is not installed. Assuming latest Flow version for linting.');
-      return '999.999.999';
+      return ULTIMATE_LATEST_SEMVER;
     }
     throw e;
   }
@@ -133,8 +165,8 @@ function getFlowVersionFromContext(context) {
   } else {
     throw 'Could not retrieve flowVersion from settings'; // eslint-disable-line no-throw-literal
   }
-  confVer = /^[0-9]+\.[0-9]+$/.test(confVer) ? `${confVer}.0` : confVer;
-  const result = semver.coerce(confVer.split('.').map((part) => Number(part)).join('.'));
+
+  const result = convertConfVerToSemver(confVer);
   if (!result) {
     error(`Warning: Flow version specified in eslint-plugin-react-settings must be a valid semver version, or "detect"; got “${confVer}”`);
   }
@@ -158,4 +190,5 @@ module.exports = {
   testFlowVersion,
   resetWarningFlag,
   resetDetectedVersion,
+  resetDefaultVersion,
 };
diff --git a/package.json b/package.json
index febbcc6a0e..5c91dd7c08 100644
--- a/package.json
+++ b/package.json
@@ -1,11 +1,15 @@
 {
   "name": "eslint-plugin-react",
-  "version": "7.33.2",
+  "version": "7.37.5",
   "author": "Yannick Croissant <yannick.croissant+npm@gmail.com>",
   "description": "React specific linting rules for ESLint",
   "main": "index.js",
+  "types": "index.d.ts",
   "scripts": {
-    "prepack": "npmignore --auto --commentLines=autogenerated",
+    "clean-built-types": "rm -f $(find . -maxdepth 1 -type f -name '*.d.ts*') $(find lib -type f -name '*.d.ts*' ! -name 'types.d.ts')",
+    "prebuild-types": "npm run clean-built-types",
+    "build-types": "tsc -p build.tsconfig.json",
+    "prepack": "npm run build-types && npmignore --auto --commentLines=autogenerated",
     "prelint": "npm run lint:docs",
     "lint:docs": "markdownlint \"**/*.md\"",
     "postlint:docs": "npm run update:eslint-docs -- --check",
@@ -13,59 +17,66 @@
     "postlint": "npm run type-check",
     "pretest": "npm run lint",
     "test": "npm run unit-test",
-    "posttest": "aud --production",
+    "posttest": "npx npm@'>= 10.2' audit --production",
     "type-check": "tsc",
-    "unit-test": "istanbul cover node_modules/mocha/bin/_mocha tests/lib/**/*.js tests/util/**/*.js tests/index.js",
+    "unit-test": "istanbul cover node_modules/mocha/bin/_mocha tests/lib/**/*.js tests/util/**/*.js tests/index.js tests/flat-config.js",
     "update:eslint-docs": "eslint-doc-generator"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/jsx-eslint/eslint-plugin-react"
   },
+  "directories": {
+    "test": [
+      "test",
+      "tests",
+      "test-published-types"
+    ]
+  },
   "homepage": "https://github.com/jsx-eslint/eslint-plugin-react",
   "bugs": "https://github.com/jsx-eslint/eslint-plugin-react/issues",
   "dependencies": {
-    "array-includes": "^3.1.7",
-    "array.prototype.findlast": "^1.2.3",
-    "array.prototype.flatmap": "^1.3.2",
-    "array.prototype.toreversed": "^1.1.2",
-    "array.prototype.tosorted": "^1.1.2",
+    "array-includes": "^3.1.8",
+    "array.prototype.findlast": "^1.2.5",
+    "array.prototype.flatmap": "^1.3.3",
+    "array.prototype.tosorted": "^1.1.4",
     "doctrine": "^2.1.0",
-    "es-iterator-helpers": "^1.0.15",
+    "es-iterator-helpers": "^1.2.1",
     "estraverse": "^5.3.0",
+    "hasown": "^2.0.2",
     "jsx-ast-utils": "^2.4.1 || ^3.0.0",
     "minimatch": "^3.1.2",
-    "object.entries": "^1.1.7",
-    "object.fromentries": "^2.0.7",
-    "object.hasown": "^1.1.3",
-    "object.values": "^1.1.7",
+    "object.entries": "^1.1.9",
+    "object.fromentries": "^2.0.8",
+    "object.values": "^1.2.1",
     "prop-types": "^15.8.1",
     "resolve": "^2.0.0-next.5",
     "semver": "^6.3.1",
-    "string.prototype.matchall": "^4.0.10"
+    "string.prototype.matchall": "^4.0.12",
+    "string.prototype.repeat": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.23.6",
-    "@babel/eslint-parser": "^7.23.3",
-    "@babel/plugin-syntax-decorators": "^7.23.3",
-    "@babel/plugin-syntax-do-expressions": "^7.23.3",
-    "@babel/plugin-syntax-function-bind": "^7.23.3",
-    "@babel/preset-react": "^7.23.3",
+    "@babel/core": "^7.27.1",
+    "@babel/eslint-parser": "^7.27.1",
+    "@babel/plugin-syntax-decorators": "^7.27.1",
+    "@babel/plugin-syntax-do-expressions": "^7.27.1",
+    "@babel/plugin-syntax-function-bind": "^7.27.1",
+    "@babel/preset-react": "^7.27.1",
     "@types/eslint": "=7.2.10",
     "@types/estree": "0.0.52",
     "@types/node": "^4.9.5",
-    "@typescript-eslint/parser": "^2.34.0 || ^3.10.1 || ^4.0.0 || ^5.0.0",
-    "aud": "^2.0.4",
+    "@typescript-eslint/parser": "^2.34.0 || ^3.10.1 || ^4 || ^5 || ^6.20 || ^7.14.1 || 8.4 - 8.17",
     "babel-eslint": "^8 || ^9 || ^10.1.0",
-    "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8",
+    "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-doc-generator": "^1.6.1",
+    "eslint-doc-generator": "^1.7.1",
     "eslint-plugin-eslint-plugin": "^2.3.0 || ^3.5.3 || ^4.0.1 || ^5.0.5",
-    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-remote-tester": "^3.0.1",
     "eslint-remote-tester-repositories": "^1.0.1",
     "eslint-scope": "^3.7.3",
     "espree": "^3.5.4",
+    "gfm-footnotes": "^1.0.1",
     "glob": "=10.3.7",
     "istanbul": "^0.4.5",
     "jackspeak": "=2.1.1",
@@ -78,7 +89,7 @@
     "typescript-eslint-parser": "^20.1.1"
   },
   "peerDependencies": {
-    "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8"
+    "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7"
   },
   "engines": {
     "node": ">=4"
@@ -96,6 +107,7 @@
       "!lib",
       "docs/",
       "test/",
+      "test-published-types/",
       "tests/",
       "*.md",
       "*.config.js",
@@ -103,7 +115,11 @@
       ".eslintrc",
       ".editorconfig",
       "tsconfig.json",
-      ".markdownlint*"
+      "build.tsconfig.json",
+      ".markdownlint*",
+      "types",
+      "!*.d.ts",
+      "!*.d.ts.map"
     ]
   }
 }
diff --git a/test-published-types/.npmrc b/test-published-types/.npmrc
new file mode 100644
index 0000000000..43c97e719a
--- /dev/null
+++ b/test-published-types/.npmrc
@@ -0,0 +1 @@
+package-lock=false
diff --git a/test-published-types/index.js b/test-published-types/index.js
new file mode 100644
index 0000000000..010d658041
--- /dev/null
+++ b/test-published-types/index.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const react = require('eslint-plugin-react');
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  {
+    plugins: {
+      react,
+    },
+  },
+];
+
+module.exports = config;
diff --git a/test-published-types/package.json b/test-published-types/package.json
new file mode 100644
index 0000000000..80953c53ab
--- /dev/null
+++ b/test-published-types/package.json
@@ -0,0 +1,8 @@
+{
+  "name": "eslint-plugin-react-test-published-types",
+  "private": true,
+  "version": "0.0.0",
+  "dependencies": {
+    "eslint": "^9.11.1"
+  }
+}
diff --git a/test-published-types/tsconfig.json b/test-published-types/tsconfig.json
new file mode 100644
index 0000000000..2ce0bd816e
--- /dev/null
+++ b/test-published-types/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+
+  "files": [
+    "index.js"
+  ],
+
+  "compilerOptions": {
+    "lib": ["esnext"],
+    "types": ["node"],
+    "skipLibCheck": true
+  }
+}
diff --git a/tests/fixtures/flat-config/config-all/eslint.config-deep.js b/tests/fixtures/flat-config/config-all/eslint.config-deep.js
new file mode 100644
index 0000000000..e74b950f50
--- /dev/null
+++ b/tests/fixtures/flat-config/config-all/eslint.config-deep.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const reactAll = require('../../../../configs/all');
+
+module.exports = [{
+  files: ['**/*.jsx'],
+  ...reactAll,
+  languageOptions: {
+    ...reactAll.languageOptions
+  }
+}];
diff --git a/tests/fixtures/flat-config/config-all/eslint.config-root.js b/tests/fixtures/flat-config/config-all/eslint.config-root.js
new file mode 100644
index 0000000000..f5dc21e002
--- /dev/null
+++ b/tests/fixtures/flat-config/config-all/eslint.config-root.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const reactPlugin = require('../../../..');
+
+module.exports = [{
+  files: ['**/*.jsx'],
+  ...reactPlugin.configs.flat.all
+}];
diff --git a/tests/fixtures/flat-config/config-all/test.jsx b/tests/fixtures/flat-config/config-all/test.jsx
new file mode 100644
index 0000000000..66e96ef9ed
--- /dev/null
+++ b/tests/fixtures/flat-config/config-all/test.jsx
@@ -0,0 +1,3 @@
+<div foo="hello">
+    test
+</div>
diff --git a/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-deep.js b/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-deep.js
new file mode 100644
index 0000000000..053bf08dab
--- /dev/null
+++ b/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-deep.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const reactRecommended = require('../../../../configs/recommended');
+const reactJSXRuntime = require('../../../../configs/jsx-runtime');
+
+module.exports = [
+  {
+    files: ['**/*.jsx'],
+    ...reactRecommended,
+    languageOptions: {
+      ...reactRecommended.languageOptions
+    }
+  },
+  reactJSXRuntime
+];
diff --git a/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-root.js b/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-root.js
new file mode 100644
index 0000000000..f6c1c4aff5
--- /dev/null
+++ b/tests/fixtures/flat-config/config-jsx-runtime/eslint.config-root.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const reactPlugin = require('../../../..');
+
+module.exports = [
+  {
+    files: ['**/*.jsx'],
+    ...reactPlugin.configs.flat.recommended
+  },
+  reactPlugin.configs.flat['jsx-runtime']
+];
diff --git a/tests/fixtures/flat-config/config-jsx-runtime/test.jsx b/tests/fixtures/flat-config/config-jsx-runtime/test.jsx
new file mode 100644
index 0000000000..66e96ef9ed
--- /dev/null
+++ b/tests/fixtures/flat-config/config-jsx-runtime/test.jsx
@@ -0,0 +1,3 @@
+<div foo="hello">
+    test
+</div>
diff --git a/tests/fixtures/flat-config/config-recommended/eslint.config-deep.js b/tests/fixtures/flat-config/config-recommended/eslint.config-deep.js
new file mode 100644
index 0000000000..f9471c23e1
--- /dev/null
+++ b/tests/fixtures/flat-config/config-recommended/eslint.config-deep.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const reactRecommended = require('../../../../configs/recommended');
+
+module.exports = [{
+  files: ['**/*.jsx'],
+  ...reactRecommended,
+  languageOptions: {
+    ...reactRecommended.languageOptions
+  }
+}];
diff --git a/tests/fixtures/flat-config/config-recommended/eslint.config-root.js b/tests/fixtures/flat-config/config-recommended/eslint.config-root.js
new file mode 100644
index 0000000000..c1acda025b
--- /dev/null
+++ b/tests/fixtures/flat-config/config-recommended/eslint.config-root.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const reactPlugin = require('../../../..');
+
+module.exports = [{
+  files: ['**/*.jsx'],
+  ...reactPlugin.configs.flat.recommended
+}];
diff --git a/tests/fixtures/flat-config/config-recommended/test.jsx b/tests/fixtures/flat-config/config-recommended/test.jsx
new file mode 100644
index 0000000000..66e96ef9ed
--- /dev/null
+++ b/tests/fixtures/flat-config/config-recommended/test.jsx
@@ -0,0 +1,3 @@
+<div foo="hello">
+    test
+</div>
diff --git a/tests/fixtures/flat-config/plugin-and-config/eslint.config-deep.js b/tests/fixtures/flat-config/plugin-and-config/eslint.config-deep.js
new file mode 100644
index 0000000000..ea4882daa1
--- /dev/null
+++ b/tests/fixtures/flat-config/plugin-and-config/eslint.config-deep.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const react = require('../../../..');
+const reactRecommended = require('../../../../configs/recommended');
+
+module.exports = [
+  {
+    files: ['**/*.jsx'],
+    plugins: { react }
+  },
+  {
+    files: ['**/*.jsx'],
+    ...reactRecommended,
+    languageOptions: {
+      ...reactRecommended.languageOptions
+    }
+  }
+];
diff --git a/tests/fixtures/flat-config/plugin-and-config/eslint.config-root.js b/tests/fixtures/flat-config/plugin-and-config/eslint.config-root.js
new file mode 100644
index 0000000000..ad174287cf
--- /dev/null
+++ b/tests/fixtures/flat-config/plugin-and-config/eslint.config-root.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const react = require('../../../..');
+const reactRecommended = require('../../../../configs/recommended');
+
+module.exports = [
+  {
+    files: ['**/*.jsx'],
+    plugins: { react }
+  },
+  {
+    files: ['**/*.jsx'],
+    ...react.configs.flat.recommended
+  }
+];
diff --git a/tests/fixtures/flat-config/plugin-and-config/test.jsx b/tests/fixtures/flat-config/plugin-and-config/test.jsx
new file mode 100644
index 0000000000..66e96ef9ed
--- /dev/null
+++ b/tests/fixtures/flat-config/plugin-and-config/test.jsx
@@ -0,0 +1,3 @@
+<div foo="hello">
+    test
+</div>
diff --git a/tests/fixtures/flat-config/plugin/eslint.config.js b/tests/fixtures/flat-config/plugin/eslint.config.js
new file mode 100644
index 0000000000..9945a4494e
--- /dev/null
+++ b/tests/fixtures/flat-config/plugin/eslint.config.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const react = require('../../../..');
+
+module.exports = [{
+  files: ['**/*.jsx'],
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+  plugins: {
+    react,
+  },
+  rules: {
+    'react/jsx-no-literals': 1,
+  },
+}];
diff --git a/tests/fixtures/flat-config/plugin/test.jsx b/tests/fixtures/flat-config/plugin/test.jsx
new file mode 100644
index 0000000000..66e96ef9ed
--- /dev/null
+++ b/tests/fixtures/flat-config/plugin/test.jsx
@@ -0,0 +1,3 @@
+<div foo="hello">
+    test
+</div>
diff --git a/tests/flat-config.js b/tests/flat-config.js
new file mode 100644
index 0000000000..79e809657d
--- /dev/null
+++ b/tests/flat-config.js
@@ -0,0 +1,117 @@
+/* eslint-env mocha */
+
+'use strict';
+
+const semver = require('semver');
+const eslintPkg = require('eslint/package.json');
+
+if (!semver.satisfies(eslintPkg.version, '>= 8.23.0')) {
+  return;
+}
+
+const ESLint = semver.major(eslintPkg.version) < 9
+  ? require('eslint/use-at-your-own-risk').FlatESLint // eslint-disable-line import/no-unresolved -- false positive
+  : require('eslint').ESLint;
+
+const path = require('path');
+const assert = require('assert');
+
+describe('eslint-plugin-react in flat config', () => {
+  const fixturesdDir = path.resolve(__dirname, 'fixtures', 'flat-config');
+
+  it('should work when the plugin is used directly', () => {
+    const eslint = new ESLint({
+      cwd: path.resolve(fixturesdDir, 'plugin'),
+    });
+
+    return eslint.lintFiles(['test.jsx']).then((results) => {
+      const result = results[0];
+
+      assert.strictEqual(result.messages.length, 1);
+      assert.strictEqual(result.messages[0].severity, 1);
+      assert.strictEqual(result.messages[0].ruleId, 'react/jsx-no-literals');
+      assert.strictEqual(result.messages[0].messageId, 'literalNotInJSXExpression');
+    });
+  });
+
+  ['root', 'deep'].forEach((configAccess) => {
+    const overrideConfigFile = `eslint.config-${configAccess}.js`;
+
+    it(`should work when the plugin is used with "all" config (${configAccess})`, () => {
+      const eslint = new ESLint({
+        cwd: path.resolve(fixturesdDir, 'config-all'),
+        overrideConfigFile,
+      });
+
+      return eslint.lintFiles(['test.jsx']).then((results) => {
+        const result = results[0];
+
+        assert.strictEqual(result.messages.length, 3);
+        assert.strictEqual(result.messages[0].severity, 2);
+        assert.strictEqual(result.messages[0].ruleId, 'react/react-in-jsx-scope');
+        assert.strictEqual(result.messages[0].messageId, 'notInScope');
+        assert.strictEqual(result.messages[1].severity, 2);
+        assert.strictEqual(result.messages[1].ruleId, 'react/no-unknown-property');
+        assert.strictEqual(result.messages[1].messageId, 'unknownProp');
+        assert.strictEqual(result.messages[2].severity, 2);
+        assert.strictEqual(result.messages[2].ruleId, 'react/jsx-no-literals');
+        assert.strictEqual(result.messages[2].messageId, 'literalNotInJSXExpression');
+      });
+    });
+
+    it(`should work when the plugin is used with "recommended" config (${configAccess})`, () => {
+      const eslint = new ESLint({
+        cwd: path.resolve(fixturesdDir, 'config-recommended'),
+        overrideConfigFile,
+      });
+
+      return eslint.lintFiles(['test.jsx']).then((results) => {
+        const result = results[0];
+
+        assert.strictEqual(result.messages.length, 2);
+        assert.strictEqual(result.messages[0].severity, 2);
+        assert.strictEqual(result.messages[0].ruleId, 'react/react-in-jsx-scope');
+        assert.strictEqual(result.messages[0].messageId, 'notInScope');
+        assert.strictEqual(result.messages[1].severity, 2);
+        assert.strictEqual(result.messages[1].ruleId, 'react/no-unknown-property');
+        assert.strictEqual(result.messages[1].messageId, 'unknownProp');
+      });
+    });
+
+    it(`should work when the plugin is used with "recommended" and "jsx-runtime" configs (${configAccess})`, () => {
+      const eslint = new ESLint({
+        cwd: path.resolve(fixturesdDir, 'config-jsx-runtime'),
+        overrideConfigFile,
+      });
+
+      return eslint.lintFiles(['test.jsx']).then((results) => {
+        const result = results[0];
+
+        assert.strictEqual(result.messages.length, 1);
+        assert.strictEqual(result.messages[0].severity, 2);
+        assert.strictEqual(result.messages[0].ruleId, 'react/no-unknown-property');
+        assert.strictEqual(result.messages[0].messageId, 'unknownProp');
+      });
+    });
+
+    // https://github.com/jsx-eslint/eslint-plugin-react/issues/3693
+    it(`should work when the plugin is used directly and with "recommended" config (${configAccess})`, () => {
+      const eslint = new ESLint({
+        cwd: path.resolve(fixturesdDir, 'plugin-and-config'),
+        overrideConfigFile,
+      });
+
+      return eslint.lintFiles(['test.jsx']).then((results) => {
+        const result = results[0];
+
+        assert.strictEqual(result.messages.length, 2);
+        assert.strictEqual(result.messages[0].severity, 2);
+        assert.strictEqual(result.messages[0].ruleId, 'react/react-in-jsx-scope');
+        assert.strictEqual(result.messages[0].messageId, 'notInScope');
+        assert.strictEqual(result.messages[1].severity, 2);
+        assert.strictEqual(result.messages[1].ruleId, 'react/no-unknown-property');
+        assert.strictEqual(result.messages[1].messageId, 'unknownProp');
+      });
+    });
+  });
+});
diff --git a/tests/helpers/getRuleDefiner.js b/tests/helpers/getRuleDefiner.js
new file mode 100644
index 0000000000..b83c1cb59a
--- /dev/null
+++ b/tests/helpers/getRuleDefiner.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const eslint = require('eslint');
+
+// `ruleTester` is a RuleTester instance
+const getRuleDefiner = (ruleTester) => (typeof Symbol !== 'undefined' && Symbol.for && ruleTester[Symbol.for('react.RuleTester.RuleDefiner')])
+    || ruleTester.linter
+    || eslint.linter
+    || eslint.Linter;
+
+module.exports = getRuleDefiner;
diff --git a/tests/helpers/parsers.js b/tests/helpers/parsers.js
index 59205a509a..cbd6568d01 100644
--- a/tests/helpers/parsers.js
+++ b/tests/helpers/parsers.js
@@ -1,6 +1,5 @@
 'use strict';
 
-const path = require('path');
 const semver = require('semver');
 const entries = require('object.entries');
 const version = require('eslint/package.json').version;
@@ -31,13 +30,11 @@ function minEcmaVersion(features, parserOptions) {
   return Number.isFinite(result) ? result : undefined;
 }
 
-const NODE_MODULES = '../../node_modules';
-
 const parsers = {
-  BABEL_ESLINT: path.join(__dirname, NODE_MODULES, 'babel-eslint'),
-  '@BABEL_ESLINT': path.join(__dirname, NODE_MODULES, '@babel/eslint-parser'),
-  TYPESCRIPT_ESLINT: path.join(__dirname, NODE_MODULES, 'typescript-eslint-parser'),
-  '@TYPESCRIPT_ESLINT': path.join(__dirname, NODE_MODULES, '@typescript-eslint/parser'),
+  BABEL_ESLINT: require.resolve('babel-eslint'),
+  '@BABEL_ESLINT': require.resolve('@babel/eslint-parser'),
+  TYPESCRIPT_ESLINT: require.resolve('typescript-eslint-parser'),
+  '@TYPESCRIPT_ESLINT': require.resolve('@typescript-eslint/parser'),
   disableNewTS,
   skipDueToMultiErrorSorting: semver.satisfies(process.versions.node, '^8 || ^9'),
   babelParserOptions: function parserOptions(test, features) {
@@ -105,7 +102,7 @@ const parsers = {
           && {
             errors: testObject.errors.map(
               (errorObject) => {
-                const nextSuggestions = errorObject.suggestions && {
+                const nextSuggestions = errorObject.suggestions && typeof errorObject.suggestions !== 'number' && {
                   suggestions: errorObject.suggestions.map((suggestion) => Object.assign({}, suggestion, {
                     output: suggestion.output + extraComment,
                   })),
diff --git a/tests/helpers/ruleTester.js b/tests/helpers/ruleTester.js
new file mode 100644
index 0000000000..f754c13e04
--- /dev/null
+++ b/tests/helpers/ruleTester.js
@@ -0,0 +1,109 @@
+'use strict';
+
+const ESLintRuleTester = require('eslint').RuleTester;
+const semver = require('semver');
+const eslintPkg = require('eslint/package.json');
+
+// `item` can be a config passed to the constructor, or a test case object/string
+function convertToFlat(item, plugins) {
+  if (typeof item === 'string') {
+    return item;
+  }
+
+  if (typeof item !== 'object' || item === null) {
+    throw new TypeError('Invalid value for "item" option. Expected an object or a string.');
+  }
+
+  const newItem = Object.assign({}, item, { languageOptions: {} });
+
+  if (newItem.parserOptions) {
+    newItem.languageOptions.parserOptions = newItem.parserOptions;
+
+    if (newItem.parserOptions.ecmaVersion) {
+      newItem.languageOptions.ecmaVersion = newItem.parserOptions.ecmaVersion;
+    }
+
+    if (newItem.parserOptions.sourceType) {
+      newItem.languageOptions.sourceType = newItem.parserOptions.sourceType;
+    }
+
+    delete newItem.parserOptions;
+  }
+
+  if (newItem.parser) {
+    newItem.languageOptions.parser = require(newItem.parser); // eslint-disable-line global-require, import/no-dynamic-require
+    delete newItem.parser;
+  }
+
+  if (newItem.globals) {
+    newItem.languageOptions.globals = newItem.globals;
+    delete newItem.globals;
+  }
+
+  if (plugins) {
+    newItem.plugins = plugins;
+  }
+
+  return newItem;
+}
+
+let RuleTester = ESLintRuleTester;
+
+if (semver.major(eslintPkg.version) >= 9) {
+  const PLUGINS = Symbol('eslint-plugin-react plugins');
+  const RULE_DEFINER = Symbol.for('react.RuleTester.RuleDefiner');
+
+  RuleTester = class extends ESLintRuleTester {
+    constructor(config) {
+      if ((typeof config !== 'object' && typeof config !== 'undefined') || config === null) {
+        throw new TypeError('Invalid value for "config" option. Expected an object or undefined.');
+      }
+
+      const newConfig = convertToFlat(config || {});
+
+      if (!newConfig.languageOptions.ecmaVersion) {
+        newConfig.languageOptions.ecmaVersion = 5; // old default
+      }
+
+      if (!newConfig.languageOptions.sourceType) {
+        newConfig.languageOptions.sourceType = 'script'; // old default
+      }
+
+      super(newConfig);
+
+      this[RULE_DEFINER] = {
+        defineRule: (ruleId, rule) => {
+          if (!this[PLUGINS]) {
+            this[PLUGINS] = {};
+          }
+
+          const ruleIdSplit = ruleId.split('/');
+
+          if (ruleIdSplit.length !== 2) {
+            throw new Error('ruleId should be in the format: plugin-name/rule-name');
+          }
+
+          const pluginName = ruleIdSplit[0];
+          const ruleName = ruleIdSplit[1];
+
+          if (!this[PLUGINS][pluginName]) {
+            this[PLUGINS][pluginName] = { rules: {} };
+          }
+
+          this[PLUGINS][pluginName].rules[ruleName] = rule;
+        },
+      };
+    }
+
+    run(ruleName, rule, tests) {
+      const newTests = {
+        valid: tests.valid.map((test) => convertToFlat(test, this[PLUGINS])),
+        invalid: tests.invalid.map((test) => convertToFlat(test, this[PLUGINS])),
+      };
+
+      super.run(ruleName, rule, newTests);
+    }
+  };
+}
+
+module.exports = RuleTester;
diff --git a/tests/index.js b/tests/index.js
index 258429517b..3539f48136 100644
--- a/tests/index.js
+++ b/tests/index.js
@@ -10,6 +10,7 @@ const plugin = require('..');
 const index = require('../lib/rules');
 
 const ruleFiles = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
+  .filter((f) => f.endsWith('.js'))
   .map((f) => path.basename(f, '.js'))
   .filter((f) => f !== 'index');
 
@@ -34,7 +35,7 @@ describe('all rule files should be exported by the plugin', () => {
 describe('deprecated rules', () => {
   it('marks all deprecated rules as deprecated', () => {
     ruleFiles.forEach((ruleName) => {
-      const inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
+      const inDeprecatedRules = !!plugin.deprecatedRules[ruleName];
       const isDeprecated = plugin.rules[ruleName].meta.deprecated;
       if (inDeprecatedRules) {
         assert(isDeprecated, `${ruleName} metadata should mark it as deprecated`);
@@ -77,7 +78,7 @@ describe('configurations', () => {
     });
 
     ruleFiles.forEach((ruleName) => {
-      const inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
+      const inDeprecatedRules = !!plugin.deprecatedRules[ruleName];
       const inConfig = typeof plugin.configs[configName].rules[`react/${ruleName}`] !== 'undefined';
       assert(inDeprecatedRules ^ inConfig); // eslint-disable-line no-bitwise
     });
@@ -91,7 +92,7 @@ describe('configurations', () => {
       assert.ok(ruleName.startsWith('react/'));
       assert.equal(plugin.configs[configName].rules[ruleName], 0);
 
-      const inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
+      const inDeprecatedRules = !!plugin.deprecatedRules[ruleName];
       const inConfig = typeof plugin.configs[configName].rules[ruleName] !== 'undefined';
       assert(inDeprecatedRules ^ inConfig); // eslint-disable-line no-bitwise
     });
diff --git a/tests/lib/rules/boolean-prop-naming.js b/tests/lib/rules/boolean-prop-naming.js
index 2e2be01e5d..84a50c9187 100644
--- a/tests/lib/rules/boolean-prop-naming.js
+++ b/tests/lib/rules/boolean-prop-naming.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/boolean-prop-naming');
 
 const parsers = require('../../helpers/parsers');
@@ -415,7 +415,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
       features: ['ts'],
-      errors: [],
     },
     {
       code: `
@@ -426,7 +425,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
     },
     {
       code: `
@@ -439,7 +437,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '(is|has)[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
     },
     {
       code: `
@@ -451,7 +448,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
     },
     {
       code: `
@@ -465,7 +461,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
     },
     {
       code: `
@@ -479,7 +474,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
     },
     {
       code: `
@@ -495,7 +489,29 @@ ruleTester.run('boolean-prop-naming', rule, {
       `,
       options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
       features: ['types'],
-      errors: [],
+    },
+    {
+      code: `
+        export const DataRow = (props: { label: string; value: string; } & React.HTMLAttributes<HTMLDivElement>) => {
+            const { label, value, ...otherProps } = props;
+            return (
+                <div {...otherProps}>
+                    <span>{label}</span>
+                    <span>{value}</span>
+                </div>
+            );
+        };
+      `,
+      options: [{ rule: '(^(is|has|should|without)[A-Z]([A-Za-z0-9]?)+|disabled|required|checked|defaultChecked)' }],
+      features: ['types'],
+    },
+    {
+      code: `
+        // Strip @jsx comments, see https://github.com/microsoft/fluentui/issues/29126
+        const resultCode = result.code
+          .replace('/** @jsxRuntime automatic */', '')
+          .replace('/** @jsxImportSource @fluentui/react-jsx-runtime */', '');
+      `,
     },
   ]),
 
@@ -1106,12 +1122,16 @@ ruleTester.run('boolean-prop-naming', rule, {
           enabled: boolean
         }
         const HelloNew = (props: TestConstType) => { return <div /> };
-    `,
+      `,
       options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
       features: ['ts', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^is[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1121,12 +1141,16 @@ ruleTester.run('boolean-prop-naming', rule, {
           enabled: boolean
         }
         const HelloNew = (props: TestFNType) => { return <div /> };
-    `,
+      `,
       options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
       features: ['ts', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^is[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1142,7 +1166,11 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^is[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1160,7 +1188,11 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1176,7 +1208,11 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^is[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1194,7 +1230,11 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1212,7 +1252,11 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
@@ -1232,10 +1276,110 @@ ruleTester.run('boolean-prop-naming', rule, {
       features: ['types', 'no-ts-old'],
       errors: [
         {
-          message: 'Prop name (enabled) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'lol',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
         },
+      ],
+    },
+    {
+      code: `
+        interface TestFNType {
+          enabled: boolean
+        }
+        const HelloNew = (props: TestFNType) => { return <div /> };
+      `,
+      options: [{ rule: '^is[A-Z]([A-Za-z0-9]?)+' }],
+      features: ['ts', 'no-babel'],
+      errors: [
         {
-          message: 'Prop name (lol) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)',
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^is[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+      ],
+    },
+    {
+      code: 'const Hello = (props: {enabled:boolean}) => <div />;',
+      options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
+      features: ['ts', 'no-babel'],
+      errors: [
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+        type Props = {
+          enabled: boolean
+        };
+        type BaseProps = {
+          semi: boolean
+        };
+
+        const Hello = (props: Props & BaseProps) => <div />;
+      `,
+      options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
+      features: ['ts', 'no-babel', 'no-ts-old'],
+      errors: [
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'semi',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+      ],
+    },
+    {
+      code: `
+        type Props = {
+          enabled: boolean
+        };
+
+        const Hello = (props: Props & {
+          semi: boolean
+        }) => <div />;
+      `,
+      options: [{ rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+' }],
+      features: ['ts', 'no-babel', 'no-ts-old'],
+      errors: [
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'enabled',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
+        },
+        {
+          messageId: 'patternMismatch',
+          data: {
+            propName: 'semi',
+            pattern: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
+          },
         },
       ],
     },
diff --git a/tests/lib/rules/button-has-type.js b/tests/lib/rules/button-has-type.js
index fb16f28aa5..e5d6be6d5e 100644
--- a/tests/lib/rules/button-has-type.js
+++ b/tests/lib/rules/button-has-type.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/button-has-type');
 
 const parsers = require('../../helpers/parsers');
@@ -304,6 +304,12 @@ ruleTester.run('button-has-type', rule, {
         },
       ],
     },
+    {
+      code: 'React.createElement("button", {...extraProps})',
+      errors: [
+        { messageId: 'missingType' },
+      ],
+    },
     {
       code: 'Foo.createElement("button")',
       errors: [
diff --git a/tests/lib/rules/checked-requires-onchange-or-readonly.js b/tests/lib/rules/checked-requires-onchange-or-readonly.js
new file mode 100644
index 0000000000..1f8bb551db
--- /dev/null
+++ b/tests/lib/rules/checked-requires-onchange-or-readonly.js
@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Enforce the use of the 'onChange' or 'readonly' attribute when 'checked' is used'
+ * @author Jaesoekjjang
+ */
+
+'use strict';
+
+const RuleTester = require('../../helpers/ruleTester');
+const rule = require('../../../lib/rules/checked-requires-onchange-or-readonly');
+
+const parsers = require('../../helpers/parsers');
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+ruleTester.run('checked-requires-onchange-or-readonly', rule, {
+  valid: parsers.all([
+    '<input type="checkbox" />',
+    '<input type="checkbox" onChange={noop} />',
+    '<input type="checkbox" readOnly />',
+    '<input type="checkbox" checked onChange={noop} />',
+    '<input type="checkbox" checked={true} onChange={noop} />',
+    '<input type="checkbox" checked={false} onChange={noop} />',
+    '<input type="checkbox" checked readOnly />',
+    '<input type="checkbox" checked={true} readOnly />',
+    '<input type="checkbox" checked={false} readOnly />',
+    '<input type="checkbox" defaultChecked />',
+    "React.createElement('input')",
+    "React.createElement('input', { checked: true, onChange: noop })",
+    "React.createElement('input', { checked: false, onChange: noop })",
+    "React.createElement('input', { checked: true, readOnly: true })",
+    "React.createElement('input', { checked: true, onChange: noop, readOnly: true })",
+    "React.createElement('input', { checked: foo, onChange: noop, readOnly: true })",
+    {
+      code: '<input type="checkbox" checked />',
+      options: [{ ignoreMissingProperties: true }],
+    },
+    {
+      code: '<input type="checkbox" checked={true} />',
+      options: [{ ignoreMissingProperties: true }],
+    },
+    {
+      code: '<input type="checkbox" onChange={noop} checked defaultChecked />',
+      options: [{ ignoreExclusiveCheckedAttribute: true }],
+    },
+    {
+      code: '<input type="checkbox" onChange={noop} checked={true} defaultChecked />',
+      options: [{ ignoreExclusiveCheckedAttribute: true }],
+    },
+    {
+      code: '<input type="checkbox" onChange={noop} checked defaultChecked />',
+      options: [{ ignoreMissingProperties: true, ignoreExclusiveCheckedAttribute: true }],
+    },
+    '<span/>',
+    "React.createElement('span')",
+    '(()=>{})()',
+  ]),
+  invalid: parsers.all([
+    {
+      code: '<input type="radio" checked />',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="radio" checked={true} />',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="checkbox" checked />',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="checkbox" checked={true} />',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="checkbox" checked={condition ? true : false} />',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="checkbox" checked defaultChecked />',
+      errors: [
+        { messageId: 'exclusiveCheckedAttribute' },
+        { messageId: 'missingProperty' },
+      ],
+    },
+    {
+      code: 'React.createElement("input", { checked: false })',
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: 'React.createElement("input", { checked: true, defaultChecked: true })',
+      errors: [
+        { messageId: 'exclusiveCheckedAttribute' },
+        { messageId: 'missingProperty' },
+      ],
+    },
+    {
+      code: '<input type="checkbox" checked defaultChecked />',
+      options: [{ ignoreMissingProperties: true }],
+      errors: [{ messageId: 'exclusiveCheckedAttribute' }],
+    },
+    {
+      code: '<input type="checkbox" checked defaultChecked />',
+      options: [{ ignoreExclusiveCheckedAttribute: true }],
+      errors: [{ messageId: 'missingProperty' }],
+    },
+    {
+      code: '<input type="checkbox" checked defaultChecked />',
+      options: [{ ignoreMissingProperties: false, ignoreExclusiveCheckedAttribute: false }],
+      errors: [
+        { messageId: 'exclusiveCheckedAttribute' },
+        { messageId: 'missingProperty' },
+      ],
+    },
+  ]),
+});
diff --git a/tests/lib/rules/default-props-match-prop-types.js b/tests/lib/rules/default-props-match-prop-types.js
index 9759fad635..fdc86dc357 100644
--- a/tests/lib/rules/default-props-match-prop-types.js
+++ b/tests/lib/rules/default-props-match-prop-types.js
@@ -10,7 +10,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/default-props-match-prop-types');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/destructuring-assignment.js b/tests/lib/rules/destructuring-assignment.js
index 18c88e1cfe..13d0c10ac7 100644
--- a/tests/lib/rules/destructuring-assignment.js
+++ b/tests/lib/rules/destructuring-assignment.js
@@ -4,9 +4,9 @@
 
 'use strict';
 
-const RuleTester = require('eslint').RuleTester;
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/destructuring-assignment');
 
 const parsers = require('../../helpers/parsers');
@@ -374,18 +374,6 @@ ruleTester.run('destructuring-assignment', rule, {
       code: `
         import { useContext } from 'react';
 
-        const MyComponent = (props) => {
-          const {foo} = useContext(aContext);
-          return <div>{foo}</div>
-        };
-      `,
-      options: ['always'],
-      settings: { react: { version: '16.9.0' } },
-    },
-    {
-      code: `
-        import { useContext } from 'react';
-
         const MyComponent = (props) => {
           const foo = useContext(aContext);
           return <div>{foo.test}</div>
@@ -884,6 +872,69 @@ ${'            '}
         `,
         features: ['ts', 'no-babel'],
       },
-    ] : []
+    ] : [],
+    {
+      code: `
+        type Props = { text: string };
+        export const MyComponent: React.FC<Props> = (props) => {
+          type MyType = typeof props.text;
+          return <div>{props.text as MyType}</div>;
+        };
+      `,
+      options: ['always', { destructureInSignature: 'always' }],
+      features: ['types', 'no-babel'],
+      errors: [
+        {
+          messageId: 'useDestructAssignment',
+          type: 'TSQualifiedName',
+          data: { type: 'props' },
+        },
+        {
+          messageId: 'useDestructAssignment',
+          type: 'MemberExpression',
+          data: { type: 'props' },
+        },
+      ],
+    },
+    {
+      code: `
+        type Props = { text: string };
+        export const MyOtherComponent: React.FC<Props> = (props) => {
+          const { text } = props;
+          type MyType = typeof props.text;
+          return <div>{text as MyType}</div>;
+        };
+      `,
+      options: ['always', { destructureInSignature: 'always' }],
+      features: ['types', 'no-babel'],
+      errors: [
+        {
+          messageId: 'useDestructAssignment',
+          type: 'TSQualifiedName',
+          data: { type: 'props' },
+        },
+      ],
+    },
+    {
+      code: `
+        function C(props: Props) {
+          void props.a
+          typeof props.b
+          return <div />
+        }
+      `,
+      options: ['always'],
+      features: ['types'],
+      errors: [
+        {
+          messageId: 'useDestructAssignment',
+          data: { type: 'props' },
+        },
+        {
+          messageId: 'useDestructAssignment',
+          data: { type: 'props' },
+        },
+      ],
+    }
   )),
 });
diff --git a/tests/lib/rules/display-name.js b/tests/lib/rules/display-name.js
index da73207a5c..18fd1ca83c 100644
--- a/tests/lib/rules/display-name.js
+++ b/tests/lib/rules/display-name.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/display-name');
 
 const parsers = require('../../helpers/parsers');
@@ -369,39 +369,6 @@ ruleTester.run('display-name', rule, {
         };
       `,
     },
-    {
-      code: `
-        import React, {createElement} from "react";
-        const SomeComponent = (props) => {
-          const {foo, bar} = props;
-          return someComponentFactory({
-            onClick: () => foo(bar("x"))
-          });
-        };
-      `,
-    },
-    {
-      code: `
-        import React, {Component} from "react";
-        function someDecorator(ComposedComponent) {
-          return class MyDecorator extends Component {
-            render() {return <ComposedComponent {...this.props} />;}
-          };
-        }
-        module.exports = someDecorator;
-      `,
-    },
-    {
-      code: `
-        import React, {Component} from "react";
-        function someDecorator(ComposedComponent) {
-          return class MyDecorator extends Component {
-            render() {return <ComposedComponent {...this.props} />;}
-          };
-        }
-        module.exports = someDecorator;
-      `,
-    },
     {
       code: `
         const element = (
diff --git a/tests/lib/rules/forbid-component-props.js b/tests/lib/rules/forbid-component-props.js
index 5f1aa7e68d..566860d139 100644
--- a/tests/lib/rules/forbid-component-props.js
+++ b/tests/lib/rules/forbid-component-props.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/forbid-component-props');
 
 const parsers = require('../../helpers/parsers');
@@ -166,21 +166,6 @@ ruleTester.run('forbid-component-props', rule, {
         },
       ],
     },
-    {
-      code: `
-        const item = (<Foo className="foo" />);
-      `,
-      options: [
-        {
-          forbid: [
-            {
-              propName: 'className',
-              disallowedFor: ['ReactModal'],
-            },
-          ],
-        },
-      ],
-    },
     {
       code: `
         <fbt:param name="Total number of files" number={true} />
@@ -248,6 +233,95 @@ ruleTester.run('forbid-component-props', rule, {
         },
       ],
     },
+    {
+      code: `
+        const MyComponent = () => (
+          <div aria-label="welcome" />
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propNamePattern: '**-**',
+              allowedFor: ['div'],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = (
+          <Root>
+            <SomeIcon className="size-lg" />
+            <AnotherIcon className="size-lg" />
+            <SomeSvg className="size-lg" />
+            <UICard className="size-lg" />
+            <UIButton className="size-lg" />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              allowedForPatterns: ['*Icon', '*Svg', 'UI*'],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = (
+          <Root>
+            <SomeIcon className="size-lg" />
+            <AnotherIcon className="size-lg" />
+            <SomeSvg className="size-lg" />
+            <UICard className="size-lg" />
+            <UIButton className="size-lg" />
+            <ButtonLegacy className="size-lg" />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              allowedFor: ['ButtonLegacy'],
+              allowedForPatterns: ['*Icon', '*Svg', 'UI*'],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = (
+          <Root>
+            <SomeIcon className="size-lg" />
+            <AnotherIcon className="size-lg" />
+            <SomeSvg className="size-lg" />
+            <UICard className="size-lg" />
+            <UIButton className="size-lg" />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              disallowedFor: ['Modal'],
+              disallowedForPatterns: ['*Legacy', 'Shared*'],
+            },
+          ],
+        },
+      ],
+    },
   ]),
 
   invalid: parsers.all([
@@ -568,5 +642,235 @@ ruleTester.run('forbid-component-props', rule, {
         },
       ],
     },
+    {
+      code: `
+        const MyComponent = () => (
+          <Foo kebab-case-prop={123} />
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propNamePattern: '**-**',
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          messageId: 'propIsForbidden',
+          data: { prop: 'kebab-case-prop' },
+          line: 3,
+          column: 16,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const MyComponent = () => (
+          <Foo kebab-case-prop={123} />
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propNamePattern: '**-**',
+              message: 'Avoid using kebab-case',
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          message: 'Avoid using kebab-case',
+          line: 3,
+          column: 16,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const MyComponent = () => (
+          <div>
+            <div aria-label="Hello Akul" />
+            <Foo kebab-case-prop={123} />
+          </div>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propNamePattern: '**-**',
+              allowedFor: ['div'],
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          messageId: 'propIsForbidden',
+          data: { prop: 'kebab-case-prop' },
+          line: 5,
+          column: 18,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const MyComponent = () => (
+          <div>
+            <div aria-label="Hello Akul" />
+            <h1 data-id="my-heading" />
+            <Foo kebab-case-prop={123} />
+          </div>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propNamePattern: '**-**',
+              disallowedFor: ['Foo'],
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          messageId: 'propIsForbidden',
+          data: { prop: 'kebab-case-prop' },
+          line: 6,
+          column: 18,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = () => (
+          <Root>
+            <SomeIcon className="size-lg" />
+            <SomeSvg className="size-lg" />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              message: 'className available only for icons',
+              allowedForPatterns: ['*Icon'],
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          message: 'className available only for icons',
+          line: 5,
+          column: 22,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = () => (
+          <Root>
+            <UICard style={{backgroundColor: black}}/>
+            <SomeIcon className="size-lg" />
+            <SomeSvg className="size-lg" style={{fill: currentColor}} />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              message: 'className available only for icons',
+              allowedForPatterns: ['*Icon'],
+            },
+            {
+              propName: 'style',
+              message: 'style available only for SVGs',
+              allowedForPatterns: ['*Svg'],
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          message: 'style available only for SVGs',
+          line: 4,
+          column: 21,
+          type: 'JSXAttribute',
+        },
+        {
+          message: 'className available only for icons',
+          line: 6,
+          column: 22,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
+    {
+      code: `
+        const rootElement = (
+          <Root>
+            <SomeIcon className="size-lg" />
+            <AnotherIcon className="size-lg" />
+            <SomeSvg className="size-lg" />
+            <UICard className="size-lg" />
+            <ButtonLegacy className="size-lg" />
+          </Root>
+        );
+      `,
+      options: [
+        {
+          forbid: [
+            {
+              propName: 'className',
+              disallowedFor: ['SomeSvg'],
+              disallowedForPatterns: ['UI*', '*Icon'],
+              message: 'Avoid using className for SomeSvg and components that match the `UI*` and `*Icon` patterns',
+            },
+          ],
+        },
+      ],
+      errors: [
+        {
+          message: 'Avoid using className for SomeSvg and components that match the `UI*` and `*Icon` patterns',
+          line: 4,
+          column: 23,
+          type: 'JSXAttribute',
+        },
+        {
+          message: 'Avoid using className for SomeSvg and components that match the `UI*` and `*Icon` patterns',
+          line: 5,
+          column: 26,
+          type: 'JSXAttribute',
+        },
+        {
+          message: 'Avoid using className for SomeSvg and components that match the `UI*` and `*Icon` patterns',
+          line: 6,
+          column: 22,
+          type: 'JSXAttribute',
+        },
+        {
+          message: 'Avoid using className for SomeSvg and components that match the `UI*` and `*Icon` patterns',
+          line: 7,
+          column: 21,
+          type: 'JSXAttribute',
+        },
+      ],
+    },
   ]),
 });
diff --git a/tests/lib/rules/forbid-dom-props.js b/tests/lib/rules/forbid-dom-props.js
index 157e4950be..a11d39fe00 100644
--- a/tests/lib/rules/forbid-dom-props.js
+++ b/tests/lib/rules/forbid-dom-props.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/forbid-dom-props');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/forbid-elements.js b/tests/lib/rules/forbid-elements.js
index 927f7bd97f..d0c179b131 100644
--- a/tests/lib/rules/forbid-elements.js
+++ b/tests/lib/rules/forbid-elements.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/forbid-elements');
 
 const parsers = require('../../helpers/parsers');
@@ -82,6 +82,9 @@ ruleTester.run('forbid-elements', rule, {
       code: 'React.createElement(1)',
       options: [{ forbid: ['button'] }],
     },
+    {
+      code: 'React.createElement()',
+    },
   ]),
 
   invalid: parsers.all([
diff --git a/tests/lib/rules/forbid-foreign-prop-types.js b/tests/lib/rules/forbid-foreign-prop-types.js
index c7ee08d80f..000d7eb4a9 100644
--- a/tests/lib/rules/forbid-foreign-prop-types.js
+++ b/tests/lib/rules/forbid-foreign-prop-types.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/forbid-foreign-prop-types');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/forbid-prop-types.js b/tests/lib/rules/forbid-prop-types.js
index ad7ca97c66..67ac1b47f6 100644
--- a/tests/lib/rules/forbid-prop-types.js
+++ b/tests/lib/rules/forbid-prop-types.js
@@ -10,7 +10,7 @@
 
 const babelEslintVersion = require('babel-eslint/package.json').version;
 const semver = require('semver');
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/forbid-prop-types');
 
diff --git a/tests/lib/rules/forward-ref-uses-ref.js b/tests/lib/rules/forward-ref-uses-ref.js
new file mode 100644
index 0000000000..906baaca1e
--- /dev/null
+++ b/tests/lib/rules/forward-ref-uses-ref.js
@@ -0,0 +1,265 @@
+/**
+ * @fileoverview Require all forwardRef components include a ref parameter
+ * @author Tiger Oakes
+ */
+
+'use strict';
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const RuleTester = require('../../helpers/ruleTester');
+const rule = require('../../../lib/rules/forward-ref-uses-ref');
+const parsers = require('../../helpers/parsers');
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+  },
+});
+
+ruleTester.run('forward-ref-uses-ref', rule, {
+  valid: parsers.all([
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef((props, ref) => {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef((props, ref) => null);
+      `,
+    },
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef(function (props, ref) {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef(function Component(props, ref) {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef((props, ref) => {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef((props, ref) => null);
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef(function (props, ref) {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef(function Component(props, ref) {
+          return null;
+        });
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        function Component(props) {
+          return null;
+        };
+      `,
+    },
+    {
+      code: `
+        import * as React from 'react'
+        (props) => null;
+      `,
+    },
+  ]),
+  invalid: parsers.all([
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef((props) => {
+          return null;
+        });
+      `,
+      errors: [
+        {
+          message: 'forwardRef is used with this component but no ref parameter is set',
+          suggestions: [
+            {
+              messageId: 'addRefParameter',
+              output: `
+        import { forwardRef } from 'react'
+        forwardRef((props, ref) => {
+          return null;
+        });
+      `,
+            },
+            {
+              messageId: 'removeForwardRef',
+              output: `
+        import { forwardRef } from 'react'
+        (props) => {
+          return null;
+        };
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        import { forwardRef } from 'react'
+        forwardRef(props => {
+          return null;
+        });
+      `,
+      errors: [
+        {
+          message: 'forwardRef is used with this component but no ref parameter is set',
+          suggestions: [
+            {
+              messageId: 'addRefParameter',
+              output: `
+        import { forwardRef } from 'react'
+        forwardRef((props, ref) => {
+          return null;
+        });
+      `,
+            },
+            {
+              messageId: 'removeForwardRef',
+              output: `
+        import { forwardRef } from 'react'
+        props => {
+          return null;
+        };
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef((props) => null);
+      `,
+      errors: [
+        {
+          message: 'forwardRef is used with this component but no ref parameter is set',
+          suggestions: [
+            {
+              messageId: 'addRefParameter',
+              output: `
+        import * as React from 'react'
+        React.forwardRef((props, ref) => null);
+      `,
+            },
+            {
+              messageId: 'removeForwardRef',
+              output: `
+        import * as React from 'react'
+        (props) => null;
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        import { forwardRef } from 'react'
+        const Component = forwardRef(function (props) {
+          return null;
+        });
+      `,
+      errors: [
+        {
+          message: 'forwardRef is used with this component but no ref parameter is set',
+          suggestions: [
+            {
+              messageId: 'addRefParameter',
+              output: `
+        import { forwardRef } from 'react'
+        const Component = forwardRef(function (props, ref) {
+          return null;
+        });
+      `,
+            },
+            {
+              messageId: 'removeForwardRef',
+              output: `
+        import { forwardRef } from 'react'
+        const Component = function (props) {
+          return null;
+        };
+      `,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: `
+        import * as React from 'react'
+        React.forwardRef(function Component(props) {
+          return null;
+        });
+      `,
+      errors: [
+        {
+          message: 'forwardRef is used with this component but no ref parameter is set',
+          suggestions: [
+            {
+              messageId: 'addRefParameter',
+              output: `
+        import * as React from 'react'
+        React.forwardRef(function Component(props, ref) {
+          return null;
+        });
+      `,
+            },
+            {
+              messageId: 'removeForwardRef',
+              output: `
+        import * as React from 'react'
+        function Component(props) {
+          return null;
+        };
+      `,
+            },
+          ],
+        },
+      ],
+    },
+  ]),
+});
diff --git a/tests/lib/rules/function-component-definition.js b/tests/lib/rules/function-component-definition.js
index 8f0e96ee17..dda2a10ec8 100644
--- a/tests/lib/rules/function-component-definition.js
+++ b/tests/lib/rules/function-component-definition.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/function-component-definition');
 
 const parserOptions = {
@@ -807,11 +807,7 @@ ruleTester.run('function-component-definition', rule, {
           return <div/>;
         }
       `,
-      output: `
-        var Hello: React.FC<Test> = function(props) {
-          return <div/>;
-        }
-      `,
+      output: null,
       options: [{ namedComponents: 'function-declaration' }],
       errors: [{ messageId: 'function-declaration' }],
       features: ['types'],
@@ -822,11 +818,7 @@ ruleTester.run('function-component-definition', rule, {
           return <div/>;
         };
       `,
-      output: `
-        var Hello: React.FC<Test> = (props) => {
-          return <div/>;
-        };
-      `,
+      output: null,
       options: [{ namedComponents: 'function-declaration' }],
       errors: [{ messageId: 'function-declaration' }],
       features: ['types'],
@@ -852,11 +844,7 @@ ruleTester.run('function-component-definition', rule, {
           return <div/>;
         }
       `,
-      output: `
-        function Hello<Test>(props: Test) {
-          return <div/>;
-        }
-      `,
+      output: null,
       options: [{ namedComponents: 'arrow-function' }],
       errors: [{ messageId: 'arrow-function' }],
       features: ['types'],
@@ -963,13 +951,7 @@ ruleTester.run('function-component-definition', rule, {
           }
         }
       `,
-      output: `
-        function wrap(Component) {
-          return function<Test>(props) {
-            return <div><Component {...props}/></div>
-          }
-        }
-      `,
+      output: null,
       errors: [{ messageId: 'arrow-function' }],
       options: [{ unnamedComponents: 'arrow-function' }],
       features: ['types'],
diff --git a/tests/lib/rules/hook-use-state.js b/tests/lib/rules/hook-use-state.js
index 1cadaf8a1a..031ad6ce55 100644
--- a/tests/lib/rules/hook-use-state.js
+++ b/tests/lib/rules/hook-use-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/hook-use-state');
 const parsers = require('../../helpers/parsers');
 
@@ -311,6 +311,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         function useColor() {
@@ -334,7 +335,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
-              desc: 'Replace useState call with useMemo',
+              messageId: 'suggestMemo',
               output: `
         import { useState, useMemo } from 'react'
         function useColor(initialColor) {
@@ -343,7 +344,7 @@ const tests = {
       `,
             },
             {
-              desc: 'Destructure useState call into value + setter pair',
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         function useColor(initialColor) {
@@ -366,7 +367,7 @@ const tests = {
         message: 'useState call is not destructured into value + setter pair',
         suggestions: [
           {
-            desc: 'Replace useState call with useMemo',
+            messageId: 'suggestMemo',
             output: `
         import { useState, useMemo as useMemoAlternative } from 'react'
         function useColor(initialColor) {
@@ -375,7 +376,7 @@ const tests = {
       `,
           },
           {
-            desc: 'Destructure useState call into value + setter pair',
+            messageId: 'suggestPair',
             output: `
         import { useState, useMemo as useMemoAlternative } from 'react'
         function useColor(initialColor) {
@@ -398,7 +399,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
-              desc: 'Replace useState call with useMemo',
+              messageId: 'suggestMemo',
               output: `
         import React from 'react'
         function useColor(initialColor) {
@@ -407,7 +408,7 @@ const tests = {
       `,
             },
             {
-              desc: 'Destructure useState call into value + setter pair',
+              messageId: 'suggestPair',
               output: `
         import React from 'react'
         function useColor(initialColor) {
@@ -432,6 +433,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         function useColor() {
@@ -457,6 +459,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         function useColor() {
@@ -486,6 +489,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         const [color, setColor] = useState()
@@ -505,6 +509,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         const [color, setColor] = useState()
@@ -561,6 +566,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         const [color, setColor] = useState<string>()
@@ -584,6 +590,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import { useState } from 'react'
         function useColor() {
@@ -610,6 +617,7 @@ const tests = {
           message: 'useState call is not destructured into value + setter pair',
           suggestions: [
             {
+              messageId: 'suggestPair',
               output: `
         import React from 'react'
         function useColor() {
diff --git a/tests/lib/rules/iframe-missing-sandbox.js b/tests/lib/rules/iframe-missing-sandbox.js
index 82c4304e14..628eea3adf 100644
--- a/tests/lib/rules/iframe-missing-sandbox.js
+++ b/tests/lib/rules/iframe-missing-sandbox.js
@@ -8,7 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/iframe-missing-sandbox');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-boolean-value.js b/tests/lib/rules/jsx-boolean-value.js
index 678b492740..95be0709f4 100644
--- a/tests/lib/rules/jsx-boolean-value.js
+++ b/tests/lib/rules/jsx-boolean-value.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-boolean-value');
 
 const parsers = require('../../helpers/parsers');
@@ -52,6 +52,10 @@ ruleTester.run('jsx-boolean-value', rule, {
       code: '<App />;',
       options: ['never', { assumeUndefinedIsFalse: true }],
     },
+    {
+      code: '<App foo={false} />;',
+      options: ['never', { assumeUndefinedIsFalse: false }],
+    },
     {
       code: '<App foo={false} />;',
       options: ['never', { assumeUndefinedIsFalse: true, always: ['foo'] }],
@@ -63,7 +67,10 @@ ruleTester.run('jsx-boolean-value', rule, {
       output: '<App foo />;',
       options: ['never'],
       errors: [
-        { messageId: 'omitBoolean_noMessage' },
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'foo' },
+        },
       ],
     },
     {
@@ -73,11 +80,11 @@ ruleTester.run('jsx-boolean-value', rule, {
       errors: [
         {
           messageId: 'omitBoolean',
-          data: { exceptionsMessage: ' for the following props: `foo`, `bar`' },
+          data: { propName: 'foo' },
         },
         {
           messageId: 'omitBoolean',
-          data: { exceptionsMessage: ' for the following props: `foo`, `bar`' },
+          data: { propName: 'bar' },
         },
       ],
     },
@@ -85,14 +92,20 @@ ruleTester.run('jsx-boolean-value', rule, {
       code: '<App foo={true} />;',
       output: '<App foo />;',
       errors: [
-        { messageId: 'omitBoolean_noMessage' },
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'foo' },
+        },
       ],
     },
     {
       code: '<App foo = {true} />;',
       output: '<App foo />;',
       errors: [
-        { messageId: 'omitBoolean_noMessage' },
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'foo' },
+        },
       ],
     },
     {
@@ -100,7 +113,10 @@ ruleTester.run('jsx-boolean-value', rule, {
       output: '<App foo={true} />;',
       options: ['always'],
       errors: [
-        { messageId: 'setBoolean_noMessage' },
+        {
+          messageId: 'setBoolean',
+          data: { propName: 'foo' },
+        },
       ],
     },
     {
@@ -110,11 +126,11 @@ ruleTester.run('jsx-boolean-value', rule, {
       errors: [
         {
           messageId: 'setBoolean',
-          data: { exceptionsMessage: ' for the following props: `foo`, `bar`' },
+          data: { propName: 'foo' },
         },
         {
           messageId: 'setBoolean',
-          data: { exceptionsMessage: ' for the following props: `foo`, `bar`' },
+          data: { propName: 'bar' },
         },
       ],
     },
@@ -123,8 +139,29 @@ ruleTester.run('jsx-boolean-value', rule, {
       output: '<App   />;',
       options: ['never', { assumeUndefinedIsFalse: true }],
       errors: [
-        { messageId: 'omitPropAndBoolean_noMessage' },
-        { messageId: 'omitPropAndBoolean_noMessage' },
+        {
+          messageId: 'omitPropAndBoolean',
+          data: { propName: 'foo' },
+        },
+        {
+          messageId: 'omitPropAndBoolean',
+          data: { propName: 'bak' },
+        },
+      ],
+    },
+    {
+      code: '<App foo={true} bak={false} />;',
+      output: '<App foo  />;',
+      options: ['never', { assumeUndefinedIsFalse: true }],
+      errors: [
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'foo' },
+        },
+        {
+          messageId: 'omitPropAndBoolean',
+          data: { propName: 'bak' },
+        },
       ],
     },
     {
@@ -137,11 +174,30 @@ ruleTester.run('jsx-boolean-value', rule, {
       errors: [
         {
           messageId: 'omitPropAndBoolean',
-          data: { exceptionsMessage: ' for the following props: `baz`, `bak`' },
+          data: { propName: 'baz' },
         },
         {
           messageId: 'omitPropAndBoolean',
-          data: { exceptionsMessage: ' for the following props: `baz`, `bak`' },
+          data: { propName: 'bak' },
+        },
+      ],
+    },
+    {
+      code: '<App foo={true} bar={true} baz />;',
+      output: '<App foo bar baz={true} />;',
+      options: ['always', { never: ['foo', 'bar'] }],
+      errors: [
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'foo' },
+        },
+        {
+          messageId: 'omitBoolean',
+          data: { propName: 'bar' },
+        },
+        {
+          messageId: 'setBoolean',
+          data: { propName: 'baz' },
         },
       ],
     },
diff --git a/tests/lib/rules/jsx-child-element-spacing.js b/tests/lib/rules/jsx-child-element-spacing.js
index 92e001acee..4788b7db49 100644
--- a/tests/lib/rules/jsx-child-element-spacing.js
+++ b/tests/lib/rules/jsx-child-element-spacing.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-child-element-spacing');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-closing-bracket-location.js b/tests/lib/rules/jsx-closing-bracket-location.js
index c23ec1943a..0e20084785 100644
--- a/tests/lib/rules/jsx-closing-bracket-location.js
+++ b/tests/lib/rules/jsx-closing-bracket-location.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-closing-bracket-location');
 
 const parsers = require('../../helpers/parsers');
@@ -419,7 +419,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_TAG },
+          data: {
+            location: MESSAGE_AFTER_TAG,
+            details: '',
+          },
         },
       ],
     },
@@ -434,7 +437,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -449,7 +455,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -536,7 +545,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -578,7 +590,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -644,7 +659,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -686,7 +704,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -1098,7 +1119,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_TAG },
+          data: {
+            location: MESSAGE_AFTER_TAG,
+            details: '',
+          },
         },
       ],
     },
@@ -1216,7 +1240,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -1258,7 +1285,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -1324,7 +1354,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -1366,7 +1399,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_PROPS },
+          data: {
+            location: MESSAGE_AFTER_PROPS,
+            details: '',
+          },
         },
       ],
     },
@@ -1778,7 +1814,10 @@ ruleTester.run('jsx-closing-bracket-location', rule, {
       errors: [
         {
           messageId: 'bracketLocation',
-          data: { location: MESSAGE_AFTER_TAG },
+          data: {
+            location: MESSAGE_AFTER_TAG,
+            details: '',
+          },
         },
       ],
     },
diff --git a/tests/lib/rules/jsx-closing-tag-location.js b/tests/lib/rules/jsx-closing-tag-location.js
index 4f1b24205f..23b71cdca5 100644
--- a/tests/lib/rules/jsx-closing-tag-location.js
+++ b/tests/lib/rules/jsx-closing-tag-location.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-closing-tag-location');
 
 const parsers = require('../../helpers/parsers');
@@ -29,12 +29,79 @@ const parserOptions = {
 const ruleTester = new RuleTester({ parserOptions });
 ruleTester.run('jsx-closing-tag-location', rule, {
   valid: parsers.all([
+    {
+      code: `
+        const foo = () => {
+          return <App>
+       bar</App>
+        }
+      `,
+      options: [{ location: 'line-aligned' }],
+    },
+    {
+      code: `
+        const foo = () => {
+          return <App>
+              bar</App>
+        }
+      `,
+    },
+    {
+      code: `
+        const foo = () => {
+          return <App>
+              bar
+          </App>
+        }
+      `,
+      options: ['line-aligned'],
+    },
+    {
+      code: `
+        const foo = <App>
+              bar
+        </App>
+      `,
+      options: ['line-aligned'],
+    },
+    {
+      code: `
+        const x = <App>
+              foo
+                  </App>
+      `,
+    },
+    {
+      code: `
+        const foo =
+          <App>
+              bar
+          </App>
+      `,
+      options: ['line-aligned'],
+    },
+    {
+      code: `
+        const foo =
+          <App>
+              bar
+          </App>
+      `,
+    },
+    {
+      code: `
+        <App>
+          foo
+        </App>
+      `,
+    },
     {
       code: `
         <App>
           foo
         </App>
       `,
+      options: ['line-aligned'],
     },
     {
       code: `
@@ -110,5 +177,36 @@ ruleTester.run('jsx-closing-tag-location', rule, {
       `,
       errors: [{ messageId: 'onOwnLine' }],
     },
+    {
+      code: `
+        const x = () => {
+          return <App>
+              foo</App>
+        }
+      `,
+      output: `
+        const x = () => {
+          return <App>
+              foo
+          </App>
+        }
+      `,
+      errors: [{ messageId: 'onOwnLine' }],
+      options: ['line-aligned'],
+    },
+    {
+      code: `
+        const x = <App>
+              foo
+                  </App>
+      `,
+      output: `
+        const x = <App>
+              foo
+        </App>
+      `,
+      errors: [{ messageId: 'alignWithOpening' }],
+      options: ['line-aligned'],
+    },
   ]),
 });
diff --git a/tests/lib/rules/jsx-curly-brace-presence.js b/tests/lib/rules/jsx-curly-brace-presence.js
index 616ffba21d..59d756737b 100755
--- a/tests/lib/rules/jsx-curly-brace-presence.js
+++ b/tests/lib/rules/jsx-curly-brace-presence.js
@@ -11,9 +11,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-curly-brace-presence');
 
 const parsers = require('../../helpers/parsers');
@@ -483,14 +483,14 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
   invalid: parsers.all([].concat(
     {
       code: '<App prop={`foo`} />',
-      output: '<App prop="foo" />',
       options: [{ props: 'never' }],
+      output: '<App prop="foo" />',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
       code: '<App>{<myApp></myApp>}</App>',
-      output: '<App><myApp></myApp></App>',
       options: [{ children: 'never' }],
+      output: '<App><myApp></myApp></App>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
@@ -500,21 +500,21 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
     },
     {
       code: '<App prop={`foo`}>foo</App>',
-      output: '<App prop="foo">foo</App>',
       options: [{ props: 'never' }],
+      output: '<App prop="foo">foo</App>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
       code: '<App>{`foo`}</App>',
-      output: '<App>foo</App>',
       options: [{ children: 'never' }],
+      output: '<App>foo</App>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
       code: '<>{`foo`}</>',
-      output: '<>foo</>',
-      features: ['fragment'],
       options: [{ children: 'never' }],
+      features: ['fragment'],
+      output: '<>foo</>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
@@ -529,14 +529,14 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
     },
     {
       code: `<MyComponent>{'foo'}</MyComponent>`,
-      output: '<MyComponent>foo</MyComponent>',
       options: [{ children: 'never' }],
+      output: '<MyComponent>foo</MyComponent>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
       code: `<MyComponent prop={'bar'}>foo</MyComponent>`,
-      output: '<MyComponent prop="bar">foo</MyComponent>',
       options: [{ props: 'never' }],
+      output: '<MyComponent prop="bar">foo</MyComponent>',
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
@@ -545,12 +545,12 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           {'%'}
         </MyComponent>
       `,
+      options: [{ children: 'never' }],
       output: `
         <MyComponent>
           %
         </MyComponent>
       `,
-      options: [{ children: 'never' }],
       errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
@@ -563,6 +563,7 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           {'baz'}
         </MyComponent>
       `,
+      options: [{ children: 'never' }],
       output: `
         <MyComponent>
           foo
@@ -572,7 +573,6 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           baz
         </MyComponent>
       `,
-      options: [{ children: 'never' }],
       errors: [
         { messageId: 'unnecessaryCurly' },
         { messageId: 'unnecessaryCurly' },
@@ -600,8 +600,8 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           {'some-complicated-exp'}
         </MyComponent>
       `,
-      features: ['no-default', 'no-ts-new', 'no-babel-new'], // TODO: FIXME: remove no-default and no-ts-new and fix
       options: [{ children: 'never' }],
+      features: ['no-default', 'no-ts-new', 'no-babel-new'], // TODO: FIXME: remove no-default and no-ts-new and fix
       errors: [
         { messageId: 'unnecessaryCurly', line: 3 },
         { messageId: 'unnecessaryCurly', line: 5 },
@@ -619,6 +619,9 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           {'some-complicated-exp'}
         </MyComponent>
       `,
+      options: [{ children: 'never' }],
+      parser: parsers['@BABEL_ESLINT'],
+      parserOptions: parsers.babelParserOptions({}, new Set()),
       output: `
         <MyComponent>
           foo
@@ -629,9 +632,6 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           some-complicated-exp
         </MyComponent>
       `,
-      parser: parsers['@BABEL_ESLINT'],
-      parserOptions: parsers.babelParserOptions({}, new Set()),
-      options: [{ children: 'never' }],
       errors: [
         { messageId: 'unnecessaryCurly', line: 3 },
         { messageId: 'unnecessaryCurly', line: 5 },
@@ -641,149 +641,147 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
     } : [],
     {
       code: `<MyComponent prop='bar'>foo</MyComponent>`,
-      output: '<MyComponent prop={"bar"}>foo</MyComponent>',
       options: [{ props: 'always' }],
+      output: '<MyComponent prop={"bar"}>foo</MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent prop="foo 'bar'">foo</MyComponent>`,
-      output: `<MyComponent prop={"foo 'bar'"}>foo</MyComponent>`,
       options: [{ props: 'always' }],
+      output: `<MyComponent prop={"foo 'bar'"}>foo</MyComponent>`,
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent prop='foo "bar"'>foo</MyComponent>`,
-      output: `<MyComponent prop={"foo \\"bar\\""}>foo</MyComponent>`,
-      options: [{ props: 'always' }],
-      errors: [{ messageId: 'missingCurly' }],
-    },
-    {
-      code: `<MyComponent prop="foo 'bar'">foo</MyComponent>`,
-      output: `<MyComponent prop={"foo 'bar'"}>foo</MyComponent>`,
       options: [{ props: 'always' }],
+      output: `<MyComponent prop={"foo \\"bar\\""}>foo</MyComponent>`,
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo bar </MyComponent>',
-      output: `<MyComponent>{"foo bar "}</MyComponent>`,
       options: [{ children: 'always' }],
+      output: `<MyComponent>{"foo bar "}</MyComponent>`,
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent prop="foo 'bar' \\n ">foo</MyComponent>`,
-      output: `<MyComponent prop={"foo 'bar' \\\\n "}>foo</MyComponent>`,
       options: [{ props: 'always' }],
+      output: `<MyComponent prop={"foo 'bar' \\\\n "}>foo</MyComponent>`,
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo bar \\r </MyComponent>',
-      output: '<MyComponent>{"foo bar \\\\r "}</MyComponent>',
       options: [{ children: 'always' }],
+      output: '<MyComponent>{"foo bar \\\\r "}</MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent>foo bar 'foo'</MyComponent>`,
-      output: `<MyComponent>{"foo bar 'foo'"}</MyComponent>`,
       options: [{ children: 'always' }],
+      output: `<MyComponent>{"foo bar 'foo'"}</MyComponent>`,
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo bar "foo"</MyComponent>',
-      output: '<MyComponent>{"foo bar \\"foo\\""}</MyComponent>',
       options: [{ children: 'always' }],
+      output: '<MyComponent>{"foo bar \\"foo\\""}</MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo bar <App/></MyComponent>',
-      output: '<MyComponent>{"foo bar "}<App/></MyComponent>',
       options: [{ children: 'always' }],
+      output: '<MyComponent>{"foo bar "}<App/></MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo \\n bar</MyComponent>',
-      output: '<MyComponent>{"foo \\\\n bar"}</MyComponent>',
       options: [{ children: 'always' }],
+      output: '<MyComponent>{"foo \\\\n bar"}</MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<MyComponent>foo \\u1234 bar</MyComponent>',
-      output: '<MyComponent>{"foo \\\\u1234 bar"}</MyComponent>',
       options: [{ children: 'always' }],
+      output: '<MyComponent>{"foo \\\\u1234 bar"}</MyComponent>',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent prop='foo \\u1234 bar' />`,
-      output: '<MyComponent prop={"foo \\\\u1234 bar"} />',
       options: [{ props: 'always' }],
+      output: '<MyComponent prop={"foo \\\\u1234 bar"} />',
       errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<MyComponent prop={'bar'}>{'foo'}</MyComponent>`,
-      output: '<MyComponent prop="bar">foo</MyComponent>',
       options: ['never'],
+      output: '<MyComponent prop="bar">foo</MyComponent>',
       errors: [
-        { messageId: 'unnecessaryCurly' }, { messageId: 'unnecessaryCurly' },
+        { messageId: 'unnecessaryCurly' },
+        { messageId: 'unnecessaryCurly' },
       ],
     },
     {
       code: `<MyComponent prop='bar'>foo</MyComponent>`,
-      output: '<MyComponent prop={"bar"}>{"foo"}</MyComponent>',
       options: ['always'],
+      output: '<MyComponent prop={"bar"}>{"foo"}</MyComponent>',
       errors: [
-        { messageId: 'missingCurly' }, { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
       ],
     },
     {
       code: `<App prop={'foo'} attr={" foo "} />`,
+      options: [{ props: 'never' }],
       output: '<App prop="foo" attr=" foo " />',
       errors: [
-        { messageId: 'unnecessaryCurly' }, { messageId: 'unnecessaryCurly' },
+        { messageId: 'unnecessaryCurly' },
+        { messageId: 'unnecessaryCurly' },
       ],
-      options: [{ props: 'never' }],
     },
     {
       code: `<App prop='foo' attr="bar" />`,
+      options: [{ props: 'always' }],
       output: '<App prop={"foo"} attr={"bar"} />',
       errors: [
-        { messageId: 'missingCurly' }, { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
       ],
-      options: [{ props: 'always' }],
     },
     {
       code: `<App prop='foo' attr={"bar"} />`,
+      options: [{ props: 'always' }],
       output: `<App prop={"foo"} attr={"bar"} />`,
       errors: [{ messageId: 'missingCurly' }],
-      options: [{ props: 'always' }],
     },
     {
       code: `<App prop={'foo'} attr='bar' />`,
+      options: [{ props: 'always' }],
       output: `<App prop={'foo'} attr={"bar"} />`,
       errors: [{ messageId: 'missingCurly' }],
-      options: [{ props: 'always' }],
     },
     {
       code: `<App prop='foo &middot; bar' />`,
-      errors: [{ messageId: 'missingCurly' }],
       options: [{ props: 'always' }],
       output: `<App prop={"foo &middot; bar"} />`,
+      errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: '<App>foo &middot; bar</App>',
-      errors: [{ messageId: 'missingCurly' }],
       options: [{ children: 'always' }],
       output: '<App>{"foo &middot; bar"}</App>',
+      errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<App>{'foo "bar"'}</App>`,
+      options: [{ children: 'never' }],
       output: `<App>foo "bar"</App>`,
       errors: [{ messageId: 'unnecessaryCurly' }],
-      options: [{ children: 'never' }],
     },
     {
       code: `<App>{"foo 'bar'"}</App>`,
+      options: [{ children: 'never' }],
       output: `<App>foo 'bar'</App>`,
       errors: [{ messageId: 'unnecessaryCurly' }],
-      options: [{ children: 'never' }],
     },
     {
       code: `
@@ -797,9 +795,6 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
                  d${'      '}
         </App>
       `,
-      errors: [
-        { messageId: 'missingCurly' }, { messageId: 'missingCurly' },
-      ],
       options: ['always'],
       output: `
         <App prop="${'    '}
@@ -812,6 +807,10 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
                  {"d      "}
         </App>
       `,
+      errors: [
+        { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
+      ],
     },
     {
       code: `
@@ -825,9 +824,6 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
                  d${'      '}
         </App>
       `,
-      errors: [
-        { messageId: 'missingCurly' }, { messageId: 'missingCurly' },
-      ],
       options: ['always'],
       output: `
         <App prop='${'    '}
@@ -840,6 +836,10 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
                  {"d      "}
         </App>
       `,
+      errors: [
+        { messageId: 'missingCurly' },
+        { messageId: 'missingCurly' },
+      ],
     },
     {
       code: `
@@ -854,6 +854,7 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           </span>
         </App>
       `,
+      options: [{ children: 'always' }],
       output: `
         <App>
           {"foo bar"}
@@ -873,7 +874,6 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
         { messageId: 'missingCurly' },
         { messageId: 'missingCurly' },
       ],
-      options: [{ children: 'always' }],
     },
     {
       code: `
@@ -883,6 +883,7 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
           &nbsp;
         </App>
       `,
+      options: [{ children: 'always' }],
       output: `
         <App>
           &lt;{"Component"}&gt;
@@ -891,55 +892,68 @@ ruleTester.run('jsx-curly-brace-presence', rule, {
         </App>
       `,
       errors: [{ messageId: 'missingCurly' }],
-      options: [{ children: 'always' }],
     },
     {
       code: `
         <Box mb={'1rem'} />
       `,
+      options: [{ props: 'never' }],
       output: `
         <Box mb="1rem" />
       `,
-      errors: [
-        { messageId: 'unnecessaryCurly' },
-      ],
-      options: [{ props: 'never' }],
+      errors: [{ messageId: 'unnecessaryCurly' }],
     },
     {
       code: `
         <Box mb={'1rem {}'} />
       `,
+      options: ['never'],
       output: `
         <Box mb="1rem {}" />
       `,
       errors: [{ messageId: 'unnecessaryCurly' }],
-      options: ['never'],
     },
     {
       code: '<MyComponent prop={"{ style: true }"}>bar</MyComponent>',
+      options: ['never'],
       output: '<MyComponent prop="{ style: true }">bar</MyComponent>',
       errors: [{ messageId: 'unnecessaryCurly' }],
-      options: ['never'],
     },
     {
       code: '<MyComponent prop={"< style: true >"}>foo</MyComponent>',
+      options: ['never'],
       output: '<MyComponent prop="< style: true >">foo</MyComponent>',
       errors: [{ messageId: 'unnecessaryCurly' }],
-      options: ['never'],
     },
     {
       code: `<App horror=<div /> />`,
-      output: `<App horror={<div />} />`,
-      errors: [{ messageId: 'missingCurly' }],
       options: [{ props: 'always', children: 'always', propElementValues: 'always' }],
       features: ['no-ts'],
+      output: `<App horror={<div />} />`,
+      errors: [{ messageId: 'missingCurly' }],
     },
     {
       code: `<App horror={<div />} />`,
+      options: [{ props: 'never', children: 'never', propElementValues: 'never' }],
+      features: ['no-ts'],
       output: `<App horror=<div /> />`,
       errors: [{ messageId: 'unnecessaryCurly' }],
+    },
+    {
+      code: `<Foo bar={"'"} />`,
       options: [{ props: 'never', children: 'never', propElementValues: 'never' }],
-      features: ['no-ts'],
+      output: `<Foo bar="'" />`,
+      errors: [{ messageId: 'unnecessaryCurly' }],
+    },
+    {
+      code: `
+        <Foo help={'The maximum time range for searches. (i.e. "P30D" for 30 days, "PT24H" for 24 hours)'} />
+      `,
+      options: ['never'],
+      output: `
+        <Foo help='The maximum time range for searches. (i.e. "P30D" for 30 days, "PT24H" for 24 hours)' />
+      `,
+      errors: [{ messageId: 'unnecessaryCurly' }],
     }
   )),
 });
diff --git a/tests/lib/rules/jsx-curly-newline.js b/tests/lib/rules/jsx-curly-newline.js
index 894e21834f..8b0a82b26a 100644
--- a/tests/lib/rules/jsx-curly-newline.js
+++ b/tests/lib/rules/jsx-curly-newline.js
@@ -8,7 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-curly-newline');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-curly-spacing.js b/tests/lib/rules/jsx-curly-spacing.js
index 3eec41b99a..f7a778bbe0 100644
--- a/tests/lib/rules/jsx-curly-spacing.js
+++ b/tests/lib/rules/jsx-curly-spacing.js
@@ -10,7 +10,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-curly-spacing');
 
 const parsers = require('../../helpers/parsers');
@@ -756,14 +756,6 @@ ruleTester.run('jsx-curly-spacing', rule, {
       `,
       options: ['always'],
     },
-    {
-      code: `
-        <App {
-        ...bar
-        } />;
-      `,
-      options: ['always'],
-    },
     {
       code: `
         <App {
diff --git a/tests/lib/rules/jsx-equals-spacing.js b/tests/lib/rules/jsx-equals-spacing.js
index a4e3db95ea..843372d3cd 100644
--- a/tests/lib/rules/jsx-equals-spacing.js
+++ b/tests/lib/rules/jsx-equals-spacing.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-equals-spacing');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-filename-extension.js b/tests/lib/rules/jsx-filename-extension.js
index e924d2ede4..adf3c78e79 100644
--- a/tests/lib/rules/jsx-filename-extension.js
+++ b/tests/lib/rules/jsx-filename-extension.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-filename-extension');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-first-prop-new-line.js b/tests/lib/rules/jsx-first-prop-new-line.js
index 3cf963caf8..b53c9ee05b 100644
--- a/tests/lib/rules/jsx-first-prop-new-line.js
+++ b/tests/lib/rules/jsx-first-prop-new-line.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-first-prop-new-line');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-fragments.js b/tests/lib/rules/jsx-fragments.js
index 1ee6fb3fa2..6ed7302a47 100644
--- a/tests/lib/rules/jsx-fragments.js
+++ b/tests/lib/rules/jsx-fragments.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-fragments');
 
 const parsers = require('../../helpers/parsers');
@@ -142,7 +142,7 @@ ruleTester.run('jsx-fragments', rule, {
     },
     {
       code: '<><Foo /></>',
-      output: '<><Foo /></>', // should get '<Act.Frag><Foo /></Act.Frag>', but the old TS parser lacks opening/closing Fragment info
+      output: null, // should get '<Act.Frag><Foo /></Act.Frag>', but the old TS parser lacks opening/closing Fragment info
       features: ['fragment', 'no-babel', 'ts', 'no-ts-new'],
       options: ['element'],
       settings,
diff --git a/tests/lib/rules/jsx-handler-names.js b/tests/lib/rules/jsx-handler-names.js
index 3aba45beba..3ad3378abf 100644
--- a/tests/lib/rules/jsx-handler-names.js
+++ b/tests/lib/rules/jsx-handler-names.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-handler-names');
 
 const parsers = require('../../helpers/parsers');
@@ -181,6 +181,24 @@ ruleTester.run('jsx-handler-names', rule, {
       code: '<TestComponent someProp={props.onChange} />',
       options: [{ eventHandlerPropPrefix: false }],
     },
+    {
+      code: '<ComponentFromOtherLibraryBar customPropNameBar={handleSomething} />;',
+      options: [{ checkLocalVariables: true, ignoreComponentNames: ['ComponentFromOtherLibraryBar'] }],
+    },
+    {
+      code: `
+        function App() {
+          return (
+            <div>
+              <MyLibInput customPropNameBar={handleSomething} />;
+              <MyLibCheckbox customPropNameBar={handleSomething} />;
+              <MyLibButtom customPropNameBar={handleSomething} />;
+            </div>
+          )
+        }
+      `,
+      options: [{ checkLocalVariables: true, ignoreComponentNames: ['MyLib*'] }],
+    },
   ]),
 
   invalid: parsers.all([
@@ -265,7 +283,7 @@ ruleTester.run('jsx-handler-names', rule, {
       ],
     },
     {
-      code: '<TestComponent only={this.handleChange} />',
+      code: '<TestComponent2 only={this.handleChange} />',
       errors: [
         {
           messageId: 'badPropKey',
@@ -369,5 +387,33 @@ ruleTester.run('jsx-handler-names', rule, {
         },
       ],
     },
+    {
+      code: `
+        function App() {
+          return (
+            <div>
+              <MyLibInput customPropNameBar={handleInput} />;
+              <MyLibCheckbox customPropNameBar={handleCheckbox} />;
+              <MyLibButtom customPropNameBar={handleButton} />;
+            </div>
+          )
+        }
+      `,
+      options: [{ checkLocalVariables: true, ignoreComponentNames: ['MyLibrary*'] }],
+      errors: [
+        {
+          messageId: 'badPropKey',
+          data: { propValue: 'handleInput', handlerPropPrefix: 'on' },
+        },
+        {
+          messageId: 'badPropKey',
+          data: { propValue: 'handleCheckbox', handlerPropPrefix: 'on' },
+        },
+        {
+          messageId: 'badPropKey',
+          data: { propValue: 'handleButton', handlerPropPrefix: 'on' },
+        },
+      ],
+    },
   ]),
 });
diff --git a/tests/lib/rules/jsx-indent-props.js b/tests/lib/rules/jsx-indent-props.js
index a826fbd094..2e4a618b81 100644
--- a/tests/lib/rules/jsx-indent-props.js
+++ b/tests/lib/rules/jsx-indent-props.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-indent-props');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-indent.js b/tests/lib/rules/jsx-indent.js
index 9483279f68..95e98ac2da 100644
--- a/tests/lib/rules/jsx-indent.js
+++ b/tests/lib/rules/jsx-indent.js
@@ -9,9 +9,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
 const semver = require('semver');
 const eslintVersion = require('eslint/package.json').version;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-indent');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-key.js b/tests/lib/rules/jsx-key.js
index 17109e4215..2c5ba7a5c1 100644
--- a/tests/lib/rules/jsx-key.js
+++ b/tests/lib/rules/jsx-key.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-key');
 
 const parsers = require('../../helpers/parsers');
@@ -409,5 +409,20 @@ ruleTester.run('jsx-key', rule, {
         { messageId: 'missingIterKey' },
       ],
     },
+    {
+      code: `
+        const TestCase = () => {
+          const list = [1, 2, 3, 4, 5];
+
+          return (
+            <div>
+              {list.map(x => <div {...spread} key={x} />)}
+            </div>
+          );
+        };
+      `,
+      options: [{ checkKeyMustBeforeSpread: true }],
+      errors: [{ messageId: 'keyBeforeSpread' }],
+    },
   ]),
 });
diff --git a/tests/lib/rules/jsx-max-depth.js b/tests/lib/rules/jsx-max-depth.js
index 2aefb31e95..9b83b02cde 100644
--- a/tests/lib/rules/jsx-max-depth.js
+++ b/tests/lib/rules/jsx-max-depth.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-max-depth');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-max-props-per-line.js b/tests/lib/rules/jsx-max-props-per-line.js
index 706388bc32..88ac920493 100644
--- a/tests/lib/rules/jsx-max-props-per-line.js
+++ b/tests/lib/rules/jsx-max-props-per-line.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-max-props-per-line');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-newline.js b/tests/lib/rules/jsx-newline.js
index 201656f81e..1090dff063 100644
--- a/tests/lib/rules/jsx-newline.js
+++ b/tests/lib/rules/jsx-newline.js
@@ -10,7 +10,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-newline');
 const parsers = require('../../helpers/parsers');
 
diff --git a/tests/lib/rules/jsx-no-bind.js b/tests/lib/rules/jsx-no-bind.js
index 100c6feb21..71e3e63717 100644
--- a/tests/lib/rules/jsx-no-bind.js
+++ b/tests/lib/rules/jsx-no-bind.js
@@ -10,7 +10,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-bind');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-no-comment-textnodes.js b/tests/lib/rules/jsx-no-comment-textnodes.js
index cdb611453b..e3742eab60 100644
--- a/tests/lib/rules/jsx-no-comment-textnodes.js
+++ b/tests/lib/rules/jsx-no-comment-textnodes.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-comment-textnodes');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-no-constructed-context-values.js b/tests/lib/rules/jsx-no-constructed-context-values.js
index c8c9dee995..0fe74dab5e 100644
--- a/tests/lib/rules/jsx-no-constructed-context-values.js
+++ b/tests/lib/rules/jsx-no-constructed-context-values.js
@@ -10,7 +10,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-constructed-context-values');
 
 const parsers = require('../../helpers/parsers');
@@ -147,6 +147,44 @@ ruleTester.run('react-no-constructed-context-values', rule, {
         );
       `,
     },
+    {
+      code: `
+        // Passes because the context is not a provider
+        function Component() {
+          return <MyContext.Consumer value={{ foo: 'bar' }} />;
+        }
+      `,
+    },
+    {
+      code: `
+        import React from 'react';
+
+        const MyContext = React.createContext();
+        const Component = () => <MyContext value={props}></MyContext>;
+      `,
+    },
+    {
+      code: `
+        import React from 'react';
+
+        const MyContext = React.createContext();
+        const Component = () => <MyContext value={100}></MyContext>;
+      `,
+    },
+    {
+      code: `
+        const SomeContext = createContext();
+        const Component = () => <SomeContext value="Some string"></SomeContext>;
+      `,
+    },
+    {
+      code: `
+        // Passes because MyContext is not a variable declarator
+        function Component({ MyContext }) {
+          return <MyContext value={{ foo: "bar" }} />;
+        }
+      `,
+    },
   ]),
   invalid: parsers.all([
     {
@@ -468,5 +506,63 @@ ruleTester.run('react-no-constructed-context-values', rule, {
         },
       ],
     },
+    {
+      // Invalid because function declaration creates a new identity
+      code: `
+        import React from 'react';
+
+        const Context = React.createContext();
+        function Component() {
+          function foo() {};
+          return (<Context value={foo}></Context>)
+        }
+      `,
+      errors: [
+        {
+          messageId: 'withIdentifierMsgFunc',
+          data: {
+            variableName: 'foo',
+            type: 'function declaration',
+            nodeLine: '6',
+            usageLine: '7',
+          },
+        },
+      ],
+    },
+    {
+      // Invalid because the object value will create a new identity
+      code: `
+        const MyContext = createContext();
+        function Component() { const foo = {}; return (<MyContext value={foo}></MyContext>) }
+      `,
+      errors: [
+        {
+          messageId: 'withIdentifierMsg',
+          data: {
+            variableName: 'foo',
+            type: 'object',
+            nodeLine: '3',
+            usageLine: '3',
+          },
+        },
+      ],
+    },
+    {
+      // Invalid because inline object construction will create a new identity
+      code: `
+        const MyContext = createContext();
+        function Component() { return (<MyContext value={{foo: "bar"}}></MyContext>); }
+      `,
+      errors: [
+        {
+          messageId: 'defaultMsg',
+          data: {
+            type: 'object',
+            nodeLine: '3',
+            usageLine: '3',
+          },
+        },
+      ],
+    },
   ]),
 });
diff --git a/tests/lib/rules/jsx-no-duplicate-props.js b/tests/lib/rules/jsx-no-duplicate-props.js
index 81f2508d92..f85287a854 100644
--- a/tests/lib/rules/jsx-no-duplicate-props.js
+++ b/tests/lib/rules/jsx-no-duplicate-props.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-duplicate-props');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-no-leaked-render.js b/tests/lib/rules/jsx-no-leaked-render.js
index 969c93635c..071ecd68ab 100644
--- a/tests/lib/rules/jsx-no-leaked-render.js
+++ b/tests/lib/rules/jsx-no-leaked-render.js
@@ -11,7 +11,7 @@
 
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-leaked-render');
 
 const parsers = require('../../helpers/parsers');
@@ -126,14 +126,6 @@ ruleTester.run('jsx-no-leaked-render', rule, {
       `,
       options: [{ validStrategies: ['coerce', 'ternary'] }],
     },
-    {
-      code: `
-        const Component = ({ elements, count }) => {
-          return <div>{!!count && <List elements={elements}/>}</div>
-        }
-      `,
-      options: [{ validStrategies: ['coerce'] }],
-    },
 
     // Fixes for:
     // - https://github.com/jsx-eslint/eslint-plugin-react/issues/3292
@@ -195,6 +187,24 @@ ruleTester.run('jsx-no-leaked-render', rule, {
       `,
       options: [{ validStrategies: ['coerce'] }],
     },
+    {
+      code: `
+        const isOpen = true;
+        const Component = () => {
+          return <Popover open={isOpen && items.length > 0} />
+        }
+      `,
+      options: [{ validStrategies: ['coerce'] }],
+    },
+    {
+      code: `
+        const isOpen = false;
+        const Component = () => {
+          return <Popover open={isOpen && items.length > 0} />
+        }
+      `,
+      options: [{ validStrategies: ['coerce'] }],
+    },
   ]) || [],
 
   invalid: parsers.all([].concat(
@@ -733,6 +743,24 @@ ruleTester.run('jsx-no-leaked-render', rule, {
         }
       `,
     },
+    {
+      code: `
+        const Component = ({ connection, hasError, hasErrorUpdate}) => {
+          return <div>{connection && (hasError || hasErrorUpdate)}</div>
+        }
+      `,
+      options: [{ validStrategies: ['coerce'] }],
+      errors: [{
+        message: 'Potential leaked value that might cause unintentionally rendered values or rendering crashes',
+        line: 3,
+        column: 24,
+      }],
+      output: `
+        const Component = ({ connection, hasError, hasErrorUpdate}) => {
+          return <div>{!!connection && (hasError || hasErrorUpdate)}</div>
+        }
+      `,
+    },
 
     // cases: ternary isn't valid if strategy is only "coerce"
     {
@@ -954,6 +982,26 @@ ruleTester.run('jsx-no-leaked-render', rule, {
         line: 5,
         column: 16,
       }],
-    } : []
+    } : [],
+    {
+      code: `
+        const isOpen = 0;
+        const Component = () => {
+          return <Popover open={isOpen && items.length > 0} />
+        }
+      `,
+      output: `
+        const isOpen = 0;
+        const Component = () => {
+          return <Popover open={!!isOpen && items.length > 0} />
+        }
+      `,
+      options: [{ validStrategies: ['coerce'] }],
+      errors: [{
+        message: 'Potential leaked value that might cause unintentionally rendered values or rendering crashes',
+        line: 4,
+        column: 33,
+      }],
+    }
   )),
 });
diff --git a/tests/lib/rules/jsx-no-literals.js b/tests/lib/rules/jsx-no-literals.js
index d547178d8b..d1f6135f82 100644
--- a/tests/lib/rules/jsx-no-literals.js
+++ b/tests/lib/rules/jsx-no-literals.js
@@ -10,7 +10,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-literals');
 
 const parsers = require('../../helpers/parsers');
@@ -296,6 +296,186 @@ ruleTester.run('jsx-no-literals', rule, {
       `,
       options: [{ noStrings: true, allowedStrings: ['&mdash;', '—'] }],
     },
+    {
+      code: `
+        <T>foo</T>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        <T>foo <div>bar</div></T>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        <T>foo <div>{'bar'}</div></T>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true, applyToNestedElements: false } } }],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>{2}</T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true } } }],
+    },
+    {
+      code: `
+        <T>{2}<div>{2}</div></T>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true } } }],
+    },
+    {
+      code: `
+        <T>{2}<div>{'foo'}</div></T>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true, applyToNestedElements: false } } }],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>foo</T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { allowedStrings: ['foo'] } } }],
+    },
+    {
+      code: `
+        <T>foo<div>foo</div></T>
+      `,
+      options: [{ elementOverrides: { T: { allowedStrings: ['foo'] } } }],
+    },
+    {
+      code: `
+        <T>foo<div>{'foo'}</div></T>
+      `,
+      options: [{ elementOverrides: { T: { allowedStrings: ['foo'], applyToNestedElements: false } } }],
+    },
+    {
+      code: `
+        <div>
+          <div foo={2} />
+          <T foo="bar" />
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true } } }],
+    },
+    {
+      code: `
+        <T foo="bar"><div foo="bar" /></T>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true } } }],
+    },
+    {
+      code: `
+        <T foo="bar"><div foo={2} /></T>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true, applyToNestedElements: false } } }],
+    },
+    {
+      code: `
+        <div>
+          <div foo="foo" />
+          <T foo={2} />
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true } } }],
+    },
+    {
+      code: `
+        <T foo={2}><div foo={2} /></T>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true } } }],
+    },
+    {
+      code: `
+        <T foo={2}><div foo="foo" /></T>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true, applyToNestedElements: false } } }],
+    },
+    {
+      code: `
+        <T>foo<U>foo</U></T>
+      `,
+      options: [{ elementOverrides: { T: { allowedStrings: ['foo'] }, U: { allowedStrings: ['foo'] } } }],
+    },
+    {
+      code: `
+        import { T } from 'foo';
+        <T>{'foo'}</T>
+      `,
+    },
+    {
+      code: `
+        import { T as U } from 'foo';
+        <U>foo</U>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        const { T: U } = require('foo');
+        <U>foo</U>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        const { T: U } = require('foo').Foo;
+        <U>foo</U>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        const { T: U } = require('foo').Foo.Foo;
+        <U>foo</U>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        const foo = 2;
+        <T>foo</T>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+    },
+    {
+      code: `
+        <T.U>foo</T.U>
+      `,
+      options: [{ elementOverrides: { 'T.U': { allowElement: true } } }],
+    },
+    {
+      code: `
+        import { T as U } from 'foo';
+        <U.U>foo</U.U>
+      `,
+      options: [{ elementOverrides: { 'T.U': { allowElement: true } } }],
+    },
+    {
+      code: `
+        <React.Fragment>foo</React.Fragment>
+      `,
+      options: [{ elementOverrides: { Fragment: { allowElement: true } } }],
+    },
+    {
+      code: `
+        <React.Fragment>foo</React.Fragment>
+      `,
+      options: [{ elementOverrides: { 'React.Fragment': { allowElement: true } } }],
+    },
+    {
+      code: `
+        <div>{'foo'}</div>
+      `,
+      options: [{ elementOverrides: { div: { allowElement: true } } }],
+    },
   ]),
 
   invalid: parsers.all([
@@ -521,6 +701,7 @@ ruleTester.run('jsx-no-literals', rule, {
         },
       ],
     },
+    /* eslint-disable no-template-curly-in-string */
     {
       code: '<Foo bar={`${baz}`} />',
       options: [{ noStrings: true, ignoreProps: false }],
@@ -541,6 +722,7 @@ ruleTester.run('jsx-no-literals', rule, {
         },
       ],
     },
+    /* eslint-enable no-template-curly-in-string */
     {
       code: '<Foo bar={`foo` + \'bar\'} />',
       options: [{ noStrings: true, ignoreProps: false }],
@@ -663,5 +845,329 @@ ruleTester.run('jsx-no-literals', rule, {
         },
       ],
     },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>bar</T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: {} } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpression', data: { text: 'foo' } },
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'bar', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>bar</T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpression', data: { text: 'foo' } },
+      ],
+    },
+    {
+      code: `
+        <T>foo <div>bar</div></T>
+      `,
+      options: [{ elementOverrides: { T: { allowElement: true, applyToNestedElements: false } } }],
+      errors: [{ messageId: 'literalNotInJSXExpression', data: { text: 'bar' } }],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>{'bar'}</T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpression', data: { text: 'foo' } },
+        { messageId: 'noStringsInJSXInElement', data: { text: '\'bar\'', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>{'bar'}<div>{'baz'}</div></T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpression', data: { text: 'foo' } },
+        { messageId: 'noStringsInJSXInElement', data: { text: '\'bar\'', element: 'T' } },
+        { messageId: 'noStringsInJSXInElement', data: { text: '\'baz\'', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>{'bar'}<div>{'baz'}</div></T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true, applyToNestedElements: false } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpression', data: { text: 'foo' } },
+        { messageId: 'noStringsInJSXInElement', data: { text: '\'bar\'', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>{'foo'}</T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, allowedStrings: ['foo'] } } }],
+      errors: [
+        { messageId: 'noStringsInJSX', data: { text: '\'foo\'' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>{'foo'}<div>{'foo'}</div></T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, allowedStrings: ['foo'] } } }],
+      errors: [
+        { messageId: 'noStringsInJSX', data: { text: '\'foo\'' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>{'foo'}<div>{'foo'}</div></T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, allowedStrings: ['foo'], applyToNestedElements: false } } }],
+      errors: [
+        { messageId: 'noStringsInJSX', data: { text: '\'foo\'' } },
+        { messageId: 'noStringsInJSX', data: { text: '\'foo\'' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar" />
+          <T foo2="bar" />
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true } } }],
+      errors: [
+        { messageId: 'invalidPropValue', data: { text: 'foo1="bar"' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar" />
+          <T foo2="bar"><div foo3="bar" /></T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true } } }],
+      errors: [
+        { messageId: 'invalidPropValue', data: { text: 'foo1="bar"' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar" />
+          <T foo2="bar"><div foo3="bar" /></T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: { noStrings: true, ignoreProps: true, applyToNestedElements: false } } }],
+      errors: [
+        { messageId: 'invalidPropValue', data: { text: 'foo1="bar"' } },
+        { messageId: 'invalidPropValue', data: { text: 'foo3="bar"' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar1" />
+          <T foo2="bar2" />
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true } } }],
+      errors: [
+        { messageId: 'noStringsInAttributesInElement', data: { text: '"bar2"', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar1" />
+          <T foo2="bar2"><div foo3="bar3" /></T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true } } }],
+      errors: [
+        { messageId: 'noStringsInAttributesInElement', data: { text: '"bar2"', element: 'T' } },
+        { messageId: 'noStringsInAttributesInElement', data: { text: '"bar3"', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar1" />
+          <T foo2="bar2"><div foo3="bar3" /></T>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: { noAttributeStrings: true, applyToNestedElements: false } } }],
+      errors: [
+        { messageId: 'noStringsInAttributesInElement', data: { text: '"bar2"', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>{'foo'}</div>
+          <T>{'bar'}</T>
+        </div>
+      `,
+      options: [{ noStrings: true, elementOverrides: { T: {} } }],
+      errors: [
+        { messageId: 'noStringsInJSX', data: { text: '\'foo\'' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>foo</T>
+        </div>
+      `,
+      options: [{ allowedStrings: ['foo'], elementOverrides: { T: {} } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div>foo</div>
+          <T>foo</T>
+          <T>bar</T>
+          <T>baz</T>
+        </div>
+      `,
+      options: [{ allowedStrings: ['foo'], elementOverrides: { T: { allowedStrings: ['bar'] } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'baz', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar1" />
+          <T foo2="bar2" />
+        </div>
+      `,
+      options: [{ noStrings: true, ignoreProps: true, elementOverrides: { T: { noStrings: true } } }],
+      errors: [
+        { messageId: 'invalidPropValueInElement', data: { text: 'foo2="bar2"', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <div foo1="bar1" />
+          <T foo2="bar2" />
+        </div>
+      `,
+      options: [{ noAttributeStrings: true, elementOverrides: { T: {} } }],
+      errors: [
+        { messageId: 'noStringsInAttributes', data: { text: '"bar1"' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <T>foo</T>
+          <U>bar</U>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: {}, U: {} } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'bar', element: 'U' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <T>foo</T>
+          <U>bar</U>
+        </div>
+      `,
+      options: [{ elementOverrides: { T: {}, U: { allowElement: true } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <T>foo <U>bar</U></T>
+      `,
+      options: [{ elementOverrides: { T: {}, U: { allowElement: true } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <T>{'foo'}<U>{'bar'}</U></T>
+      `,
+      options: [{ elementOverrides: { T: { noStrings: true }, U: {} } }],
+      errors: [
+        { messageId: 'noStringsInJSXInElement', data: { text: '\'foo\'', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <T>foo<U>foo</U></T>
+      `,
+      options: [{ elementOverrides: { T: { allowedStrings: ['foo'] }, U: {} } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'U' } },
+      ],
+    },
+    {
+      code: `
+        <T>foo<U>foo</U></T>
+      `,
+      options: [{ elementOverrides: { T: {}, U: { allowedStrings: ['foo'] } } }],
+      errors: [
+        { messageId: 'literalNotInJSXExpressionInElement', data: { text: 'foo', element: 'T' } },
+      ],
+    },
+    {
+      code: `
+        <div>
+          <Fragment>foo</Fragment>
+          <React.Fragment>foo</React.Fragment>
+        </div>
+      `,
+      options: [{ elementOverrides: { 'React.Fragment': { allowElement: true } } }],
+      errors: [{ messageId: 'literalNotInJSXExpression', data: { text: 'foo' } }],
+    },
+    {
+      code: `
+        <div>foo</div>
+      `,
+      options: [{ elementOverrides: { div: { allowElement: true } } }],
+      errors: [{ messageId: 'literalNotInJSXExpression', data: { text: 'foo' } }],
+    },
   ]),
 });
diff --git a/tests/lib/rules/jsx-no-script-url.js b/tests/lib/rules/jsx-no-script-url.js
index 4d0374e08e..b97c9ce567 100644
--- a/tests/lib/rules/jsx-no-script-url.js
+++ b/tests/lib/rules/jsx-no-script-url.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-script-url');
 
 const parsers = require('../../helpers/parsers');
@@ -38,6 +38,10 @@ ruleTester.run('jsx-no-script-url', rule, {
     { code: '<a href={"javascript:"}></a>' },
     { code: '<Foo href="javascript:"></Foo>' },
     { code: '<a href />' },
+    {
+      code: '<Foo other="javascript:"></Foo>',
+      options: [[{ name: 'Foo', props: ['to', 'href'] }]],
+    },
     {
       code: '<Foo href="javascript:"></Foo>',
       settings: {
@@ -51,6 +55,13 @@ ruleTester.run('jsx-no-script-url', rule, {
         linkComponents: [{ name: 'Foo', linkAttribute: ['to', 'href'] }],
       },
     },
+    {
+      code: '<Foo other="javascript:"></Foo>',
+      options: [[], { includeFromSettings: true }],
+      settings: {
+        linkComponents: [{ name: 'Foo', linkAttribute: ['to', 'href'] }],
+      },
+    },
   ]),
   invalid: parsers.all([
     // defaults
diff --git a/tests/lib/rules/jsx-no-target-blank.js b/tests/lib/rules/jsx-no-target-blank.js
index 591a1a42ee..01dcb360ff 100644
--- a/tests/lib/rules/jsx-no-target-blank.js
+++ b/tests/lib/rules/jsx-no-target-blank.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-target-blank');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-no-undef.js b/tests/lib/rules/jsx-no-undef.js
index 665f0da454..84ffeb0c35 100644
--- a/tests/lib/rules/jsx-no-undef.js
+++ b/tests/lib/rules/jsx-no-undef.js
@@ -9,11 +9,13 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const eslint = require('eslint');
+const semver = require('semver');
+const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
+const getRuleDefiner = require('../../helpers/getRuleDefiner');
+const getESLintCoreRule = require('../../helpers/getESLintCoreRule');
 const rule = require('../../../lib/rules/jsx-no-undef');
 
-const RuleTester = eslint.RuleTester;
-
 const parsers = require('../../helpers/parsers');
 
 const parserOptions = {
@@ -29,8 +31,12 @@ const parserOptions = {
 // -----------------------------------------------------------------------------
 
 const ruleTester = new RuleTester({ parserOptions });
-const linter = ruleTester.linter || eslint.linter || eslint.Linter;
-linter.defineRule('no-undef', require('../../helpers/getESLintCoreRule')('no-undef'));
+
+// In ESLint >= 9, it isn't possible to redefine a core rule, but it isn't necessary anyway since the core rules are certainly already available in the RuleTester/Linter
+if (semver.major(eslintPkg.version) < 9) {
+  const ruleDefiner = getRuleDefiner(ruleTester);
+  ruleDefiner.defineRule('no-undef', getESLintCoreRule('no-undef'));
+}
 
 ruleTester.run('jsx-no-undef', rule, {
   valid: parsers.all([
diff --git a/tests/lib/rules/jsx-no-useless-fragment.js b/tests/lib/rules/jsx-no-useless-fragment.js
index 22594aa6bf..eb5b227bcd 100644
--- a/tests/lib/rules/jsx-no-useless-fragment.js
+++ b/tests/lib/rules/jsx-no-useless-fragment.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-no-useless-fragment');
 const parsers = require('../../helpers/parsers');
 
@@ -194,7 +194,7 @@ ruleTester.run('jsx-no-useless-fragment', rule, {
     },
     {
       code: '<div><>{"a"}{"b"}</></div>',
-      output: '<div><>{"a"}{"b"}</></div>',
+      output: null,
       errors: [{ messageId: 'ChildOfHtmlElement', type: 'JSXFragment' }],
       features: ['fragment', 'ts-old', 'no-ts-new', 'no-babel', 'no-default'],
     },
diff --git a/tests/lib/rules/jsx-one-expression-per-line.js b/tests/lib/rules/jsx-one-expression-per-line.js
index 62afc430d4..72615c2679 100644
--- a/tests/lib/rules/jsx-one-expression-per-line.js
+++ b/tests/lib/rules/jsx-one-expression-per-line.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-one-expression-per-line');
 
 const parsers = require('../../helpers/parsers');
@@ -937,26 +937,6 @@ foo
         <App>
           <Foo></
         Foo>
-</App>
-      `,
-      errors: [
-        {
-          messageId: 'moveToNewLine',
-          data: { descriptor: 'Foo' },
-        },
-      ],
-      parserOptions,
-    },
-    {
-      code: `
-        <App>
-          <Foo></
-        Foo></App>
-      `,
-      output: `
-        <App>
-          <Foo></
-        Foo>
 </App>
       `,
       errors: [
diff --git a/tests/lib/rules/jsx-pascal-case.js b/tests/lib/rules/jsx-pascal-case.js
index 9923131118..bc90773ef7 100644
--- a/tests/lib/rules/jsx-pascal-case.js
+++ b/tests/lib/rules/jsx-pascal-case.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-pascal-case');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-props-no-multi-spaces.js b/tests/lib/rules/jsx-props-no-multi-spaces.js
index 1f3597bbcf..8b8d15a9b4 100644
--- a/tests/lib/rules/jsx-props-no-multi-spaces.js
+++ b/tests/lib/rules/jsx-props-no-multi-spaces.js
@@ -9,9 +9,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-props-no-multi-spaces');
 
 const parsers = require('../../helpers/parsers');
@@ -84,7 +84,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
     {
       code: `
         <button
-          title="Some button"
+          title="Some button 8"
           type="button"
         />
       `,
@@ -92,7 +92,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
     {
       code: `
         <button
-          title="Some button"
+          title="Some button 8"
           onClick={(value) => {
             console.log(value);
           }}
@@ -104,7 +104,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 2"
             // this is a comment
             onClick={(value) => {
               console.log(value);
@@ -116,7 +116,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 2"
             // this is a comment
             // this is a second comment
             onClick={(value) => {
@@ -129,7 +129,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <App
-            foo="Some button" // comment
+            foo="Some button 3" // comment
             // comment
             bar=""
           />
@@ -138,7 +138,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 3"
             /* this is a multiline comment
                 ...
                 ... */
@@ -263,6 +263,12 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
           type="button"
         />
       `,
+      output: `
+        <button
+          title='Some button'${semver.satisfies(eslintPkg.version, '> 3') ? '' : '\n'}
+          type="button"
+        />
+      `,
       errors: [
         {
           messageId: 'noLineGap',
@@ -273,7 +279,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
     {
       code: `
         <button
-          title="Some button"
+          title="Some button 4"
 
           onClick={(value) => {
             console.log(value);
@@ -282,6 +288,15 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
           type="button"
         />
       `,
+      output: `
+        <button
+          title="Some button 4"${semver.satisfies(eslintPkg.version, '> 3') ? '' : '\n'}
+          onClick={(value) => {
+            console.log(value);
+          }}${semver.satisfies(eslintPkg.version, '> 3') ? '' : '\n'}
+          type="button"
+        />
+      `,
       errors: [
         {
           messageId: 'noLineGap',
@@ -297,7 +312,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 5"
             // this is a comment
             onClick={(value) => {
               console.log(value);
@@ -306,6 +321,16 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
             type="button"
           />
         `,
+        output: `
+          <button
+            title="Some button 5"
+            // this is a comment
+            onClick={(value) => {
+              console.log(value);
+            }}
+            type="button"
+          />
+        `,
         errors: [
           {
             messageId: 'noLineGap',
@@ -316,7 +341,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 6"
             // this is a comment
             // second comment
 
@@ -327,6 +352,17 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
             type="button"
           />
         `,
+        output: `
+          <button
+            title="Some button 6"
+            // this is a comment
+            // second comment
+            onClick={(value) => {
+              console.log(value);
+            }}
+            type="button"
+          />
+        `,
         errors: [
           {
             messageId: 'noLineGap',
@@ -341,7 +377,7 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
       {
         code: `
           <button
-            title="Some button"
+            title="Some button 7"
             /*this is a
               multiline
               comment
@@ -354,6 +390,19 @@ ruleTester.run('jsx-props-no-multi-spaces', rule, {
             type="button"
           />
         `,
+        output: `
+          <button
+            title="Some button 7"
+            /*this is a
+              multiline
+              comment
+            */
+            onClick={(value) => {
+              console.log(value);
+            }}
+            type="button"
+          />
+        `,
         errors: [
           {
             messageId: 'noLineGap',
diff --git a/tests/lib/rules/jsx-props-no-spread-multi.js b/tests/lib/rules/jsx-props-no-spread-multi.js
new file mode 100644
index 0000000000..2e5df66668
--- /dev/null
+++ b/tests/lib/rules/jsx-props-no-spread-multi.js
@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Tests for jsx-props-no-spread-multi
+ */
+
+'use strict';
+
+// -----------------------------------------------------------------------------
+// Requirements
+// -----------------------------------------------------------------------------
+
+const RuleTester = require('../../helpers/ruleTester');
+const rule = require('../../../lib/rules/jsx-props-no-spread-multi');
+
+const parsers = require('../../helpers/parsers');
+
+const parserOptions = {
+  ecmaVersion: 2018,
+  sourceType: 'module',
+  ecmaFeatures: {
+    jsx: true,
+  },
+};
+
+// -----------------------------------------------------------------------------
+// Tests
+// -----------------------------------------------------------------------------
+
+const ruleTester = new RuleTester({ parserOptions });
+const expectedError = { messageId: 'noMultiSpreading' };
+
+ruleTester.run('jsx-props-no-spread-multi', rule, {
+  valid: parsers.all([
+    {
+      code: `
+        const a = {};
+        <App {...a} />
+      `,
+    },
+    {
+      code: `
+        const a = {};
+        const b = {};
+        <App {...a} {...b} />
+      `,
+    },
+  ]),
+
+  invalid: parsers.all([
+    {
+      code: `
+        const props = {};
+        <App {...props} {...props} />
+      `,
+      errors: [expectedError],
+    },
+    {
+      code: `
+        const props = {};
+        <div {...props} a="a" {...props} />
+      `,
+      errors: [expectedError],
+    },
+    {
+      code: `
+        const props = {};
+        <div {...props} {...props} {...props} />
+      `,
+      errors: [expectedError, expectedError],
+    },
+  ]),
+});
diff --git a/tests/lib/rules/jsx-props-no-spreading.js b/tests/lib/rules/jsx-props-no-spreading.js
index 27fbf37170..dc9c0203ed 100644
--- a/tests/lib/rules/jsx-props-no-spreading.js
+++ b/tests/lib/rules/jsx-props-no-spreading.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-props-no-spreading');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-sort-default-props.js b/tests/lib/rules/jsx-sort-default-props.js
index 171b431889..15d651db3a 100644
--- a/tests/lib/rules/jsx-sort-default-props.js
+++ b/tests/lib/rules/jsx-sort-default-props.js
@@ -11,7 +11,7 @@
 
 const babelEslintVersion = require('babel-eslint/package.json').version;
 const semver = require('semver');
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/jsx-sort-default-props');
 
diff --git a/tests/lib/rules/jsx-sort-props.js b/tests/lib/rules/jsx-sort-props.js
index 1dc9d270a6..797dc26650 100644
--- a/tests/lib/rules/jsx-sort-props.js
+++ b/tests/lib/rules/jsx-sort-props.js
@@ -9,9 +9,9 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-sort-props');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-space-before-closing.js b/tests/lib/rules/jsx-space-before-closing.js
index af69bd749a..01f80be41a 100644
--- a/tests/lib/rules/jsx-space-before-closing.js
+++ b/tests/lib/rules/jsx-space-before-closing.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-space-before-closing');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-tag-spacing.js b/tests/lib/rules/jsx-tag-spacing.js
index 039591a7f5..cc98cb2b05 100644
--- a/tests/lib/rules/jsx-tag-spacing.js
+++ b/tests/lib/rules/jsx-tag-spacing.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-tag-spacing');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/jsx-uses-react.js b/tests/lib/rules/jsx-uses-react.js
index 0110be18bb..381b44bc89 100644
--- a/tests/lib/rules/jsx-uses-react.js
+++ b/tests/lib/rules/jsx-uses-react.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const eslint = require('eslint');
 const rule = require('../../helpers/getESLintCoreRule')('no-unused-vars');
 
-const RuleTester = eslint.RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
+const getRuleDefiner = require('../../helpers/getRuleDefiner');
 
 const parsers = require('../../helpers/parsers');
 
@@ -35,53 +35,92 @@ const settings = {
 // -----------------------------------------------------------------------------
 
 const ruleTester = new RuleTester({ parserOptions });
-const linter = ruleTester.linter || eslint.linter || eslint.Linter;
-linter.defineRule('jsx-uses-react', require('../../../lib/rules/jsx-uses-react'));
+const ruleDefiner = getRuleDefiner(ruleTester);
+ruleDefiner.defineRule('react/jsx-uses-react', require('../../../lib/rules/jsx-uses-react'));
 
 ruleTester.run('no-unused-vars', rule, {
   valid: parsers.all([
-    { code: '/*eslint jsx-uses-react:1*/ var React; <div />;' },
-    { code: '/*eslint jsx-uses-react:1*/ var React; (function () { <div /> })();' },
-    { code: '/*eslint jsx-uses-react:1*/ /** @jsx Foo */ var Foo; <div />;' },
+    { code: '/*eslint react/jsx-uses-react:1*/ var React; <div />;' },
+    { code: '/*eslint react/jsx-uses-react:1*/ var React; (function () { <div /> })();' },
+    { code: '/*eslint react/jsx-uses-react:1*/ /** @jsx Foo */ var Foo; <div />;' },
     {
-      code: '/*eslint jsx-uses-react:1*/ var Foo; <div />;',
+      code: '/*eslint react/jsx-uses-react:1*/ var Foo; <div />;',
       settings,
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ var Frag; <></>;',
+      code: '/*eslint react/jsx-uses-react:1*/ var Frag; <></>;',
       settings: { react: { fragment: 'Frag' } },
       features: ['fragment'],
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ var React; <></>;',
+      code: '/*eslint react/jsx-uses-react:1*/ var React; <></>;',
       features: ['fragment', 'no-ts-old'], // TODO: FIXME: fix for typescript-eslint
     },
   ].map(parsers.disableNewTS)),
   invalid: parsers.all([
     {
-      code: '/*eslint jsx-uses-react:1*/ var React;',
-      errors: [{ message: '\'React\' is defined but never used.' }],
+      code: '/*eslint react/jsx-uses-react:1*/ var React;',
+      errors: [{
+        message: '\'React\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/*eslint react/jsx-uses-react:1*/ ',
+        }],
+      }],
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ /** @jsx Foo */ var React; <div />;',
-      errors: [{ message: '\'React\' is defined but never used.' }],
+      code: '/*eslint react/jsx-uses-react:1*/ /** @jsx Foo */ var React; <div />;',
+      errors: [{
+        message: '\'React\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/*eslint react/jsx-uses-react:1*/ /** @jsx Foo */  <div />;',
+        }],
+      }],
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ var React; <div />;',
-      errors: [{ message: '\'React\' is defined but never used.' }],
+      code: '/*eslint react/jsx-uses-react:1*/ var React; <div />;',
+      errors: [{
+        message: '\'React\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/*eslint react/jsx-uses-react:1*/  <div />;',
+        }],
+      }],
       settings,
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ var Frag; <></>;',
-      errors: [{ message: '\'Frag\' is defined but never used.' }],
+      code: '/*eslint react/jsx-uses-react:1*/ var Frag; <></>;',
+      errors: [{
+        message: '\'Frag\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/*eslint react/jsx-uses-react:1*/  <></>;',
+        }],
+      }],
       features: ['fragment'],
       settings: { react: { fragment: 'Fragment' } },
     },
     {
-      code: '/*eslint jsx-uses-react:1*/ var React; <></>;',
+      code: '/*eslint react/jsx-uses-react:1*/ var React; <></>;',
       features: ['fragment'],
-      errors: [{ message: '\'React\' is defined but never used.' }],
+      errors: [{
+        message: '\'React\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/*eslint react/jsx-uses-react:1*/  <></>;',
+        }],
+      }],
       settings,
     },
-  ].map(parsers.disableNewTS)),
+  ].map(parsers.disableNewTS).map((test) => {
+    if (!rule.meta.hasSuggestions) {
+      test.errors = test.errors.map((error) => {
+        // https://github.com/eslint/eslint/pull/18352 added suggestions to no-unused-vars in eslint v9.17.0
+        delete error.suggestions;
+        return error;
+      });
+    }
+    return test;
+  })),
 });
diff --git a/tests/lib/rules/jsx-uses-vars.js b/tests/lib/rules/jsx-uses-vars.js
index 3dc9ccdaad..8b9db2a956 100644
--- a/tests/lib/rules/jsx-uses-vars.js
+++ b/tests/lib/rules/jsx-uses-vars.js
@@ -9,11 +9,12 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const eslint = require('eslint');
 const ruleNoUnusedVars = require('../../helpers/getESLintCoreRule')('no-unused-vars');
+
 const rulePreferConst = require('../../helpers/getESLintCoreRule')('prefer-const');
 
-const RuleTester = eslint.RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
+const getRuleDefiner = require('../../helpers/getRuleDefiner');
 
 const parsers = require('../../helpers/parsers');
 
@@ -30,14 +31,14 @@ const parserOptions = {
 // -----------------------------------------------------------------------------
 
 const ruleTester = new RuleTester({ parserOptions });
-const linter = ruleTester.linter || eslint.linter || eslint.Linter;
-linter.defineRule('jsx-uses-vars', require('../../../lib/rules/jsx-uses-vars'));
+const ruleDefiner = getRuleDefiner(ruleTester);
+ruleDefiner.defineRule('react/jsx-uses-vars', require('../../../lib/rules/jsx-uses-vars'));
 
 ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
   valid: parsers.all([
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         function foo() {
           var App;
           var bar = React.render(<App/>);
@@ -48,21 +49,21 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var App;
         React.render(<App/>);
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var a = 1;
         React.render(<img src={a} />);
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var App;
         function f() {
           return <App />;
@@ -72,21 +73,21 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var App;
         <App.Hello />
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         class HelloMessage {};
         <HelloMessage />
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         class HelloMessage {
           render() {
             var HelloMessage = <div>Hello</div>;
@@ -98,7 +99,7 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         function foo() {
           var App = { Foo: { Bar: {} } };
           var bar = React.render(<App.Foo.Bar/>);
@@ -109,7 +110,7 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         function foo() {
           var App = { Foo: { Bar: { Baz: {} } } };
           var bar = React.render(<App.Foo.Bar.Baz/>);
@@ -120,14 +121,14 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var object;
         React.render(<object.Tag />);
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var object;
         React.render(<object.tag />);
       `,
@@ -135,50 +136,109 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
   ].map(parsers.disableNewTS)),
   invalid: parsers.all([
     {
-      code: '/* eslint jsx-uses-vars: 1 */ var App;',
-      errors: [{ message: '\'App\' is defined but never used.' }],
+      code: '/* eslint react/jsx-uses-vars: 1 */ var App;',
+      errors: [{
+        message: '\'App\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: '/* eslint react/jsx-uses-vars: 1 */ ',
+        }],
+      }],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var App;
         var unused;
         React.render(<App unused=""/>);
       `,
-      errors: [{ message: '\'unused\' is defined but never used.' }],
+      errors: [{
+        message: '\'unused\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        var App;
+        ${''}
+        React.render(<App unused=""/>);
+      `,
+        }],
+      }],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var App;
         var Hello;
         React.render(<App:Hello/>);
       `,
       errors: [
-        { message: '\'App\' is defined but never used.' },
-        { message: '\'Hello\' is defined but never used.' },
+        {
+          message: '\'App\' is defined but never used.',
+          suggestions: [{
+            messageId: 'removeVar',
+            output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        ${''}
+        var Hello;
+        React.render(<App:Hello/>);
+      `,
+          }],
+        },
+        {
+          message: '\'Hello\' is defined but never used.',
+          suggestions: [{
+            messageId: 'removeVar',
+            output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        var App;
+        ${''}
+        React.render(<App:Hello/>);
+      `,
+          }],
+        },
       ],
       features: ['jsx namespace'],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var Button;
         var Input;
         React.render(<Button.Input unused=""/>);
       `,
-      errors: [{ message: '\'Input\' is defined but never used.' }],
+      errors: [{
+        message: '\'Input\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        var Button;
+        ${''}
+        React.render(<Button.Input unused=""/>);
+      `,
+        }],
+      }],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         class unused {}
       `,
-      errors: [{ message: '\'unused\' is defined but never used.' }],
+      errors: [{
+        message: '\'unused\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        ${''}
+      `,
+        }],
+      }],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         class HelloMessage {
           render() {
             var HelloMessage = <div>Hello</div>;
@@ -190,12 +250,19 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
         {
           message: '\'HelloMessage\' is defined but never used.',
           line: 3,
+          suggestions: [{
+            messageId: 'removeVar',
+            output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        ${''}
+      `,
+          }],
         },
       ],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         import {Hello} from 'Hello';
         function Greetings() {
           const Hello = require('Hello').default;
@@ -207,20 +274,42 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
         {
           message: '\'Hello\' is defined but never used.',
           line: 3,
+          suggestions: [{
+            messageId: 'removeVar',
+            output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        ${''}
+        function Greetings() {
+          const Hello = require('Hello').default;
+          return <Hello />;
+        }
+        Greetings();
+      `,
+          }],
         },
       ],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         var lowercase;
         React.render(<lowercase />);
       `,
-      errors: [{ message: '\'lowercase\' is defined but never used.' }],
+      errors: [{
+        message: '\'lowercase\' is defined but never used.',
+        suggestions: [{
+          messageId: 'removeVar',
+          output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        ${''}
+        React.render(<lowercase />);
+      `,
+        }],
+      }],
     },
     {
       code: `
-        /* eslint jsx-uses-vars: 1 */
+        /* eslint react/jsx-uses-vars: 1 */
         function Greetings(div) {
           return <div />;
         }
@@ -230,10 +319,29 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
         {
           message: '\'div\' is defined but never used.',
           line: 3,
+          suggestions: [{
+            messageId: 'removeVar',
+            output: `
+        /* eslint react/jsx-uses-vars: 1 */
+        function Greetings() {
+          return <div />;
+        }
+        Greetings();
+      `,
+          }],
         },
       ],
     },
-  ]),
+  ].map((test) => {
+    if (!ruleNoUnusedVars.meta.hasSuggestions) {
+      test.errors = test.errors.map((error) => {
+        // https://github.com/eslint/eslint/pull/18352 added suggestions to no-unused-vars in eslint v9.17.0
+        delete error.suggestions;
+        return error;
+      });
+    }
+    return test;
+  })),
 });
 
 // Check compatibility with eslint prefer-const rule (#716)
@@ -242,26 +350,26 @@ ruleTester.run('prefer-const', rulePreferConst, {
   invalid: parsers.all([
     {
       code: `
-        /* eslint jsx-uses-vars:1 */
+        /* eslint react/jsx-uses-vars:1 */
         let App = <div />;
         <App />;
       `,
       errors: [{ message: '\'App\' is never reassigned. Use \'const\' instead.' }],
       output: `
-        /* eslint jsx-uses-vars:1 */
+        /* eslint react/jsx-uses-vars:1 */
         const App = <div />;
         <App />;
       `,
     },
     {
       code: `
-        /* eslint jsx-uses-vars:1 */
+        /* eslint react/jsx-uses-vars:1 */
         let filters = 'foo';
         <div>{filters}</div>;
       `,
       errors: [{ message: '\'filters\' is never reassigned. Use \'const\' instead.' }],
       output: `
-        /* eslint jsx-uses-vars:1 */
+        /* eslint react/jsx-uses-vars:1 */
         const filters = 'foo';
         <div>{filters}</div>;
       `,
diff --git a/tests/lib/rules/jsx-wrap-multilines.js b/tests/lib/rules/jsx-wrap-multilines.js
index 36efd2f8f5..8db8fe79d9 100644
--- a/tests/lib/rules/jsx-wrap-multilines.js
+++ b/tests/lib/rules/jsx-wrap-multilines.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/jsx-wrap-multilines');
 
 const parsers = require('../../helpers/parsers');
@@ -1393,16 +1393,6 @@ ruleTester.run('jsx-wrap-multilines', rule, {
         { messageId: 'parensOnNewLines' },
       ],
     },
-    {
-      code: DECLARATION_TERNARY_PAREN_FRAGMENT,
-      features: ['fragment'],
-      output: addNewLineSymbols(DECLARATION_TERNARY_PAREN_FRAGMENT),
-      options: [{ declaration: 'parens-new-line' }],
-      errors: [
-        { messageId: 'parensOnNewLines' },
-        { messageId: 'parensOnNewLines' },
-      ],
-    },
     {
       code: ASSIGNMENT_TERNARY_NO_PAREN,
       output: addNewLineSymbols(ASSIGNMENT_TERNARY_PAREN),
diff --git a/tests/lib/rules/no-access-state-in-setstate.js b/tests/lib/rules/no-access-state-in-setstate.js
index 258821be84..bdf104d0cc 100644
--- a/tests/lib/rules/no-access-state-in-setstate.js
+++ b/tests/lib/rules/no-access-state-in-setstate.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const parsers = require('../../helpers/parsers');
 const rule = require('../../../lib/rules/no-access-state-in-setstate');
 
diff --git a/tests/lib/rules/no-adjacent-inline-elements.js b/tests/lib/rules/no-adjacent-inline-elements.js
index f2da87d7da..a757fb869d 100644
--- a/tests/lib/rules/no-adjacent-inline-elements.js
+++ b/tests/lib/rules/no-adjacent-inline-elements.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-adjacent-inline-elements');
 const parsers = require('../../helpers/parsers');
 
diff --git a/tests/lib/rules/no-array-index-key.js b/tests/lib/rules/no-array-index-key.js
index dc5364f47c..2269e208ca 100644
--- a/tests/lib/rules/no-array-index-key.js
+++ b/tests/lib/rules/no-array-index-key.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const parsers = require('../../helpers/parsers');
 const rule = require('../../../lib/rules/no-array-index-key');
 
@@ -27,7 +27,7 @@ const parserOptions = {
 
 const ruleTester = new RuleTester({ parserOptions });
 ruleTester.run('no-array-index-key', rule, {
-  valid: parsers.all(
+  valid: parsers.all([
     { code: '<Foo key="foo" />;' },
     { code: '<Foo key={i} />;' },
     { code: '<Foo key />;' },
@@ -96,9 +96,6 @@ ruleTester.run('no-array-index-key', rule, {
     {
       code: 'foo.flatMap((a) => <Foo key={a} />)',
     },
-    {
-      code: 'foo.reduce((a, b) => a.concat(<Foo key={b.id} />), [])',
-    },
     {
       code: 'foo.reduce((a, b, i) => a.concat(<Foo key={b.id} />), [])',
     },
@@ -139,8 +136,8 @@ ruleTester.run('no-array-index-key', rule, {
     {
       code: 'foo?.map(child => <Foo key={child.i} />)',
       features: ['optional chaining'],
-    }
-  ),
+    },
+  ]),
 
   invalid: parsers.all([].concat(
     {
diff --git a/tests/lib/rules/no-arrow-function-lifecycle.js b/tests/lib/rules/no-arrow-function-lifecycle.js
index ac22256c2c..de2c67cbc3 100644
--- a/tests/lib/rules/no-arrow-function-lifecycle.js
+++ b/tests/lib/rules/no-arrow-function-lifecycle.js
@@ -6,8 +6,8 @@
 'use strict';
 
 const semver = require('semver');
-const RuleTester = require('eslint').RuleTester;
 const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-arrow-function-lifecycle');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-children-prop.js b/tests/lib/rules/no-children-prop.js
index 93f0f4cf42..fdd7f501f8 100644
--- a/tests/lib/rules/no-children-prop.js
+++ b/tests/lib/rules/no-children-prop.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-children-prop');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-danger-with-children.js b/tests/lib/rules/no-danger-with-children.js
index b25397e0c6..53013f5a58 100644
--- a/tests/lib/rules/no-danger-with-children.js
+++ b/tests/lib/rules/no-danger-with-children.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-danger-with-children');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-danger.js b/tests/lib/rules/no-danger.js
index a6f18630d5..9403a220bf 100644
--- a/tests/lib/rules/no-danger.js
+++ b/tests/lib/rules/no-danger.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-danger');
 
 const parsers = require('../../helpers/parsers');
@@ -32,6 +32,26 @@ ruleTester.run('no-danger', rule, {
     { code: '<App />;' },
     { code: '<App dangerouslySetInnerHTML={{ __html: "" }} />;' },
     { code: '<div className="bar"></div>;' },
+    {
+      code: '<div className="bar"></div>;',
+      options: [{ customComponentNames: ['*'] }],
+    },
+    {
+      code: `
+        function App() {
+          return <Title dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['Home'] }],
+    },
+    {
+      code: `
+        function App() {
+          return <TextMUI dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['MUI*'] }],
+    },
   ]),
   invalid: parsers.all([
     {
@@ -43,5 +63,115 @@ ruleTester.run('no-danger', rule, {
         },
       ],
     },
+    {
+      code: '<App dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;',
+      options: [{ customComponentNames: ['*'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+        },
+      ],
+    },
+    {
+      code: `
+        function App() {
+          return <Title dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['Title'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+        },
+      ],
+    },
+    {
+      code: `
+        function App() {
+          return <TextFoo dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['*Foo'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+        },
+      ],
+    },
+    {
+      code: `
+        function App() {
+          return <FooText dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['Foo*'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+        },
+      ],
+    },
+    {
+      code: `
+        function App() {
+          return <TextMUI dangerouslySetInnerHTML={{ __html: "<span>hello</span>" }} />;
+        }
+      `,
+      options: [{ customComponentNames: ['*MUI'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+        },
+      ],
+    },
+    {
+      code: `
+        import type { ComponentProps } from "react";
+
+        const Comp = "div";
+        const Component = () => <></>;
+
+        const NestedComponent = (_props: ComponentProps<"div">) => <></>;
+
+        Component.NestedComponent = NestedComponent;
+
+        function App() {
+          return (
+            <>
+              <div dangerouslySetInnerHTML={{ __html: "<div>aaa</div>" }} />
+              <Comp dangerouslySetInnerHTML={{ __html: "<div>aaa</div>" }} />
+
+              <Component.NestedComponent
+                dangerouslySetInnerHTML={{ __html: '<div>aaa</div>' }}
+              />
+            </>
+          );
+        }
+      `,
+      features: ['fragment', 'types'],
+      options: [{ customComponentNames: ['*'] }],
+      errors: [
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+          line: 14,
+        },
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+          line: 15,
+        },
+        {
+          messageId: 'dangerousProp',
+          data: { name: 'dangerouslySetInnerHTML' },
+          line: 18,
+        },
+      ],
+    },
   ]),
 });
diff --git a/tests/lib/rules/no-deprecated.js b/tests/lib/rules/no-deprecated.js
index d986533aa5..a523eb1b6c 100644
--- a/tests/lib/rules/no-deprecated.js
+++ b/tests/lib/rules/no-deprecated.js
@@ -11,7 +11,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-deprecated');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-did-mount-set-state.js b/tests/lib/rules/no-did-mount-set-state.js
index c0ab3acf70..83a1e9b7b4 100644
--- a/tests/lib/rules/no-did-mount-set-state.js
+++ b/tests/lib/rules/no-did-mount-set-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-did-mount-set-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-did-update-set-state.js b/tests/lib/rules/no-did-update-set-state.js
index 679ba194eb..f0895531c5 100644
--- a/tests/lib/rules/no-did-update-set-state.js
+++ b/tests/lib/rules/no-did-update-set-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-did-update-set-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-direct-mutation-state.js b/tests/lib/rules/no-direct-mutation-state.js
index fa9f731188..ae692a20d0 100644
--- a/tests/lib/rules/no-direct-mutation-state.js
+++ b/tests/lib/rules/no-direct-mutation-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-direct-mutation-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-find-dom-node.js b/tests/lib/rules/no-find-dom-node.js
index 4d6890a2e1..152d7d9c58 100644
--- a/tests/lib/rules/no-find-dom-node.js
+++ b/tests/lib/rules/no-find-dom-node.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-find-dom-node');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-invalid-html-attribute.js b/tests/lib/rules/no-invalid-html-attribute.js
index f1e20aa9a6..d7530cecdd 100644
--- a/tests/lib/rules/no-invalid-html-attribute.js
+++ b/tests/lib/rules/no-invalid-html-attribute.js
@@ -9,7 +9,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const semver = require('semver');
+const eslintPkg = require('eslint/package.json');
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-invalid-html-attribute');
 const parsers = require('../../helpers/parsers');
 
@@ -247,12 +249,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'alternatex',
             attributeName: 'rel',
+            reportingValue: 'alternatex',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex' },
               output: '<a rel=""></a>',
             },
           ],
@@ -266,12 +269,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'alternatex',
             attributeName: 'rel',
+            reportingValue: 'alternatex',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex' },
               output: 'React.createElement("a", { rel: "" })',
             },
           ],
@@ -291,6 +295,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex' },
               output: 'React.createElement("a", { rel: [""] })',
             },
           ],
@@ -304,12 +309,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'alternatex',
             attributeName: 'rel',
+            reportingValue: 'alternatex',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex' },
               output: '<a rel=" alternate"></a>',
             },
           ],
@@ -323,12 +329,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'alternatex alternate',
             attributeName: 'rel',
+            reportingValue: 'alternatex alternate',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex alternate' },
               output: 'React.createElement("a", { rel: "" })',
             },
           ],
@@ -348,6 +355,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex alternate' },
               output: 'React.createElement("a", { rel: [""] })',
             },
           ],
@@ -367,6 +375,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternatex' },
               output: '<a rel="alternate "></a>',
             },
           ],
@@ -386,6 +395,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternate alternatex' },
               output: 'React.createElement("a", { rel: "" })',
             },
           ],
@@ -405,6 +415,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternate alternatex' },
               output: 'React.createElement("a", { rel: [""] })',
             },
           ],
@@ -424,6 +435,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveDefault',
+              data: { attributeName: 'rel' },
               output: '<html ></html>',
             },
           ],
@@ -443,6 +455,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           // suggestions: [
           //   {
           //     messageId: 'suggestRemoveDefault',
+          //     data: { attributeName: 'rel' },
           //     output: 'React.createElement("html", { })',
           //   },
           // ],
@@ -460,6 +473,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveEmpty',
+              data: { attributeName: 'rel' },
               output: '<a ></a>',
             },
           ],
@@ -476,12 +490,19 @@ ruleTester.run('no-invalid-html-attribute', rule, {
             attributeName: 'rel',
             reportingValue: 1,
           },
-          // suggestions: [
-          //   {
-          //     messageId: 'suggestRemoveDefault',
-          //     output: 'React.createElement("a", { })',
-          //   },
-          // ],
+
+          // FIXME: this suggestion produces invalid code
+          // In ESLint > 9, RuleTester doesn't allow suggestions with parsing errors.
+          suggestions: semver.major(eslintPkg.version) < 9
+            ? [
+              {
+                messageId: 'suggestRemoveInvalid',
+                data: { reportingValue: '1' },
+                output: 'React.createElement("a", { rel:  })',
+              },
+            ]
+            : 1,
+
           type: 'Literal',
         },
       ],
@@ -508,6 +529,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveDefault',
+              data: { attributeName: 'rel' },
               output: '<span ></span>',
             },
           ],
@@ -524,6 +546,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveNonString',
+              data: { attributeName: 'rel' },
               output: '<a ></a>',
             },
           ],
@@ -540,6 +563,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveNonString',
+              data: { attributeName: 'rel' },
               output: '<a ></a>',
             },
           ],
@@ -552,10 +576,11 @@ ruleTester.run('no-invalid-html-attribute', rule, {
       errors: [
         {
           messageId: 'onlyStrings',
-          data: { attributeName: 'rel' },
+          data: { attributeName: 'rel', reportingValue: 'true' },
           suggestions: [
             {
               messageId: 'suggestRemoveNonString',
+              data: { attributeName: 'rel', reportingValue: 'true' },
               output: '<a ></a>',
             },
           ],
@@ -572,6 +597,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveDefault',
+              data: { attributeName: 'rel' },
               output: '<a ></a>',
             },
           ],
@@ -588,6 +614,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveDefault',
+              data: { attributeName: 'rel' },
               output: '<a ></a>',
             },
           ],
@@ -607,6 +634,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'foobar' },
               output: '<a rel="noreferrer noopener "></a>',
             },
           ],
@@ -623,6 +651,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel="noreferrer noopener"></a>',
             },
           ],
@@ -639,6 +668,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel="noreferrer noopener"></a>',
             },
           ],
@@ -655,6 +685,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel="noreferrer noopener"></a>',
             },
           ],
@@ -674,6 +705,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'foobar' },
               output: '<a rel={"noreferrer noopener "}></a>',
             },
           ],
@@ -693,6 +725,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'foobar' },
               output: 'React.createElement("a", { rel: ["noreferrer", "noopener", "" ] })',
             },
           ],
@@ -712,6 +745,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'foobar' },
               output: '<a rel={" noreferrer noopener"}></a>',
             },
           ],
@@ -731,6 +765,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'foobar' },
               output: '<a rel={" batgo       noopener"}></a>',
             },
           ],
@@ -745,6 +780,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'batgo' },
               output: '<a rel={"foobar        noopener"}></a>',
             },
           ],
@@ -753,6 +789,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'spaceDelimited',
           data: { attributeName: 'rel' },
+          suggestions: [
+            {
+              messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
+              output: '<a rel={"foobar batgo noopener"}></a>',
+            },
+          ],
         },
       ],
     },
@@ -765,6 +808,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel={"noopener"}></a>',
             },
           ],
@@ -781,6 +825,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel={"noopener"}></a>',
             },
           ],
@@ -800,6 +845,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'batgo' },
               output: '<a rel={"  noopener"}></a>',
             },
           ],
@@ -808,6 +854,13 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'spaceDelimited',
           data: { attributeName: 'rel' },
+          suggestions: [
+            {
+              messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
+              output: '<a rel={"batgo noopener"}></a>',
+            },
+          ],
         },
       ],
     },
@@ -823,6 +876,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'batgo' },
               output: '<a rel={" noopener"}></a>',
             },
           ],
@@ -839,6 +893,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<a rel={"noopener"}></a>',
             },
           ],
@@ -859,6 +914,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'canonical' },
               output: '<a rel=""></a>',
             },
           ],
@@ -879,6 +935,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'dns-prefetch' },
               output: '<a rel=""></a>',
             },
           ],
@@ -899,6 +956,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'icon' },
               output: '<a rel=""></a>',
             },
           ],
@@ -925,12 +983,16 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'foo',
             attributeName: 'rel',
+            reportingValue: 'foo',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: {
+                attributeName: 'rel',
+                reportingValue: 'foo',
+              },
               output: '<link rel="shortcut "></link>',
             },
           ],
@@ -956,6 +1018,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<link rel="shortcut icon"></link>',
             },
           ],
@@ -969,12 +1032,16 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'neverValid',
           data: {
-            reportingValue: 'foo',
             attributeName: 'rel',
+            reportingValue: 'foo',
           },
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: {
+                attributeName: 'rel',
+                reportingValue: 'foo',
+              },
               output: '<link rel="shortcut  "></link>',
             },
           ],
@@ -983,6 +1050,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
         {
           messageId: 'notAlone',
           data: {
+            attributeName: 'rel',
             reportingValue: 'shortcut',
             missingValue: 'icon',
           },
@@ -993,6 +1061,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveWhitespaces',
+              data: { attributeName: 'rel' },
               output: '<link rel="shortcut foo"></link>',
             },
           ],
@@ -1013,6 +1082,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'manifest' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1033,6 +1103,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'modulepreload' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1053,6 +1124,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'pingback' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1073,6 +1145,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preconnect' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1093,6 +1166,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prefetch' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1113,6 +1187,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preload' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1133,6 +1208,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prerender' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1153,6 +1229,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'stylesheet' },
               output: '<a rel=""></a>',
             },
           ],
@@ -1173,6 +1250,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'canonical' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1193,6 +1271,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'dns-prefetch' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1213,6 +1292,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'icon' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1233,6 +1313,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'manifest' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1253,6 +1334,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'modulepreload' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1273,6 +1355,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'pingback' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1293,6 +1376,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preconnect' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1313,6 +1397,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prefetch' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1333,6 +1418,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preload' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1353,6 +1439,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prerender' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1373,6 +1460,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'stylesheet' },
               output: '<area rel=""></area>',
             },
           ],
@@ -1393,6 +1481,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'bookmark' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1413,6 +1502,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'external' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1433,6 +1523,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'nofollow' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1453,6 +1544,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'noopener' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1472,6 +1564,8 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           },
           suggestions: [
             {
+              messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'noreferrer' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1492,6 +1586,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'opener' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1512,6 +1607,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'tag' },
               output: '<link rel=""></link>',
             },
           ],
@@ -1532,6 +1628,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'alternate' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1552,6 +1649,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'author' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1572,6 +1670,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'bookmark' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1592,6 +1691,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'canonical' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1612,6 +1712,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'dns-prefetch' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1632,6 +1733,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'icon' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1652,6 +1754,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'manifest' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1672,6 +1775,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'modulepreload' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1692,6 +1796,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'pingback' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1712,6 +1817,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preconnect' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1732,6 +1838,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prefetch' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1752,6 +1859,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'preload' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1772,6 +1880,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'prerender' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1792,6 +1901,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'stylesheet' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1812,6 +1922,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveInvalid',
+              data: { reportingValue: 'tag' },
               output: '<form rel=""></form>',
             },
           ],
@@ -1832,6 +1943,7 @@ ruleTester.run('no-invalid-html-attribute', rule, {
           suggestions: [
             {
               messageId: 'suggestRemoveEmpty',
+              data: { attributeName: 'rel' },
               output: '<form ></form>',
             },
           ],
diff --git a/tests/lib/rules/no-is-mounted.js b/tests/lib/rules/no-is-mounted.js
index 9fb5b7d31d..c8b22daabb 100644
--- a/tests/lib/rules/no-is-mounted.js
+++ b/tests/lib/rules/no-is-mounted.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-is-mounted');
 
 const parsers = require('../../helpers/parsers');
@@ -57,6 +57,17 @@ ruleTester.run('no-is-mounted', rule, {
         });
       `,
     },
+    {
+      code: `
+        class Hello extends React.Component {
+          notIsMounted() {}
+          render() {
+            this.notIsMounted();
+            return <div>Hello</div>;
+          }
+        };
+      `,
+    },
   ]),
 
   invalid: parsers.all([
diff --git a/tests/lib/rules/no-multi-comp.js b/tests/lib/rules/no-multi-comp.js
index 37402facbe..db6f09db2c 100644
--- a/tests/lib/rules/no-multi-comp.js
+++ b/tests/lib/rules/no-multi-comp.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-multi-comp');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-namespace.js b/tests/lib/rules/no-namespace.js
index 1056e99d74..2d423e8ad6 100644
--- a/tests/lib/rules/no-namespace.js
+++ b/tests/lib/rules/no-namespace.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-namespace');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-object-type-as-default-prop.js b/tests/lib/rules/no-object-type-as-default-prop.js
index e2660fb938..a2dc01fb85 100644
--- a/tests/lib/rules/no-object-type-as-default-prop.js
+++ b/tests/lib/rules/no-object-type-as-default-prop.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const parsers = require('../../helpers/parsers');
 const rule = require('../../../lib/rules/no-object-type-as-default-prop');
 
@@ -143,6 +143,11 @@ ruleTester.run('no-object-type-as-default-prop', rule, {
         return null;
       };
     `,
+    `
+      const Foo = ({bar = 1}, context) => {
+        return null;
+      };
+    `,
     `
       export default function NotAComponent({foo = {}}) {}
     `
@@ -183,6 +188,24 @@ ruleTester.run('no-object-type-as-default-prop', rule, {
         }
       `,
       errors: expectedViolations,
+    },
+    {
+      code: `
+        const Foo = ({
+          a = {},
+          b = ['one', 'two'],
+          c = /regex/i,
+          d = () => {},
+          e = function() {},
+          f = class {},
+          g = new Thing(),
+          h = <Thing />,
+          i = Symbol('foo')
+        }, context) => {
+          return null;
+        }
+      `,
+      errors: expectedViolations,
     }
   )),
 });
diff --git a/tests/lib/rules/no-redundant-should-component-update.js b/tests/lib/rules/no-redundant-should-component-update.js
index 88e5a3e519..7aafb1e589 100644
--- a/tests/lib/rules/no-redundant-should-component-update.js
+++ b/tests/lib/rules/no-redundant-should-component-update.js
@@ -8,7 +8,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-redundant-should-component-update');
 
 const parsers = require('../../helpers/parsers');
@@ -37,16 +37,6 @@ ruleTester.run('no-redundant-should-component-update', rule, {
       `,
       parserOptions,
     },
-    {
-      code: `
-        class Foo extends React.Component {
-          shouldComponentUpdate() {
-            return true;
-          }
-        }
-      `,
-      parserOptions,
-    },
     {
       code: `
         class Foo extends React.Component {
diff --git a/tests/lib/rules/no-render-return-value.js b/tests/lib/rules/no-render-return-value.js
index 18caa88b5c..bbd7b7f930 100644
--- a/tests/lib/rules/no-render-return-value.js
+++ b/tests/lib/rules/no-render-return-value.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-render-return-value');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-set-state.js b/tests/lib/rules/no-set-state.js
index 3060c8e1d1..5f67e705c5 100644
--- a/tests/lib/rules/no-set-state.js
+++ b/tests/lib/rules/no-set-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-set-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-string-refs.js b/tests/lib/rules/no-string-refs.js
index fba476860d..e52680b446 100644
--- a/tests/lib/rules/no-string-refs.js
+++ b/tests/lib/rules/no-string-refs.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-string-refs');
 
 const parsers = require('../../helpers/parsers');
@@ -59,6 +59,19 @@ ruleTester.run('no-refs', rule, {
         });
       `,
     },
+    {
+      code: `
+        var Hello = createReactClass({
+          componentDidMount: function() {
+            var component = this.refs.hello;
+          },
+          render: function() {
+            return <div>Hello {this.props.name}</div>;
+          }
+        });
+      `,
+      settings: { react: { version: '18.3.0' } },
+    },
   ]),
 
   invalid: parsers.all([
@@ -73,6 +86,7 @@ ruleTester.run('no-refs', rule, {
           }
         });
       `,
+      settings: { react: { version: '18.2.0' } },
       errors: [{ messageId: 'thisRefsDeprecated' }],
     },
     {
@@ -83,6 +97,7 @@ ruleTester.run('no-refs', rule, {
           }
         });
       `,
+      settings: { react: { version: '18.2.0' } },
       errors: [{ messageId: 'stringInRefDeprecated' }],
     },
     {
@@ -93,6 +108,7 @@ ruleTester.run('no-refs', rule, {
           }
         });
       `,
+      settings: { react: { version: '18.2.0' } },
       errors: [{ messageId: 'stringInRefDeprecated' }],
     },
     {
@@ -106,6 +122,7 @@ ruleTester.run('no-refs', rule, {
           }
         });
       `,
+      settings: { react: { version: '18.2.0' } },
       errors: [
         { messageId: 'thisRefsDeprecated' },
         { messageId: 'stringInRefDeprecated' },
@@ -123,6 +140,7 @@ ruleTester.run('no-refs', rule, {
         });
       `,
       options: [{ noTemplateLiterals: true }],
+      settings: { react: { version: '18.2.0' } },
       errors: [
         { messageId: 'thisRefsDeprecated' },
         { messageId: 'stringInRefDeprecated' },
@@ -140,10 +158,28 @@ ruleTester.run('no-refs', rule, {
         });
       `,
       options: [{ noTemplateLiterals: true }],
+      settings: { react: { version: '18.2.0' } },
       errors: [
         { messageId: 'thisRefsDeprecated' },
         { messageId: 'stringInRefDeprecated' },
       ],
     },
+    {
+      code: `
+        var Hello = createReactClass({
+          componentDidMount: function() {
+          var component = this.refs.hello;
+          },
+          render: function() {
+            return <div ref={\`hello\${index}\`}>Hello {this.props.name}</div>;
+          }
+        });
+      `,
+      options: [{ noTemplateLiterals: true }],
+      settings: { react: { version: '18.3.0' } },
+      errors: [
+        { messageId: 'stringInRefDeprecated' },
+      ],
+    },
   ]),
 });
diff --git a/tests/lib/rules/no-this-in-sfc.js b/tests/lib/rules/no-this-in-sfc.js
index 2c291ce9f8..ce0abb77ba 100644
--- a/tests/lib/rules/no-this-in-sfc.js
+++ b/tests/lib/rules/no-this-in-sfc.js
@@ -8,7 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-this-in-sfc');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-typos.js b/tests/lib/rules/no-typos.js
index ee68f3407e..0aaddfd290 100644
--- a/tests/lib/rules/no-typos.js
+++ b/tests/lib/rules/no-typos.js
@@ -11,7 +11,7 @@
 const babelEslintVersion = require('babel-eslint/package.json').version;
 const semver = require('semver');
 const version = require('eslint/package.json').version;
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/no-typos');
 
diff --git a/tests/lib/rules/no-unescaped-entities.js b/tests/lib/rules/no-unescaped-entities.js
index 2eeab50ebb..4e62a82eb3 100644
--- a/tests/lib/rules/no-unescaped-entities.js
+++ b/tests/lib/rules/no-unescaped-entities.js
@@ -20,7 +20,7 @@ try {
   allowsInvalidJSX = semver.satisfies(require(resolve.sync('acorn-jsx/package.json', { basedir: path.dirname(require.resolve('eslint')) })).version, '< 5.2');
 } catch (e) { /**/ }
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unescaped-entities');
 
 const parsers = require('../../helpers/parsers');
@@ -135,6 +135,19 @@ ruleTester.run('no-unescaped-entities', rule, {
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '>', alts: '`&gt;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&gt;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>&gt; default parser</div>;
+            }
+          });
+        `,
+              },
+            ],
           },
         ],
       },
@@ -152,6 +165,21 @@ ruleTester.run('no-unescaped-entities', rule, {
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '>', alts: '`&gt;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&gt;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>first line is ok
+              so is second
+              and here are some bad entities: &gt;</div>
+            }
+          });
+        `,
+              },
+            ],
           },
         ],
       },
@@ -167,14 +195,86 @@ ruleTester.run('no-unescaped-entities', rule, {
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '\'', alts: '`&apos;`, `&lsquo;`, `&#39;`, `&rsquo;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&apos;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: &apos;>> default parser</div>;
+            }
+          });
+        `,
+              },
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&lsquo;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: &lsquo;>> default parser</div>;
+            }
+          });
+        `,
+              },
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&#39;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: &#39;>> default parser</div>;
+            }
+          });
+        `,
+              },
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&rsquo;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: &rsquo;>> default parser</div>;
+            }
+          });
+        `,
+              },
+            ],
           },
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '>', alts: '`&gt;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&gt;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: '&gt;> default parser</div>;
+            }
+          });
+        `,
+              },
+            ],
           },
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '>', alts: '`&gt;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&gt;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>Multiple errors: '>&gt; default parser</div>;
+            }
+          });
+        `,
+              },
+            ],
           },
         ],
       },
@@ -190,6 +290,19 @@ ruleTester.run('no-unescaped-entities', rule, {
           {
             messageId: 'unescapedEntityAlts',
             data: { entity: '}', alts: '`&#125;`' },
+            suggestions: [
+              {
+                messageId: 'replaceWithAlt',
+                data: { alt: '&#125;' },
+                output: `
+          var Hello = createReactClass({
+            render: function() {
+              return <div>{"Unbalanced braces - default parser"}&#125;</div>;
+            }
+          });
+        `,
+              },
+            ],
           },
         ],
       },
@@ -207,6 +320,19 @@ ruleTester.run('no-unescaped-entities', rule, {
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '>', alts: '`&gt;`' },
+          suggestions: [
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&gt;' },
+              output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <>&gt; babel-eslint</>;
+          }
+        });
+      `,
+            },
+          ],
         },
       ],
     },
@@ -225,6 +351,19 @@ ruleTester.run('no-unescaped-entities', rule, {
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '>', alts: '`&gt;`' },
+          suggestions: [{
+            messageId: 'replaceWithAlt',
+            data: { alt: '&gt;' },
+            output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <>first line is ok
+            so is second
+            and here are some bad entities: &gt;</>
+          }
+        });
+      `,
+          }],
         },
       ],
     },
@@ -240,6 +379,52 @@ ruleTester.run('no-unescaped-entities', rule, {
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '\'', alts: '`&apos;`, `&lsquo;`, `&#39;`, `&rsquo;`' },
+          suggestions: [
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&apos;' },
+              output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <div>&apos;</div>;
+          }
+        });
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&lsquo;' },
+              output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <div>&lsquo;</div>;
+          }
+        });
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&#39;' },
+              output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <div>&#39;</div>;
+          }
+        });
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&rsquo;' },
+              output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <div>&rsquo;</div>;
+          }
+        });
+      `,
+            },
+          ],
         },
       ],
     },
@@ -256,6 +441,17 @@ ruleTester.run('no-unescaped-entities', rule, {
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '}', alts: '`&#125;`' },
+          suggestions: [{
+            messageId: 'replaceWithAlt',
+            data: { alt: '&#125;' },
+            output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <>{"Unbalanced braces - babel-eslint"}&#125;</>;
+          }
+        });
+      `,
+          }],
         },
       ],
     },
@@ -304,6 +500,17 @@ ruleTester.run('no-unescaped-entities', rule, {
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '&', alts: '`&amp;`' },
+          suggestions: [{
+            messageId: 'replaceWithAlt',
+            data: { alt: '&amp;' },
+            output: `
+        var Hello = createReactClass({
+          render: function() {
+            return <span>foo &amp; bar</span>;
+          }
+        });
+      `,
+          }],
         },
       ],
       options: [
@@ -327,12 +534,72 @@ ruleTester.run('no-unescaped-entities', rule, {
           data: { entity: '"', alts: '`&quot;`, `&ldquo;`, `&#34;`, `&rdquo;`' },
           line: 2,
           column: 30,
+          suggestions: [
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&quot;' },
+              output: `
+        <script>window.foo = &quot;bar"</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&ldquo;' },
+              output: `
+        <script>window.foo = &ldquo;bar"</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&#34;' },
+              output: `
+        <script>window.foo = &#34;bar"</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&rdquo;' },
+              output: `
+        <script>window.foo = &rdquo;bar"</script>
+      `,
+            },
+          ],
         },
         {
           messageId: 'unescapedEntityAlts',
           data: { entity: '"', alts: '`&quot;`, `&ldquo;`, `&#34;`, `&rdquo;`' },
           line: 2,
           column: 34,
+          suggestions: [
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&quot;' },
+              output: `
+        <script>window.foo = "bar&quot;</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&ldquo;' },
+              output: `
+        <script>window.foo = "bar&ldquo;</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&#34;' },
+              output: `
+        <script>window.foo = "bar&#34;</script>
+      `,
+            },
+            {
+              messageId: 'replaceWithAlt',
+              data: { alt: '&rdquo;' },
+              output: `
+        <script>window.foo = "bar&rdquo;</script>
+      `,
+            },
+          ],
         },
       ],
     }
diff --git a/tests/lib/rules/no-unknown-property.js b/tests/lib/rules/no-unknown-property.js
index 3c20feebd4..ab0d5fb6d0 100644
--- a/tests/lib/rules/no-unknown-property.js
+++ b/tests/lib/rules/no-unknown-property.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unknown-property');
 
 const parsers = require('../../helpers/parsers');
@@ -41,12 +41,16 @@ ruleTester.run('no-unknown-property', rule, {
       features: ['jsx namespace'],
     },
     { code: '<App clip-path="bar" />;' },
+    {
+      code: '<App dataNotAnDataAttribute="yes" />;',
+      options: [{ requireDataLowercase: true }],
+    },
     // Some HTML/DOM elements with common attributes should work
     { code: '<div className="bar"></div>;' },
     { code: '<div onMouseDown={this._onMouseDown}></div>;' },
     { code: '<a href="someLink" download="foo">Read more</a>' },
     { code: '<area download="foo" />' },
-    { code: '<img src="cat_keyboard.jpeg" alt="A cat sleeping on a keyboard" align="top" />' },
+    { code: '<img src="cat_keyboard.jpeg" alt="A cat sleeping on a keyboard" align="top" fetchPriority="high" />' },
     { code: '<input type="password" required />' },
     { code: '<input ref={this.input} type="radio" />' },
     { code: '<input type="file" webkitdirectory="" />' },
@@ -70,11 +74,13 @@ ruleTester.run('no-unknown-property', rule, {
     { code: '<link onLoad={bar} onError={foo} />' },
     { code: '<link rel="preload" as="image" href="someHref" imageSrcSet="someImageSrcSet" imageSizes="someImageSizes" />' },
     { code: '<object onLoad={bar} />' },
+    { code: '<body onLoad={bar} />' },
     { code: '<video allowFullScreen webkitAllowFullScreen mozAllowFullScreen />' },
     { code: '<iframe allowFullScreen webkitAllowFullScreen mozAllowFullScreen />' },
     { code: '<table border="1" />' },
     { code: '<th abbr="abbr" />' },
     { code: '<td abbr="abbr" />' },
+    { code: '<template shadowrootmode="open" shadowrootclonable shadowrootdelegatesfocus shadowrootserializable />' },
     {
       code: '<div allowTransparency="true" />',
       settings: {
@@ -85,6 +91,12 @@ ruleTester.run('no-unknown-property', rule, {
     { code: '<div onPointerDown={this.onDown} onPointerUp={this.onUp} />' },
     { code: '<input type="checkbox" defaultChecked={this.state.checkbox} />' },
     { code: '<div onTouchStart={this.startAnimation} onTouchEnd={this.stopAnimation} onTouchCancel={this.cancel} onTouchMove={this.move} onMouseMoveCapture={this.capture} onTouchCancelCapture={this.log} />' },
+    {
+      code: '<link precedence="medium" href="https://foo.bar" rel="canonical" />',
+      settings: {
+        react: { version: '19.0.0' },
+      },
+    },
     // Case ignored attributes, for `charset` discussion see https://github.com/jsx-eslint/eslint-plugin-react/pull/1863
     { code: '<meta charset="utf-8" />;' },
     { code: '<meta charSet="utf-8" />;' },
@@ -169,6 +181,24 @@ ruleTester.run('no-unknown-property', rule, {
         </div>
       `,
     },
+    {
+      code: `
+        <div>
+          <button popovertarget="my-popover" popovertargetaction="toggle">Open Popover</button>
+
+          <div popover id="my-popover">Greetings, one and all!</div>
+        </div>
+      `,
+    },
+    {
+      code: `
+        <div>
+          <button popoverTarget="my-popover" popoverTargetAction="toggle">Open Popover</button>
+
+          <div id="my-popover" onBeforeToggle={this.onBeforeToggle} popover>Greetings, one and all!</div>
+        </div>
+      `,
+    },
   ]),
   invalid: parsers.all([
     {
@@ -348,8 +378,8 @@ ruleTester.run('no-unknown-property', rule, {
       ],
     },
     {
-      code: '<rect clip-path="bar" />;',
-      output: '<rect clipPath="bar" />;',
+      code: '<rect clip-path="bar" transform-origin="center" />;',
+      output: '<rect clipPath="bar" transform-origin="center" />;',
       errors: [
         {
           messageId: 'unknownPropWithStandardName',
@@ -480,7 +510,7 @@ ruleTester.run('no-unknown-property', rule, {
           data: {
             name: 'onLoad',
             tagName: 'div',
-            allowedTags: 'script, img, link, picture, iframe, object, source',
+            allowedTags: 'script, img, link, picture, iframe, object, source, body',
           },
         },
       ],
@@ -594,7 +624,34 @@ ruleTester.run('no-unknown-property', rule, {
       ],
     },
     {
-      code: '<div data-testID="bar" data-under_sCoRe="bar" />;',
+      code: '<div data-testID="bar" data-under_sCoRe="bar" dataNotAnDataAttribute="yes" />;',
+      errors: [
+        {
+          messageId: 'dataLowercaseRequired',
+          data: {
+            name: 'data-testID',
+            lowerCaseName: 'data-testid',
+          },
+        },
+        {
+          messageId: 'dataLowercaseRequired',
+          data: {
+            name: 'data-under_sCoRe',
+            lowerCaseName: 'data-under_score',
+          },
+        },
+        {
+          messageId: 'unknownProp',
+          data: {
+            name: 'dataNotAnDataAttribute',
+            lowerCaseName: 'datanotandataattribute',
+          },
+        },
+      ],
+      options: [{ requireDataLowercase: true }],
+    },
+    {
+      code: '<App data-testID="bar" data-under_sCoRe="bar" dataNotAnDataAttribute="yes" />;',
       errors: [
         {
           messageId: 'dataLowercaseRequired',
diff --git a/tests/lib/rules/no-unsafe.js b/tests/lib/rules/no-unsafe.js
index 66c45f1d51..3dc180be22 100644
--- a/tests/lib/rules/no-unsafe.js
+++ b/tests/lib/rules/no-unsafe.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unsafe');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-unstable-nested-components.js b/tests/lib/rules/no-unstable-nested-components.js
index a27444ebfd..8a9c0aad47 100644
--- a/tests/lib/rules/no-unstable-nested-components.js
+++ b/tests/lib/rules/no-unstable-nested-components.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unstable-nested-components');
 
 const parsers = require('../../helpers/parsers');
@@ -580,6 +580,18 @@ ruleTester.run('no-unstable-nested-components', rule, {
         allowAsProps: true,
       }],
     },
+    {
+      code: `
+        function ParentComponent() {
+          return <Table
+            rowRenderer={(rowData) => <Row data={data} />}
+          />
+        }
+      `,
+      options: [{
+        propNamePattern: '*Renderer',
+      }],
+    },
     /* TODO These minor cases are currently falsely marked due to component detection
     {
       code: `
diff --git a/tests/lib/rules/no-unused-class-component-methods.js b/tests/lib/rules/no-unused-class-component-methods.js
index dd22101067..deccb47a07 100644
--- a/tests/lib/rules/no-unused-class-component-methods.js
+++ b/tests/lib/rules/no-unused-class-component-methods.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unused-class-component-methods');
 const parsers = require('../../helpers/parsers');
 
diff --git a/tests/lib/rules/no-unused-prop-types.js b/tests/lib/rules/no-unused-prop-types.js
index c80c37f4cf..943db3048e 100644
--- a/tests/lib/rules/no-unused-prop-types.js
+++ b/tests/lib/rules/no-unused-prop-types.js
@@ -12,7 +12,7 @@
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
 const babelEslintVersion = require('babel-eslint/package.json').version;
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 require('object.entries/auto'); // for node 6, eslint 5, new TS parser, `function Hello({firstname}: Props): React$Element {` cases
 
diff --git a/tests/lib/rules/no-unused-state.js b/tests/lib/rules/no-unused-state.js
index cf7d50a3cc..e08197e589 100644
--- a/tests/lib/rules/no-unused-state.js
+++ b/tests/lib/rules/no-unused-state.js
@@ -5,8 +5,8 @@
 'use strict';
 
 const semver = require('semver');
-const RuleTester = require('eslint').RuleTester;
 const tsEslintVersion = require('@typescript-eslint/parser/package.json').version;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-unused-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/no-will-update-set-state.js b/tests/lib/rules/no-will-update-set-state.js
index 5c3408f1df..be3895c4e6 100644
--- a/tests/lib/rules/no-will-update-set-state.js
+++ b/tests/lib/rules/no-will-update-set-state.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/no-will-update-set-state');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/prefer-es6-class.js b/tests/lib/rules/prefer-es6-class.js
index cf5530ef53..369b22ec58 100644
--- a/tests/lib/rules/prefer-es6-class.js
+++ b/tests/lib/rules/prefer-es6-class.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/prefer-es6-class');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/prefer-exact-props.js b/tests/lib/rules/prefer-exact-props.js
index 03563add80..697c35cfa2 100644
--- a/tests/lib/rules/prefer-exact-props.js
+++ b/tests/lib/rules/prefer-exact-props.js
@@ -8,7 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/prefer-exact-props');
 const parsers = require('../../helpers/parsers');
 
diff --git a/tests/lib/rules/prefer-read-only-props.js b/tests/lib/rules/prefer-read-only-props.js
index 071f3568a5..bf7668042b 100644
--- a/tests/lib/rules/prefer-read-only-props.js
+++ b/tests/lib/rules/prefer-read-only-props.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/prefer-read-only-props');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/prefer-stateless-function.js b/tests/lib/rules/prefer-stateless-function.js
index 1d6c8c358c..5ceee4ab22 100644
--- a/tests/lib/rules/prefer-stateless-function.js
+++ b/tests/lib/rules/prefer-stateless-function.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/prefer-stateless-function');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/prop-types.js b/tests/lib/rules/prop-types.js
index 049e387da6..f851057a16 100644
--- a/tests/lib/rules/prop-types.js
+++ b/tests/lib/rules/prop-types.js
@@ -12,7 +12,7 @@
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json').version;
 const babelEslintVersion = require('babel-eslint/package.json').version;
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/prop-types');
 
@@ -1588,15 +1588,6 @@ ruleTester.run('prop-types', rule, {
         }
       `,
     },
-    {
-      // Async generator functions can't be components.
-      code: `
-        var Hello = async function* (props) {
-          yield null;
-          return <div>Hello {props.name}</div>;
-        }
-      `,
-    },
     {
       // Flow annotations with variance
       code: `
@@ -1632,7 +1623,7 @@ ruleTester.run('prop-types', rule, {
           handleDeleteConfirm = () => {
             this.props.onDelete();
           };
-          handleSubmit = async ({certificate, key}) => {};
+          handleSubmit = async ({ certificate, key }) => {};
         }
       `,
       features: ['class fields'],
@@ -1684,7 +1675,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        import type {Data} from './Data'
+        import type { Data } from './Data'
         type Person = {
           ...Data,
           lastname: string
@@ -1700,7 +1691,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        import type {Data} from 'some-libdef-like-flow-typed-provides'
+        import type { Data } from 'some-libdef-like-flow-typed-provides'
         type Person = {
           ...Data,
           lastname: string
@@ -1716,7 +1707,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        import type {BasePerson} from './types'
+        import type { BasePerson } from './types'
         type Props = {
           person: {
            ...$Exact<BasePerson>,
@@ -1820,7 +1811,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {name: {firstname: string;};};
+        type Props = { name: { firstname: string; }; };
         class Hello extends React.Component<void, Props, void> {
           render () {
             return <div>Hello {this.props.name.firstname}</div>;
@@ -1831,7 +1822,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {name: {firstname: string;};};
+        type Props = { name: { firstname: string; }; };
         class Hello extends React.Component<void, Props, void> {
           render () {
             return <div>Hello {this.props.name.firstname}</div>;
@@ -1843,7 +1834,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Note = {text: string, children?: Note[]};
+        type Note = { text: string, children?: Note[] };
         type Props = {
           notes: Note[];
         };
@@ -1908,7 +1899,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {result?: {ok?: ?string | boolean;}|{ok?: ?number | Array}};
+        type Props = { result?: { ok?: ?string | boolean; } | { ok?: ?number | Array } };
         class Hello extends React.Component<void, Props, void> {
           render () {
             return <div>Hello {this.props.result.ok}</div>;
@@ -1919,7 +1910,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {result?: {ok?: ?string | boolean;}|{ok?: ?number | Array}};
+        type Props = { result?: { ok?: ?string | boolean;} | { ok?: ?number | Array } };
         class Hello extends React.Component<void, Props, void> {
           render () {
             return <div>Hello {this.props.result.ok}</div>;
@@ -2115,14 +2106,14 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        const withOverlayState = <P: {foo: string}>(WrappedComponent: ComponentType<P>): ComponentType<P> => (
+        const withOverlayState = <P: { foo: string }>(WrappedComponent: ComponentType<P>): ComponentType<P> => (
           class extends React.Component<P> {
             constructor(props) {
               super(props);
-              this.state = {foo: props.foo}
+              this.state = { foo: props.foo };
             }
             render() {
-              return <div>Hello World</div>
+              return <div>Hello World</div>;
             }
           }
         )
@@ -2132,9 +2123,9 @@ ruleTester.run('prop-types', rule, {
 
     // issue #1288
     `function Foo() {
-      const props = {}
-      props.bar = 'bar'
-      return <div {...props} />
+      const props = {};
+      props.bar = 'bar';
+      return <div {...props} />;
     }`,
     // issue #1288
     `function Foo(props) {
@@ -2170,19 +2161,19 @@ ruleTester.run('prop-types', rule, {
     {
       code: `
       // @flow
-      import * as React from 'react'
+      import * as React from 'react';
 
-      type Props = {}
+      type Props = {};
 
-      const func = <OP: *>(arg) => arg
+      const func = <OP: *>(arg) => arg;
 
       const hoc = <OP>() => () => {
         class Inner extends React.Component<Props & OP> {
           render() {
-            return <div />
+            return <div />;
           }
         }
-      }
+      };
     `,
       features: ['flow'],
     },
@@ -2225,7 +2216,7 @@ ruleTester.run('prop-types', rule, {
         class Foo extends React.Component {
           bar() {
             this.setState((state, props) => {
-              function f(_, {aaaaaaa}) {}
+              function f(_, { aaaaaaa }) {}
             });
           }
         }
@@ -2468,7 +2459,7 @@ ruleTester.run('prop-types', rule, {
       code: `
         import React from 'react';
         import PropTypes from 'prop-types';
-        import {connect} from 'react-redux';
+        import { connect } from 'react-redux';
 
         class Foo extends React.Component {
           render() {
@@ -2547,7 +2538,7 @@ ruleTester.run('prop-types', rule, {
     {
       // issue #2326
       code: `
-        for (const {result} of results) {}
+        for (const { result } of results) {}
       `,
     },
     {
@@ -2609,7 +2600,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        const Foo = ({length, ordering}) => (
+        const Foo = ({ length, ordering }) => (
           length > 0 && (
             <Paginator items={ordering} pageSize={10} />
           )
@@ -3094,7 +3085,7 @@ ruleTester.run('prop-types', rule, {
       }
 
       const mapDispatchToProps = (dispatch: ThunkDispatch<State, null, Action>) => ({
-        ...bindActionCreators<{prop1: ()=>void,prop2: ()=>string}>(
+        ...bindActionCreators<{ prop1: ()=>void, prop2: ()=>string }>(
           { prop1: importedAction, prop2: anotherImportedAction },
           dispatch,
         ),
@@ -3150,7 +3141,7 @@ ruleTester.run('prop-types', rule, {
       }
 
       const mapDispatchToProps = (dispatch: ThunkDispatch<State, null, Action>) =>
-        bindActionCreators<{prop1: ()=>void,prop2: ()=>string}>(
+        bindActionCreators<{ prop1: () => void, prop2: () => string }>(
           { prop1: importedAction, prop2: anotherImportedAction },
           dispatch,
         )
@@ -3361,6 +3352,20 @@ ruleTester.run('prop-types', rule, {
       `,
       features: ['ts', 'no-babel'],
     },
+    {
+      code: `
+        import React from "react";
+
+        const returnTypeProp = (someProp: any) => ({ someProp });
+
+        const SomeComponent: React.FunctionComponent<
+          ReturnType<typeof returnTypeProp>
+        > = ({ someProp }) => {
+          return <div>{someProp}</div>;
+        };
+      `,
+      features: ['ts', 'no-babel'],
+    },
     {
       code: `
         export const EuiSuperSelectControl: <T extends string>(
@@ -3392,7 +3397,7 @@ ruleTester.run('prop-types', rule, {
         };
 
         const Button = <T,>({ onClick, value }: Props<T>) => {
-          return <button onClick={() => onClick(value)}>BUTTON</button>;
+          return <button type="button" onClick={() => onClick(value)}>BUTTON</button>;
         };
       `,
       features: ['ts', 'no-babel'],
@@ -3660,7 +3665,7 @@ ruleTester.run('prop-types', rule, {
         export type Props = { children: React.ReactNode; type: "submit" | "button" };
 
         export const FancyButton = forwardRef<HTMLButtonElement, Props>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.type}>
+          <button type="button" ref={ref} className="MyClassName" type={props.type}>
             {props.children}
           </button>
         ));
@@ -3675,7 +3680,7 @@ ruleTester.run('prop-types', rule, {
         export type Props = { children: React.ReactNode; type: "submit" | "button" } & X;
 
         export const FancyButton = forwardRef<HTMLButtonElement, Props>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.type} num={props.num}>
+          <button type="button" ref={ref} className="MyClassName" type={props.type} num={props.num}>
             {props.children}
           </button>
         ));
@@ -3692,7 +3697,7 @@ ruleTester.run('prop-types', rule, {
         }
 
         export const FancyButton = forwardRef<HTMLButtonElement, IProps>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.type}>
+          <button type="button" ref={ref} className="MyClassName" type={props.type}>
             {props.children}
           </button>
         ));
@@ -3712,7 +3717,7 @@ ruleTester.run('prop-types', rule, {
         }
 
         export const FancyButton = forwardRef<HTMLButtonElement, IProps>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.type} num={props.num}>
+          <button type="button" ref={ref} className="MyClassName" type={props.type} num={props.num}>
             {props.children}
           </button>
         ));
@@ -3738,18 +3743,18 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        import React, {PropTypes} from 'react'
+        import React, { PropTypes } from 'react'
 
-        function Foo({bar}) {
-          const {baz} = Foo
+        function Foo({ bar }) {
+          const { baz } = Foo;
           return <div>{baz} {bar}</div>
         }
 
         Foo.propTypes = {
           bar: PropTypes.string.isRequired,
-        }
+        };
 
-        Foo.baz = 'hi'
+        Foo.baz = 'hi';
       `,
     },
 
@@ -3849,7 +3854,7 @@ ruleTester.run('prop-types', rule, {
       code: `
         class Test extends React.Component {
           componentDidUpdate() {
-              const {bar} = this.state;
+              const { bar } = this.state;
               console.log(bar);
           }
 
@@ -3958,157 +3963,941 @@ ruleTester.run('prop-types', rule, {
           }
         });
       `,
-      features: ['types'],
+      features: ['types'],
+    },
+    {
+      code: `
+        import PropTypes from 'prop-types';
+        import React from 'react';
+
+        import { Link } from '..';
+
+        const LinkWrapper = ({ primaryLinks }) => (
+          <>
+            {primaryLinks.map((x, index) => (
+              <Link key={index} href={x.link}>
+                {x.text}
+              </Link>
+            ))}
+          </>
+        );
+
+        LinkWrapper.propTypes = {
+          primaryLinks: PropTypes.arrayOf(
+            PropTypes.shape({
+              text: PropTypes.string,
+            })
+          ),
+        };
+
+        export default LinkWrapper;
+      `,
+      features: ['fragment'],
+    },
+    {
+      code: `
+        const projectType = PropTypes.shape({
+          id: PropTypes.string.isRequired,
+          name: PropTypes.string.isRequired,
+        });
+
+        const nodesType = PropTypes.arrayOf(
+          PropTypes.shape({ project: projectType, children: nodesType }),
+        );
+
+        class ProjectNode extends React.Component {
+          render() {
+            return <div />;
+          }
+        }
+
+        ProjectNode.propTypes = {
+          project: projectType.isRequired,
+          nodes: nodesType,
+          depth: PropTypes.number.isRequired,
+          setActiveProject: PropTypes.func.isRequired,
+          activeProject: projectType,
+        };
+      `,
+    },
+    {
+      code: `
+        import React from 'react';
+
+        interface SomeType<ContextType = any> {
+          renderValue: (context: ContextType) => React.ReactNode;
+        }
+
+        interface DataObject {
+          id: string,
+          title: string,
+          value: string,
+        }
+
+        const someType: SomeType<DataObject> = {
+          renderValue: ({ title }) => <div>{title}</div>,
+        };
+      `,
+      features: ['types'],
+    },
+    {
+      code: `
+        <MyComponent
+          options={{
+            tabBarIcon: ({ color, size }) => (
+              <Icon name="dumbbell" size={size} color={color} />
+            )
+          }}
+        />
+      `,
+    },
+    {
+      code: `
+        import React, { forwardRef } from 'react';
+        import { ControlProps, NamedProps } from './ext';
+
+        type ButtonProps = ControlProps & NamedProps & {
+          onClick?: (() => void) | undefined;
+          onMouseDown?: (() => void) | undefined;
+          onMouseUp?: (() => void) | undefined;
+          disabled?: boolean | undefined;
+          width?: number;
+          type?: 'submit' | 'reset' | 'button' | undefined;
+        };
+
+        const BaseButton = forwardRef<HTMLButtonElement, ButtonProps>((
+          {
+            name,
+            className,
+            onClick,
+            onMouseDown,
+            onMouseUp,
+            children,
+            disabled,
+            width,
+            type,
+          },
+          ref,
+        ): JSX.Element => {
+          return <span>{width}</span>;
+        });
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, { forwardRef } from 'react';
+        import { ControlProps, NamedProps } from './ext';
+
+        interface ButtonProps extends NamedProps {
+          onClick?: (() => void) | undefined;
+          onMouseDown?: (() => void) | undefined;
+          onMouseUp?: (() => void) | undefined;
+          disabled?: boolean | undefined;
+          width?: number;
+          type?: 'submit' | 'reset' | 'button' | undefined;
+        };
+
+        const BaseButton = forwardRef<HTMLButtonElement, ButtonProps>((
+          {
+            name,
+            className,
+            onClick,
+            onMouseDown,
+            onMouseUp,
+            children,
+            disabled,
+            width,
+            type,
+          },
+          ref,
+        ): JSX.Element => {
+          return <span>{width}</span>;
+        });
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentPropsWithoutRef, forwardRef } from 'react';
+
+        export const FancyButton = forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentPropsWithRef, forwardRef } from "react";
+
+        export const FancyButton = forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, forwardRef } from "react";
+
+        export const FancyButton = forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentPropsWithoutRef, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentPropsWithRef, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, ComponentPropsWithoutRef, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, ComponentPropsWithoutRef, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, ComponentPropsWithRef, ElementRef, forwardRef } from "react";
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import { ComponentProps, ComponentPropsWithRef, ElementRef, forwardRef } from 'react';
+
+        const BaseButton = forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import * as React from "react";
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<React.ElementRef<typeof BaseButton>, React.ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, {ComponentPropsWithoutRef } from 'react';
+
+        export const FancyButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
     },
     {
       code: `
-        import PropTypes from 'prop-types';
-        import React from 'react';
+        import React, { ComponentPropsWithRef } from 'react';
 
-        import { Link } from '..';
+        export const FancyButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, { ComponentProps } from 'react';
 
-        const LinkWrapper = ({ primaryLinks }) => (
-          <>
-            {primaryLinks.map((x, index) => (
-              <Link key={index} href={x.link}>
-                {x.text}
-              </Link>
-            ))}
-          </>
+        export const FancyButton = React.forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ className, children, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+              {children}
+            </button>
+          ),
         );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, { ComponentPropsWithoutRef, ElementRef } from 'react';
 
-        LinkWrapper.propTypes = {
-          primaryLinks: PropTypes.arrayOf(
-            PropTypes.shape({
-              text: PropTypes.string,
-            })
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
           ),
-        };
+        );
 
-        export default LinkWrapper;
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
-      features: ['fragment'],
+      features: ['ts', 'no-babel'],
     },
     {
       code: `
-        const projectType = PropTypes.shape({
-          id: PropTypes.string.isRequired,
-          name: PropTypes.string.isRequired,
-        });
+        import React, { ComponentPropsWithRef, ElementRef } from 'react';
 
-        const nodesType = PropTypes.arrayOf(
-          PropTypes.shape({ project: projectType, children: nodesType }),
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
         );
 
-        class ProjectNode extends React.Component {
-          render() {
-            return <div />;
-          }
-        }
-
-        ProjectNode.propTypes = {
-          project: projectType.isRequired,
-          nodes: nodesType,
-          depth: PropTypes.number.isRequired,
-          setActiveProject: PropTypes.func.isRequired,
-          activeProject: projectType,
-        };
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
+      features: ['ts', 'no-babel'],
     },
     {
       code: `
-        import React from 'react';
+        import React, { ComponentProps, ElementRef } from 'react';
 
-        interface SomeType<ContextType = any> {
-          renderValue: (context: ContextType) => React.ReactNode;
-        }
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
 
-        interface DataObject {
-          id: string,
-          title: string,
-          value: string,
-        }
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
+      `,
+      features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, { ComponentProps, ComponentPropsWithoutRef, ElementRef } from 'react';
 
-        const someType: SomeType<DataObject> = {
-          renderValue: ({title}) => <div>{title}</div>,
-        };
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithoutRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
-      features: ['types'],
+      features: ['ts', 'no-babel'],
     },
     {
       code: `
-        <MyComponent
-          options={{
-            tabBarIcon: ({ color, size }) => (
-              <Icon name="dumbbell" size={size} color={color} />
-            )
-          }}
-        />
+        import React, { ComponentProps, ComponentPropsWithoutRef, ElementRef } from 'react';
+
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
+
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithoutRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
+      features: ['ts', 'no-babel'],
     },
     {
       code: `
-        import React, { forwardRef } from 'react';
-        import { ControlProps, NamedProps } from './ext';
+        import React, { ComponentProps, ComponentPropsWithRef, ElementRef } from 'react';
 
-        type ButtonProps = ControlProps & NamedProps & {
-          onClick?: (() => void) | undefined;
-          onMouseDown?: (() => void) | undefined;
-          onMouseUp?: (() => void) | undefined;
-          disabled?: boolean | undefined;
-          width?: number;
-          type?: 'submit' | 'reset' | 'button' | undefined;
-        };
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentPropsWithRef<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
 
-        const BaseButton = forwardRef<HTMLButtonElement, ButtonProps>((
-          {
-            name,
-            className,
-            onClick,
-            onMouseDown,
-            onMouseUp,
-            children,
-            disabled,
-            width,
-            type,
-          },
-          ref,
-        ): JSX.Element => {
-          return <span>{width}</span>;
-        });
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentProps<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
       features: ['ts', 'no-babel'],
     },
     {
       code: `
-        import React, { forwardRef } from 'react';
-        import { ControlProps, NamedProps } from './ext';
+        import React, { ComponentProps, ComponentPropsWithRef, ElementRef } from 'react';
 
-        interface ButtonProps extends NamedProps {
-          onClick?: (() => void) | undefined;
-          onMouseDown?: (() => void) | undefined;
-          onMouseUp?: (() => void) | undefined;
-          disabled?: boolean | undefined;
-          width?: number;
-          type?: 'submit' | 'reset' | 'button' | undefined;
-        };
+        const BaseButton = React.forwardRef<HTMLButtonElement, ComponentProps<"button">>(
+          ({ children, className, ...props }, ref) => (
+            <button type="button" ref={ref} className={className} {...props}>
+                {children}
+            </button>
+          ),
+        );
 
-        const BaseButton = forwardRef<HTMLButtonElement, ButtonProps>((
-          {
-            name,
-            className,
-            onClick,
-            onMouseDown,
-            onMouseUp,
-            children,
-            disabled,
-            width,
-            type,
-          },
-          ref,
-        ): JSX.Element => {
-          return <span>{width}</span>;
-        });
+        export const FancyButton = React.forwardRef<ElementRef<typeof BaseButton>, ComponentPropsWithRef<typeof BaseButton>>(
+          ({ children, className, ...props }, ref) => (
+            <BaseButton ref={ref} className={className} {...props}>
+              {children}
+            </BaseButton>
+          ),
+        );
       `,
       features: ['ts', 'no-babel'],
     },
@@ -4141,6 +4930,69 @@ ruleTester.run('prop-types', rule, {
         };
       `,
       features: ['ts', 'no-babel'],
+    },
+    {
+      code: `
+        import React, { memo } from 'react';
+        interface Props1 {
+            age: number;
+        }
+        const HelloTemp = memo(({ age }: Props1) => {
+            return <div>Hello {age}</div>;
+        });
+        export const Hello = HelloTemp
+      `,
+      features: ['types'],
+    },
+    {
+      code: `
+        import React, { forwardRef, memo } from 'react';
+        interface Props1 {
+            age: number;
+        }
+        const HelloTemp = forwardRef(({ age }: Props1) => {
+            return <div>Hello {age}</div>;
+        });
+        export const Hello = memo(HelloTemp);
+      `,
+      features: ['types'],
+    },
+    {
+      code: `
+        import React, { forwardRef, memo } from 'react';
+        interface Props1 {
+            age: number;
+        }
+        export const Hello = memo(
+            forwardRef(({ age }: Props1) => {
+                return <div>Hello {age}</div>;
+            }),
+        );
+      `,
+      features: ['types'],
+    },
+    {
+      code: `
+        import React from "react"
+
+        export function Heading({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) {
+          return <div className={cn("font-semibold text-lg", className)} {...props} />
+        }
+      `,
+      features: ['types'],
+    },
+    {
+      code: `
+        import React from 'react';
+        type TDelIconProps = React.HTMLProps<HTMLDivElement>;
+
+        const DelIcon: React.FC<TDelIconProps> = ({ className, ...rest }) => (
+            <div className={classNames('del flex-center', className)} {...rest}>
+                <i className="iconfont icon-del f12" />
+            </div>
+        );
+      `,
+      features: ['types'],
     }
   )),
 
@@ -4352,8 +5204,8 @@ ruleTester.run('prop-types', rule, {
       code: `
         class Foo extends Component {
           render() {
-            const {props} = this
-            return <div>{props.cat}</div>
+            const { props } = this;
+            return <div>{props.cat}</div>;
           }
         }
       `,
@@ -4413,7 +5265,7 @@ ruleTester.run('prop-types', rule, {
             this.renderStuff()
           }
         }
-        Hello.propTypes = {}
+        Hello.propTypes = {};
       `,
       errors: [
         {
@@ -4804,7 +5656,7 @@ ruleTester.run('prop-types', rule, {
           render() {
             var text;
             text = 'Hello ';
-            let {props: {firstname}} = this;
+            let { props: { firstname } } = this;
             return <div>{text} {firstname}</div>;
           }
         }
@@ -4820,7 +5672,7 @@ ruleTester.run('prop-types', rule, {
       code: `
         class Hello extends React.Component {
           render() {
-            var {'props': {firstname}} = this;
+            var { 'props': { firstname } } = this;
             return <div>Hello {firstname}</div>;
           }
         }
@@ -4896,7 +5748,7 @@ ruleTester.run('prop-types', rule, {
     {
       code: `
         var Hello = (props) => {
-          const {name} = props;
+          const { name } = props;
           return <div>Hello {name}</div>;
         }
       `,
@@ -5017,7 +5869,7 @@ ruleTester.run('prop-types', rule, {
       code: `
         class Hello extends React.Component {
           render() {
-            var props = {firstname: 'John'};
+            var props = { firstname: 'John' };
             return <div>Hello {props.firstname} {this.props.lastname}</div>;
           }
         }
@@ -5143,14 +5995,14 @@ ruleTester.run('prop-types', rule, {
       code: `
         class DynamicHello extends Component {
           render() {
-            const {firstname} = this.props;
+            const { firstname } = this.props;
             class Hello extends Component {
               render() {
-                const {name} = this.props;
+                const { name } = this.props;
                 return <div>Hello {name}</div>;
               }
             }
-            Hello = connectReduxForm({name: firstname})(Hello);
+            Hello = connectReduxForm({ name: firstname })(Hello);
             return <Hello />;
           }
         }
@@ -5243,27 +6095,6 @@ ruleTester.run('prop-types', rule, {
         },
       ],
     },
-    {
-      code: `
-        class Test extends Foo.Component {
-          render() {
-            return (
-              <div>{this.props.firstname} {this.props.lastname}</div>
-            );
-          }
-        }
-        Test.propTypes = {
-          firstname: PropTypes.string
-        };
-      `,
-      settings,
-      errors: [
-        {
-          messageId: 'missingPropType',
-          data: { name: 'lastname' },
-        },
-      ],
-    },
     {
       code: `
         class Test extends Foo.Component {
@@ -5369,7 +6200,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {name: Object;};
+        type Props = { name: Object; };
         class Hello extends React.Component {
           props: Props;
           render () {
@@ -5408,7 +6239,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {name: {firstname: string;};};
+        type Props = { name: { firstname: string; }; };
         class Hello extends React.Component {
           props: Props;
           render () {
@@ -5427,7 +6258,7 @@ ruleTester.run('prop-types', rule, {
     {
       code: `
         class Hello extends React.Component {
-          props: {person: {name: {firstname: string;};};};
+          props: { person: { name: { firstname: string; }; }; };
           render () {
             return <div>Hello {this.props.person.name.lastname}</div>;
           }
@@ -5443,7 +6274,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {person: {name: {firstname: string;};};};
+        type Props = { person: { name: { firstname: string; }; }; };
         class Hello extends React.Component {
           props: Props;
           render () {
@@ -5461,9 +6292,9 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Person = {name: {firstname: string;}};
+        type Person = { name: { firstname: string; } };
         class Hello extends React.Component {
-          props: {people: Person[];};
+          props: { people: Person[]; };
           render () {
             var names = [];
             for (var i = 0; i < this.props.people.length; i++) {
@@ -5484,8 +6315,8 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Person = {name: {firstname: string;}};
-        type Props = {people: Person[];};
+        type Person = { name: { firstname: string } };
+        type Props = { people: Person[] };
         class Hello extends React.Component {
           props: Props;
           render () {
@@ -5508,7 +6339,7 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        type Props = {result?: {ok: string | boolean;}|{ok: number | Array}};
+        type Props = { result?: { ok: string | boolean; } | { ok: number | Array } };
         class Hello extends React.Component {
           props: Props;
           render () {
@@ -5577,8 +6408,8 @@ ruleTester.run('prop-types', rule, {
     },
     {
       code: `
-        function Greetings({names}) {
-          names = names.map(({firstname, lastname}) => <div>{firstname} {lastname}</div>);
+        function Greetings({ names }) {
+          names = names.map(({ firstname, lastname }) => <div>{firstname} {lastname}</div>);
           return <Hello>{names}</Hello>;
         }
       `,
@@ -5637,7 +6468,7 @@ ruleTester.run('prop-types', rule, {
         type Props = {
           firstname: ?string,
         };
-        function Hello({firstname, lastname}: Props): React$Element {
+        function Hello({ firstname, lastname }: Props): React$Element {
           return <div>Hello {firstname} {lastname}</div>;
         }
       `,
@@ -5655,7 +6486,7 @@ ruleTester.run('prop-types', rule, {
           constructor(props, context) {
             super(props, context)
             const firstname = props.firstname;
-            const {lastname} = props;
+            const { lastname } = props;
             this.state = {
               firstname,
               lastname
@@ -7800,6 +8631,26 @@ ruleTester.run('prop-types', rule, {
       ],
       features: ['ts', 'no-babel'],
     },
+    {
+      code: `
+        import React from "react";
+
+        const returnTypeProp = (someProp: any) => ({ someProp });
+
+        const SomeComponent: React.FunctionComponent<
+          ReturnType<typeof returnTypeProp>
+        > = ({ someIncorrectProp }) => {
+          return <div>{someProp}</div>;
+        };
+      `,
+      errors: [
+        {
+          messageId: 'missingPropType',
+          data: { name: 'someIncorrectProp' },
+        },
+      ],
+      features: ['ts', 'no-babel'],
+    },
     {
       code: `
         import React from 'react';
@@ -8030,7 +8881,7 @@ ruleTester.run('prop-types', rule, {
         export type Props = { children: React.ReactNode; type: "submit" | "button" };
 
         export const FancyButton = forwardRef<HTMLButtonElement, Props>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.nonExistent}>
+          <button type="button" ref={ref} className="MyClassName" type={props.nonExistent}>
             {props.children}
           </button>
         ));
@@ -8050,7 +8901,7 @@ ruleTester.run('prop-types', rule, {
         export interface IProps { children: React.ReactNode; type: "submit" | "button" };
 
         export const FancyButton = forwardRef<HTMLButtonElement, IProps>((props, ref) => (
-          <button ref={ref} className="MyClassName" type={props.nonExistent}>
+          <button type="button" ref={ref} className="MyClassName" type={props.nonExistent}>
             {props.children}
           </button>
         ));
diff --git a/tests/lib/rules/react-in-jsx-scope.js b/tests/lib/rules/react-in-jsx-scope.js
index bc82a6c44f..6828f07ce5 100644
--- a/tests/lib/rules/react-in-jsx-scope.js
+++ b/tests/lib/rules/react-in-jsx-scope.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/react-in-jsx-scope');
 
 const parsers = require('../../helpers/parsers');
@@ -44,9 +44,6 @@ ruleTester.run('react-in-jsx-scope', rule, {
     { code: 'var React; <x-gif />;' },
     { code: 'var React, App, a=1; <App attr={a} />;' },
     { code: 'var React, App, a=1; function elem() { return <App attr={a} />; }' },
-    {
-      code: 'var React, App; <App />;',
-    },
     { code: '/** @jsx Foo */ var Foo, App; <App />;' },
     { code: '/** @jsx Foo.Bar */ var Foo, App; <App />;' },
     {
diff --git a/tests/lib/rules/require-default-props.js b/tests/lib/rules/require-default-props.js
index 8ba5d53d7c..928cf4ba1d 100644
--- a/tests/lib/rules/require-default-props.js
+++ b/tests/lib/rules/require-default-props.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/require-default-props');
 
 const parsers = require('../../helpers/parsers');
@@ -3019,16 +3019,17 @@ ruleTester.run('require-default-props', rule, {
         },
       ],
     },
+
     {
       code: `
         function MyStatelessComponent({ foo, bar }) {
           return <div>{foo}{bar}</div>;
         }
-        MyStatelessComponent.propTypes = {
+        const propTypes = forbidExtraProps({
           foo: PropTypes.string,
           bar: PropTypes.string.isRequired
-        };
-        MyStatelessComponent.propTypes.baz = React.propTypes.string;
+        });
+        MyStatelessComponent.propTypes = propTypes;
       `,
       errors: [
         {
@@ -3036,35 +3037,52 @@ ruleTester.run('require-default-props', rule, {
           data: { name: 'foo' },
           line: 6,
         },
+      ],
+      settings: {
+        propWrapperFunctions: ['forbidExtraProps'],
+      },
+    },
+    {
+      code: `
+      function MyStatelessComponent({ foo = 'foo' }) {
+        return <div>{foo}{bar}</div>;
+      }
+      MyStatelessComponent.propTypes = {
+        foo: PropTypes.string.isRequired,
+      };
+      `,
+      options: [{ functions: 'defaultArguments' }],
+      errors: [
         {
-          messageId: 'shouldHaveDefault',
-          data: { name: 'baz' },
-          line: 9,
+          messageId: 'noDefaultWithRequired',
+          data: { name: 'foo' },
+          line: 2,
         },
       ],
     },
-
     {
       code: `
-        function MyStatelessComponent({ foo, bar }) {
-          return <div>{foo}{bar}</div>;
-        }
-        const propTypes = forbidExtraProps({
-          foo: PropTypes.string,
-          bar: PropTypes.string.isRequired
-        });
-        MyStatelessComponent.propTypes = propTypes;
+      function MyStatelessComponent({ foo = 'foo', bar }) {
+        return <div>{foo}{bar}</div>;
+      }
+      MyStatelessComponent.propTypes = {
+        foo: PropTypes.string.isRequired,
+        bar: PropTypes.string
+      };
       `,
+      options: [{ functions: 'defaultArguments' }],
       errors: [
         {
-          messageId: 'shouldHaveDefault',
+          messageId: 'noDefaultWithRequired',
           data: { name: 'foo' },
-          line: 6,
+          line: 2,
+        },
+        {
+          messageId: 'shouldAssignObjectDefault',
+          data: { name: 'bar' },
+          line: 2,
         },
       ],
-      settings: {
-        propWrapperFunctions: ['forbidExtraProps'],
-      },
     },
   ]),
 });
diff --git a/tests/lib/rules/require-optimization.js b/tests/lib/rules/require-optimization.js
index 89ef8c3115..0df43ac2d1 100644
--- a/tests/lib/rules/require-optimization.js
+++ b/tests/lib/rules/require-optimization.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/require-optimization');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/require-render-return.js b/tests/lib/rules/require-render-return.js
index d24aef80c3..364a2e7c99 100644
--- a/tests/lib/rules/require-render-return.js
+++ b/tests/lib/rules/require-render-return.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/require-render-return');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/self-closing-comp.js b/tests/lib/rules/self-closing-comp.js
index b9627b3427..4cd3b1c5ad 100644
--- a/tests/lib/rules/self-closing-comp.js
+++ b/tests/lib/rules/self-closing-comp.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/self-closing-comp');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/sort-comp.js b/tests/lib/rules/sort-comp.js
index 0461f65fd0..da8810cc10 100644
--- a/tests/lib/rules/sort-comp.js
+++ b/tests/lib/rules/sort-comp.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/sort-comp');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/sort-default-props.js b/tests/lib/rules/sort-default-props.js
index 8bbe6af1f5..3878a29e0b 100644
--- a/tests/lib/rules/sort-default-props.js
+++ b/tests/lib/rules/sort-default-props.js
@@ -11,7 +11,7 @@
 
 const babelEslintVersion = require('babel-eslint/package.json').version;
 const semver = require('semver');
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/sort-default-props');
 
diff --git a/tests/lib/rules/sort-prop-types.js b/tests/lib/rules/sort-prop-types.js
index a89ebeaf97..a902f54c4c 100644
--- a/tests/lib/rules/sort-prop-types.js
+++ b/tests/lib/rules/sort-prop-types.js
@@ -11,7 +11,7 @@
 const babelEslintVersion = require('babel-eslint/package.json').version;
 const semver = require('semver');
 const eslintPkg = require('eslint/package.json');
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 
 const rule = require('../../../lib/rules/sort-prop-types');
 
@@ -493,6 +493,26 @@ ruleTester.run('sort-prop-types', rule, {
       `,
       features: ['types'],
       options: [{ checkTypes: false }],
+    },
+    {
+      code: `
+        function Foo() {
+          return <div />;
+        }
+      `,
+      options: [{ checkTypes: true }],
+    },
+    {
+      code: `
+        const Foo = (props: {
+          aaa: string,
+          zzz: string
+        }) => {
+          return null;
+        }
+      `,
+      features: ['types'],
+      options: [{ checkTypes: true }],
     }
   )),
   invalid: parsers.all([].concat(
@@ -2348,6 +2368,52 @@ ruleTester.run('sort-prop-types', rule, {
           column: 11,
         },
       ],
+    },
+    {
+      code: `
+        type CustomProps = { onChange: () => void; name: string };
+        const Foo = (props: CustomProps) => {
+          return null;
+        }
+      `,
+      output: `
+        type CustomProps = { name: string; onChange: () => void };
+        const Foo = (props: CustomProps) => {
+          return null;
+        }
+      `,
+      features: ['types'],
+      options: [{ checkTypes: true }],
+      errors: [
+        {
+          messageId: 'propsNotSorted',
+          line: 2,
+          column: 52,
+        },
+      ],
+    },
+    {
+      code: `
+        type CustomProps = { onChange: (event: { target: { name: string; value: string } }) => void; name: string };
+        const Foo = (props: CustomProps) => {
+          return null;
+        }
+      `,
+      output: `
+        type CustomProps = { name: string; onChange: (event: { target: { name: string; value: string } }) => void };
+        const Foo = (props: CustomProps) => {
+          return null;
+        }
+      `,
+      features: ['types'],
+      options: [{ checkTypes: true }],
+      errors: [
+        {
+          messageId: 'propsNotSorted',
+          line: 2,
+          column: 102,
+        },
+      ],
     }
   )),
 });
diff --git a/tests/lib/rules/state-in-constructor.js b/tests/lib/rules/state-in-constructor.js
index 9b8791cc43..e144d4e4cb 100644
--- a/tests/lib/rules/state-in-constructor.js
+++ b/tests/lib/rules/state-in-constructor.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/state-in-constructor');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/static-property-placement.js b/tests/lib/rules/static-property-placement.js
index 084881b318..97b49e936b 100644
--- a/tests/lib/rules/static-property-placement.js
+++ b/tests/lib/rules/static-property-placement.js
@@ -16,7 +16,7 @@ const PROPERTY_ASSIGNMENT = 'property assignment';
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/static-property-placement');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/style-prop-object.js b/tests/lib/rules/style-prop-object.js
index d851fcbf9a..9381bad508 100644
--- a/tests/lib/rules/style-prop-object.js
+++ b/tests/lib/rules/style-prop-object.js
@@ -9,7 +9,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/style-prop-object');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/lib/rules/void-dom-elements-no-children.js b/tests/lib/rules/void-dom-elements-no-children.js
index 8e4156931d..64c4aadddb 100644
--- a/tests/lib/rules/void-dom-elements-no-children.js
+++ b/tests/lib/rules/void-dom-elements-no-children.js
@@ -9,7 +9,7 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-const RuleTester = require('eslint').RuleTester;
+const RuleTester = require('../../helpers/ruleTester');
 const rule = require('../../../lib/rules/void-dom-elements-no-children');
 
 const parsers = require('../../helpers/parsers');
diff --git a/tests/util/Components.js b/tests/util/Components.js
index 087159e2a6..414f9a05bd 100644
--- a/tests/util/Components.js
+++ b/tests/util/Components.js
@@ -2,14 +2,14 @@
 
 const assert = require('assert');
 const entries = require('object.entries');
-const eslint = require('eslint');
 const fromEntries = require('object.fromentries');
 const values = require('object.values');
 
+const RuleTester = require('../helpers/ruleTester');
 const Components = require('../../lib/util/Components');
 const parsers = require('../helpers/parsers');
 
-const ruleTester = new eslint.RuleTester({
+const ruleTester = new RuleTester({
   parserOptions: {
     ecmaVersion: 2018,
     sourceType: 'module',
diff --git a/tests/util/jsx.js b/tests/util/jsx.js
index c8009fc005..7be16d5410 100644
--- a/tests/util/jsx.js
+++ b/tests/util/jsx.js
@@ -21,6 +21,7 @@ const parseCode = (code) => {
 };
 
 const mockContext = {
+  getSourceCode() { return { getScope: mockContext.getScope }; },
   getScope() {
     return {
       type: 'global',
@@ -34,7 +35,7 @@ const mockContext = {
 describe('jsxUtil', () => {
   describe('isReturningJSX', () => {
     const assertValid = (codeStr) => assert(
-      isReturningJSX(parseCode(codeStr), mockContext)
+      isReturningJSX(mockContext, parseCode(codeStr))
     );
 
     it('Works when returning JSX', () => {
diff --git a/tests/util/pragma.js b/tests/util/pragma.js
index 988354a5fc..475f97aaa6 100644
--- a/tests/util/pragma.js
+++ b/tests/util/pragma.js
@@ -56,9 +56,9 @@ describe('pragma', () => {
       );
     });
 
-    it('throws an error if the pragma is invalid', () => {
+    it('returns React if the pragma is invalid', () => {
       const code = '/* @jsx invalid-jsx-pragma */';
-      assert.throws(() => getFromContext(fakeContext(code)));
+      assert.equal(getFromContext(fakeContext(code)), 'React');
     });
   });
 });
diff --git a/tests/util/version.js b/tests/util/version.js
index ad9bd4585c..3ff23e0230 100644
--- a/tests/util/version.js
+++ b/tests/util/version.js
@@ -14,6 +14,7 @@ describe('Version', () => {
     expectedErrorArgs = [];
     versionUtil.resetWarningFlag();
     versionUtil.resetDetectedVersion();
+    versionUtil.resetDefaultVersion();
   });
 
   afterEach(() => {
@@ -65,6 +66,33 @@ describe('Version', () => {
       ];
     });
 
+    it('uses default version from settings if provided and react is not installed', () => {
+      context.settings.react.defaultVersion = '16.14.0';
+      sinon.stub(context, 'getFilename').callsFake(() => path.resolve(base, 'detect-version-missing', 'test.js'));
+
+      assert.equal(versionUtil.testReactVersion(context, '16.14.0'), true);
+
+      expectedErrorArgs = [
+        ['Warning: React version was set to "detect" in eslint-plugin-react settings, but the "react" package is not installed. Assuming default React version for linting: "16.14.0".'],
+      ];
+
+      delete context.settings.react.defaultVersion;
+    });
+
+    it('fails nicely with an invalid default version of react', () => {
+      context.settings.react.defaultVersion = 'not semver';
+      sinon.stub(context, 'getFilename').callsFake(() => path.resolve(base, 'detect-version-missing', 'test.js'));
+
+      assert.equal(versionUtil.testReactVersion(context, '999.999.999'), true);
+
+      expectedErrorArgs = [
+        ['Warning: React version specified in eslint-plugin-react-settings must be a valid semver version, or "detect"; got “not semver”. Falling back to latest version as default.'],
+        ['Warning: React version was set to "detect" in eslint-plugin-react settings, but the "react" package is not installed. Assuming latest React version for linting.'],
+      ];
+
+      delete context.settings.react.defaultVersion;
+    });
+
     it('warns only once for failure to detect react ', () => {
       sinon.stub(context, 'getFilename').callsFake(() => path.resolve(base, 'detect-version-missing', 'test.js'));
 
diff --git a/tsconfig.json b/tsconfig.json
index 39187b7f32..8772fab53d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,5 +19,5 @@
     "alwaysStrict": false,                 /* Parse in strict mode and emit "use strict" for each source file. */
     "resolveJsonModule": true
   },
-  "include": ["lib"],
+  "include": ["lib", "types"],
 }
diff --git a/types/rules/jsx-no-literals.d.ts b/types/rules/jsx-no-literals.d.ts
new file mode 100644
index 0000000000..c1b9638958
--- /dev/null
+++ b/types/rules/jsx-no-literals.d.ts
@@ -0,0 +1,50 @@
+type RawElementConfig = {
+  noStrings?: boolean;
+  allowedStrings?: string[];
+  ignoreProps?: boolean;
+  noAttributeStrings?: boolean;
+};
+
+type RawOverrideConfig = {
+  allowElement?: boolean;
+  applyToNestedElements?: boolean;
+};
+
+interface RawElementOverrides {
+  elementOverrides?: Record<string, RawOverrideConfig>;
+}
+
+export type RawConfig = RawElementConfig & RawElementOverrides;
+
+interface ElementConfigType {
+  type: 'element';
+}
+
+interface ElementConfigProperties {
+  noStrings: boolean;
+  allowedStrings: Set<string>;
+  ignoreProps: boolean;
+  noAttributeStrings: boolean;
+}
+
+interface OverrideConfigProperties {
+  type: 'override';
+  name: string;
+  allowElement: boolean;
+  applyToNestedElements: boolean;
+}
+
+export type ElementConfig = {
+  type: 'element';
+} & ElementConfigProperties;
+
+export type OverrideConfig = OverrideConfigProperties & ElementConfigProperties;
+
+interface ElementOverrides {
+  elementOverrides: Record<string, OverrideConfig>;
+}
+
+export type Config = ElementConfig & ElementOverrides;
+
+export type ResolvedConfig = Config | OverrideConfig;
+
diff --git a/types/string.prototype.repeat/index.d.ts b/types/string.prototype.repeat/index.d.ts
new file mode 100644
index 0000000000..b2e5992712
--- /dev/null
+++ b/types/string.prototype.repeat/index.d.ts
@@ -0,0 +1,4 @@
+declare module 'string.prototype.repeat' {
+  function repeat(text: string, count: number): string;
+  export = repeat;
+}