Repository: eslint/eslint
Pull request #12762 (2020-01-09 05:55:55)

Chore: Adopt `eslint-plugin/require-meta-docs-description` internally
<!--
    ESLint adheres to the [JS Foundation Code of Conduct](https://js.foundation/community/code-of-conduct).
-->

**What is the purpose of this pull request? (put an "X" next to item)**

[ ] Documentation update
[ ] Bug fix ([template](https://raw.githubusercontent.com/eslint/eslint/master/templates/bug-report.md))
[ ] New rule ([template](https://raw.githubusercontent.com/eslint/eslint/master/templates/rule-proposal.md))
[ ] Changes an existing rule ([template](https://raw.githubusercontent.com/eslint/eslint/master/templates/rule-change-proposal.md))
[ ] Add autofixing to a rule
[ ] Add a CLI option
[ ] Add something to the core
[X] Other, please explain:

<!--
    If the item you've checked above has a template, please paste the template questions below and answer them. (If this pull request is addressing an issue, you can just paste a link to the issue here instead.)
-->

<!--
    Please ensure your pull request is ready:

    - Read the pull request guide (https://eslint.org/docs/developer-guide/contributing/pull-requests)
    - Include tests for this change
    - Update documentation for this change (if appropriate)
-->

<!--
    The following is required for all pull requests:
-->

**What changes did you make? (Give an overview)**

This PR replaces the `internal-rules/consistent-docs-description` lint rule with [eslint-plugin/require-meta-docs-description](https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-docs-description.md). Why?

1. The replacement rule has identical behavior.
2. The replacement rule is more generic.
3. The replacement rule can be used by any eslint plugin.
4. This allows us to reduce the amount of code in eslint.

**Is there anything you'd like reviewers to focus on?**

Feel free to double-check that the replacement rule has the same behavior as the deleted rule.

kaicataldo: I'm not sure this is the right course of action since I could see us wanting to reserve the right to easily validate internal rules differently than custom plugin rules. 
bmish: @kaicataldo I hear that. But I would note that:

1. eslint is already using all of the other recommended rules from [eslint-plugin-eslint-plugin](https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin) (@not-an-aardvark added it originally)
2. I specifically wrote [eslint-plugin/require-meta-docs-description](https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-docs-description.md) to match eslint's desired behavior
3. [eslint-plugin/require-meta-docs-description](https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-docs-description.md) provides a `pattern` option allowing full customization of the regexp that rule descriptions should match
kaicataldo: Thanks for providing more context around that. Your reasoning makes sense to me!

Patch:
diff --git a/.eslintrc.js b/.eslintrc.js
index e57ac92af..6ab4510cb 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -19,12 +19,16 @@ module.exports = {
         "eslint",
         "plugin:eslint-plugin/recommended"
     ],
+    parserOptions: {
+        ecmaVersion: 2020
+    },
     rules: {
         "eslint-plugin/consistent-output": "error",
         "eslint-plugin/no-deprecated-context-methods": "error",
         "eslint-plugin/prefer-output-null": "error",
         "eslint-plugin/prefer-placeholders": "error",
         "eslint-plugin/report-message-format": ["error", "[^a-z].*\\.$"],
+        "eslint-plugin/require-meta-docs-description": "error",
         "eslint-plugin/require-meta-type": "error",
         "eslint-plugin/test-case-property-ordering": [
             "error",
@@ -50,8 +54,7 @@ module.exports = {
             files: ["lib/rules/*", "tools/internal-rules/*"],
             excludedFiles: ["index.js"],
             rules: {
-                "internal-rules/no-invalid-meta": "error",
-                "internal-rules/consistent-docs-description": "error"
+                "internal-rules/no-invalid-meta": "error"
 
                 /*
                  * TODO: enable it when all the rules using meta.messages
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 645258a56..4b4c872b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,49 @@
+v7.0.0-alpha.0 - January 17, 2020
+
+* [`1aa021d`](https://github.com/eslint/eslint/commit/1aa021d77fdd2c68d7b7d2f4603252110c414b32) Breaking: lint `overrides` files (fixes #10828, refs eslint/rfcs#20) (#12677) (Toru Nagashima)
+* [`e59d775`](https://github.com/eslint/eslint/commit/e59d77536bd8db57e8a75cd5245f6f320aa699f8) Update: Separate pattern/expression options for array-element-newline (#11796) (jacobparish)
+* [`f8f115a`](https://github.com/eslint/eslint/commit/f8f115af6e10539e6cad485588187cb11917f8c9) Update: treat comment tokens in template-curly-spacing (fixes #12744) (#12775) (YeonJuan)
+* [`b50179d`](https://github.com/eslint/eslint/commit/b50179def3fedbd95fdeab25e32c2511867eb760) Breaking: Check assignment targets in no-extra-parens (#12490) (Milos Djermanovic)
+* [`de4fa7c`](https://github.com/eslint/eslint/commit/de4fa7c65c7befefa64d1605550267071ee56a5d) Fix: wrong indent at tagged template in indent (fixes #12122) (#12596) (YeonJuan)
+* [`d86a5bb`](https://github.com/eslint/eslint/commit/d86a5bbb1987d858d4963f647b0af5c1fd924b4f) Breaking: Check flatMap in array-callback-return (fixes #12235) (#12765) (Milos Djermanovic)
+* [`cf46df7`](https://github.com/eslint/eslint/commit/cf46df70158a4ed4c09d5c9d655c07dc6df3ff5e) Breaking: description in directive comments (refs eslint/rfcs#33) (#12699) (Toru Nagashima)
+* [`7350589`](https://github.com/eslint/eslint/commit/7350589a5bdfc9d75d1ff19364f476eec44c3911) Breaking: some rules recognize bigint literals (fixes #11803) (#12701) (Toru Nagashima)
+* [`16a1c1f`](https://github.com/eslint/eslint/commit/16a1c1f79bc0a4cc1c3a87e98d220041de88bb93) Fix: prefer-object-spread false positives with accessors (fixes #12086) (#12784) (Milos Djermanovic)
+* [`f9774ec`](https://github.com/eslint/eslint/commit/f9774ec11b0ebe63fb16a97b97890efb84699548) New: Add default-case-last rule (fixes #12665) (#12668) (Milos Djermanovic)
+* [`9a93d9e`](https://github.com/eslint/eslint/commit/9a93d9ef389c49a133c4df4f9843927f5f806423) Update: fix no-restricted-imports export * false negative (fixes #12737) (#12798) (Milos Djermanovic)
+* [`0d8c0af`](https://github.com/eslint/eslint/commit/0d8c0affe1ae7ecf228cdf91b490921f7e9d1fdb) Fix: improve report location for computed-property-spacing (#12795) (Milos Djermanovic)
+* [`756b95d`](https://github.com/eslint/eslint/commit/756b95d59fb97cd9b3f3adf98cebf529fe4842a2) Fix: id-blacklist should ignore ObjectPatterns (fixes #12787) (#12792) (JP Ramassini)
+* [`561b6d4`](https://github.com/eslint/eslint/commit/561b6d4726f3e77dd40ba0d340ca7f08429cd2eb) Chore: add prerequisites checklist to PR template (#12790) (Kai Cataldo)
+* [`01ff791`](https://github.com/eslint/eslint/commit/01ff7910af86fc45b76e883bc9ab00c9be3b50ac) Fix: Display pipe character correctly in test output (#12771) (Brad Zacher)
+* [`68becbd`](https://github.com/eslint/eslint/commit/68becbd84e8a0693409d36f2be10679c483e233a) Update: fix no-restricted-imports importNames reporting (fixes #12282) (#12711) (Andrey Alexandrov)
+* [`ae959b6`](https://github.com/eslint/eslint/commit/ae959b691fb148ac8b474c924c8cb01ef61c436d) Update: report double extra parens in no-extra-parens (fixes #12127) (#12697) (YeonJuan)
+* [`02fcc05`](https://github.com/eslint/eslint/commit/02fcc055710e8d69d986f1e682cae2014ad881e2) Docs: Improve sort-keys (#12791) (Steven Vachon)
+* [`35cd958`](https://github.com/eslint/eslint/commit/35cd95893be0afd8c954cbcf9268c2aa045b7d5b) Sponsors: Sync README with website (ESLint Jenkins)
+* [`a1d999c`](https://github.com/eslint/eslint/commit/a1d999c6b4e51c317ad409110be7be214ff9f7c6) New: Add no-useless-backreference rule (fixes #12673) (#12690) (Milos Djermanovic)
+* [`b2c6209`](https://github.com/eslint/eslint/commit/b2c62096a8b318765d618cab222240f87d73063b) Update: fix no-extra-parens CallExpression#callee false negatives (#12743) (Milos Djermanovic)
+* [`14b42c3`](https://github.com/eslint/eslint/commit/14b42c386be3387c415267b789f277e1294d4567) Update: fix counting jsx comment len in max-len (fixes #12213) (#12661) (YeonJuan)
+* [`e632c31`](https://github.com/eslint/eslint/commit/e632c31d7e5363f1347b787702ecd4a85f5c11a2) Upgrade: several dependencies (#12753) (Toru Nagashima)
+* [`25eb703`](https://github.com/eslint/eslint/commit/25eb703c8758563988ffb497a53f89a3ed345399) Docs: fix dead link in max-lines rule docs (#12766) (Christian Bundy)
+* [`9dfc850`](https://github.com/eslint/eslint/commit/9dfc8501fb1956c90dc11e6377b4cb38a6bea65d) Chore: Refactor to use messageId in a number of rules (#12715) (Brad Zacher)
+* [`1118fce`](https://github.com/eslint/eslint/commit/1118fceb49af3436b8dcd0c6089f913cedf9a329) Breaking: runtime-deprecation on '~/.eslintrc' (refs eslint/rfcs#32) (#12678) (Toru Nagashima)
+* [`2c28fbb`](https://github.com/eslint/eslint/commit/2c28fbbb563a44282bef0c9fcc9be29d611cc83b) Breaking: drop Node.js 8 support (refs eslint/rfcs#44) (#12700) (Toru Nagashima)
+* [`098b67d`](https://github.com/eslint/eslint/commit/098b67d04a4b4dc8ef4faa6434c6ef5abbde3ed3) Docs: fix minor typo in brace-style.md (#12749) (Marko Kaznovac)
+* [`313f70a`](https://github.com/eslint/eslint/commit/313f70ac9a3cf5d1558d2427b00dd75666e18cf4) Update: add outerIIFEBody: "off" to indent rule (fixes #11377) (#12706) (Kai Cataldo)
+* [`b77b858`](https://github.com/eslint/eslint/commit/b77b8585e33fc4bb438a0e11ca8177c7eb91dbd8) Chore: fix separateRequires tests for one-var rule (#12709) (Milos Djermanovic)
+* [`e4df7df`](https://github.com/eslint/eslint/commit/e4df7dfb0199badb61d2c03ff4f7e4be735279d9) Chore: add JSDoc types for RuleTester test cases (#12325) (Chiawen Chen)
+* [`b23ad0d`](https://github.com/eslint/eslint/commit/b23ad0d789a909baf8d7c41a35bc53df932eaf30) Docs: change a broken link in working-with-rules.md (#12732) (Damien Cassou)
+* [`3fa39a6`](https://github.com/eslint/eslint/commit/3fa39a633b37544fec7cedfc1f2b0e62e9312a72) Update: Handle locally unsupported regex in computed property keys (#12056) (Milos Djermanovic)
+* [`4744397`](https://github.com/eslint/eslint/commit/474439720258b1a64b305c31588f803104fa4aaf) Chore: remove unused code in max-lines-per-function (#12659) (YeonJuan)
+* [`4e16957`](https://github.com/eslint/eslint/commit/4e169576a526023ee297d5bc8b37eedba229f63d) Build: update browser build (#12693) (Toru Nagashima)
+* [`00ddfff`](https://github.com/eslint/eslint/commit/00ddfffe6b4b4244e4680b0f92f2c6697fad136f) Fix: Windows path parsing for JUnit (fixes #12507) (#12509) (Michael Wall)
+* [`985dac3`](https://github.com/eslint/eslint/commit/985dac35e3c367f0f99d1f0e766e06a1d9818dd4) New: Add no-restricted-exports rule (fixes #10428) (#12546) (Milos Djermanovic)
+* [`1aff21b`](https://github.com/eslint/eslint/commit/1aff21bb54da44cef0b6e378a34a74265863b930) Fix: no-mixed-spaces-and-tabs reports multiline strings (#12566) (Milos Djermanovic)
+* [`8f1020f`](https://github.com/eslint/eslint/commit/8f1020ff711b0c57d590bf666e2841f64186d083) Update: no-void add an option to allow void as a statement (#12613) (Brad Zacher)
+* [`bb6cf50`](https://github.com/eslint/eslint/commit/bb6cf5082623ffb67bb1495fee52c0610ee5f421) Update: Add offsetTernaryExpressions option for indent rule (#12556) (Adam Stankiewicz)
+* [`39f5a45`](https://github.com/eslint/eslint/commit/39f5a453579b2ad732212edeb71f84ecb0991f97) Chore: add test cases for for-direction (#12698) (YeonJuan)
+* [`b340304`](https://github.com/eslint/eslint/commit/b3403045e535921df6d34785a4ce053e14ba27fd) Chore: Add extra test, improve docs (#12492) (Kevin Partington)
+* [`827259e`](https://github.com/eslint/eslint/commit/827259ea009f98a0fdf3f7ebf1bfb6cd661ce28d) Build: package.json update for eslint-config-eslint release (ESLint Jenkins)
+
 v6.8.0 - December 20, 2019
 
 * [`c5c7086`](https://github.com/eslint/eslint/commit/c5c708666b450fb69522a55aa375626f9297dc6f) Fix: ignore aligning single line in key-spacing (fixes #11414) (#12652) (YeonJuan)
diff --git a/README.md b/README.md
index 65c572719..54c5e5bcc 100644
--- a/README.md
+++ b/README.md
@@ -264,7 +264,7 @@ The following companies, organizations, and individuals support ESLint's ongoing
 <h3>Gold Sponsors</h3>
 <p><a href="https://www.shopify.com"><img src="https://images.opencollective.com/shopify/eeb91aa/logo.png" alt="Shopify" height="96"></a> <a href="http://engineering.salesforce.com"><img src="https://images.opencollective.com/salesforce/ca8f997/logo.png" alt="Salesforce" height="96"></a> <a href="https://badoo.com/team?utm_source=eslint"><img src="https://images.opencollective.com/badoo/2826a3b/logo.png" alt="Badoo" height="96"></a> <a href="https://www.airbnb.com/"><img src="https://images.opencollective.com/airbnb/d327d66/logo.png" alt="Airbnb" height="96"></a> <a href="https://opensource.facebook.com"><img src="https://images.opencollective.com/fbopensource/fbb8a5b/logo.png" alt="Facebook Open Source" height="96"></a></p><h3>Silver Sponsors</h3>
 <p><a href="https://www.ampproject.org/"><img src="https://images.opencollective.com/amp/c8a3b25/logo.png" alt="AMP Project" height="64"></a></p><h3>Bronze Sponsors</h3>
-<p><a href="https://icons8.com"><img src="https://images.opencollective.com/icons8/0b37d14/logo.png" alt="Free Icons by Icons8" height="32"></a> <a href="https://www.bonus.com.de/freispiele"><img src="https://images.opencollective.com/bonusfinder-deutschland/646169e/logo.png" alt="BonusFinder Deutschland" height="32"></a> <a href="https://edubirdie.com/"><img src="https://images.opencollective.com/edubirdie2/b1d51ab/logo.png" alt="EduBirdie" height="32"></a> <a href="https://www.bugsnag.com/platforms?utm_source=Open Collective&utm_medium=Website&utm_content=open-source&utm_campaign=2019-community&utm_term="><img src="https://images.opencollective.com/bugsnag-stability-monitoring/c2cef36/logo.png" alt="Bugsnag Stability Monitoring" height="32"></a> <a href="https://www.crosswordsolver.com"><img src="https://images.opencollective.com/crosswordsolver/d4481d6/logo.png" alt="Crosswordsolver" height="32"></a> <a href="https://www.codacy.com/?utm_source=eslint&utm_medium=cpm&utm_campaign=eslint-sponsorship"><img src="https://images.opencollective.com/codacy/ed22716/logo.png" alt="Codacy" height="32"></a> <a href="https://mixpanel.com"><img src="https://images.opencollective.com/mixpanel/cd682f7/logo.png" alt="Mixpanel" height="32"></a> <a href="https://www.vpsserver.com"><img src="https://images.opencollective.com/vpsservercom/logo.png" alt="VPS Server" height="32"></a> <a href="https://medium.com/@niksundin/best-web-design-companies-1872e445775f"><img src="https://images.opencollective.com/top-web-design-agencies/d92d747/logo.png" alt="Top Web Design Agencies" height="32"></a> <a href="https://uxplanet.org/top-ui-ux-design-agencies-user-experience-firms-8c54697e290"><img src="https://images.opencollective.com/ui-ux-design-agencies/cae5dfe/logo.png" alt="UI UX Design Agencies" height="32"></a> <a href="https://clay.global"><img src="https://images.opencollective.com/clayglobal/2468f34/logo.png" alt="clay" height="32"></a> <a href="https://discordapp.com"><img src="https://images.opencollective.com/discordapp/7e3d9a9/logo.png" alt="Discord" height="32"></a> <a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://tekhattan.com"><img src="https://images.opencollective.com/tekhattan/bc73c28/logo.png" alt="TekHattan" height="32"></a> <a href="https://www.marfeel.com/"><img src="https://images.opencollective.com/marfeel/4b88e30/logo.png" alt="Marfeel" height="32"></a> <a href="http://www.firesticktricks.com"><img src="https://images.opencollective.com/fire-stick-tricks/b8fbe2c/logo.png" alt="Fire Stick Tricks" height="32"></a> <a href="https://jsheroes.io/"><img src="https://images.opencollective.com/jsheroes1/9fedf0b/logo.png" alt="JSHeroes " height="32"></a></p>
+<p><a href="https://uxplanet.org/top-ui-ux-design-agencies-user-experience-firms-8c54697e290"><img src="https://images.opencollective.com/ui-ux-design-agencies/cae5dfe/logo.png" alt="UI UX Design Agencies" height="32"></a> <a href="https://www.bonus.com.de/freispiele"><img src="https://images.opencollective.com/bonusfinder-deutschland/646169e/logo.png" alt="BonusFinder Deutschland" height="32"></a> <a href="https://www.bugsnag.com/platforms?utm_source=Open Collective&utm_medium=Website&utm_content=open-source&utm_campaign=2019-community&utm_term="><img src="https://images.opencollective.com/bugsnag-stability-monitoring/c2cef36/logo.png" alt="Bugsnag Stability Monitoring" height="32"></a> <a href="https://www.crosswordsolver.com"><img src="https://images.opencollective.com/crosswordsolver/d4481d6/logo.png" alt="Crosswordsolver" height="32"></a> <a href="https://www.codacy.com/?utm_source=eslint&utm_medium=cpm&utm_campaign=eslint-sponsorship"><img src="https://images.opencollective.com/codacy/ed22716/logo.png" alt="Codacy" height="32"></a> <a href="https://mixpanel.com"><img src="https://images.opencollective.com/mixpanel/cd682f7/logo.png" alt="Mixpanel" height="32"></a> <a href="https://www.vpsserver.com"><img src="https://images.opencollective.com/vpsservercom/logo.png" alt="VPS Server" height="32"></a> <a href="https://icons8.com"><img src="https://images.opencollective.com/icons8/0b37d14/logo.png" alt="Free Icons by Icons8" height="32"></a> <a href="https://medium.com/@niksundin/best-web-design-companies-1872e445775f"><img src="https://images.opencollective.com/top-web-design-agencies/d92d747/logo.png" alt="Top Web Design Agencies" height="32"></a> <a href="https://clay.global"><img src="https://images.opencollective.com/clayglobal/2468f34/logo.png" alt="clay" height="32"></a> <a href="https://discordapp.com"><img src="https://images.opencollective.com/discordapp/7e3d9a9/logo.png" alt="Discord" height="32"></a> <a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://tekhattan.com"><img src="https://images.opencollective.com/tekhattan/bc73c28/logo.png" alt="TekHattan" height="32"></a> <a href="https://www.marfeel.com/"><img src="https://images.opencollective.com/marfeel/4b88e30/logo.png" alt="Marfeel" height="32"></a> <a href="http://www.firesticktricks.com"><img src="https://images.opencollective.com/fire-stick-tricks/b8fbe2c/logo.png" alt="Fire Stick Tricks" height="32"></a> <a href="https://jsheroes.io/"><img src="https://images.opencollective.com/jsheroes1/9fedf0b/logo.png" alt="JSHeroes " height="32"></a></p>
 <!--sponsorsend-->
 
 ## <a name="technology-sponsors"></a>Technology Sponsors
diff --git a/conf/default-cli-options.js b/conf/default-cli-options.js
index 0f7b377fb..e09a829d1 100644
--- a/conf/default-cli-options.js
+++ b/conf/default-cli-options.js
@@ -12,7 +12,7 @@ module.exports = {
     useEslintrc: true,
     envs: [],
     globals: [],
-    extensions: [".js"],
+    extensions: null,
     ignore: true,
     ignorePath: void 0,
     cache: false,
diff --git a/docs/developer-guide/nodejs-api.md b/docs/developer-guide/nodejs-api.md
index 1ffb6737d..13f388639 100644
--- a/docs/developer-guide/nodejs-api.md
+++ b/docs/developer-guide/nodejs-api.md
@@ -7,28 +7,28 @@ While ESLint is designed to be run on the command line, it's possible to use ESL
 ## Table of Contents
 
 * [SourceCode](#sourcecode)
-    * [splitLines()](#sourcecodesplitlines)
+    * [splitLines()](#sourcecode-splitlines)
 * [Linter](#linter)
-    * [verify()](#linterverify)
-    * [verifyAndFix()](#linterverifyandfix)
-    * [defineRule()](#linterdefinerule)
-    * [defineRules()](#linterdefinerules)
-    * [getRules()](#lintergetrules)
-    * [defineParser()](#linterdefineparser)
-    * [version](#linterversion)
+    * [verify()](#linter-verify)
+    * [verifyAndFix()](#linter-verifyandfix)
+    * [defineRule()](#linter-definerule)
+    * [defineRules()](#linter-definerules)
+    * [getRules()](#linter-getrules)
+    * [defineParser()](#linter-defineparser)
+    * [version](#linter-version)
 * [linter (deprecated)](#linter-1)
 * [CLIEngine](#cliengine)
-    * [executeOnFiles()](#cliengineexecuteonfiles)
-    * [resolveFileGlobPatterns()](#cliengineresolvefileglobpatterns)
-    * [getConfigForFile()](#clienginegetconfigforfile)
-    * [executeOnText()](#cliengineexecuteontext)
-    * [addPlugin()](#cliengineaddplugin)
-    * [isPathIgnored()](#cliengineispathignored)
-    * [getFormatter()](#clienginegetformatter)
-    * [getErrorResults()](#clienginegeterrorresults)
-    * [outputFixes()](#cliengineoutputfixes)
-    * [getRules()](#clienginegetrules)
-    * [version](#cliengineversion)
+    * [executeOnFiles()](#cliengine-executeonfiles)
+    * [resolveFileGlobPatterns()](#cliengine-resolvefileglobpatterns)
+    * [getConfigForFile()](#cliengine-getconfigforfile)
+    * [executeOnText()](#cliengine-executeontext)
+    * [addPlugin()](#cliengine-addplugin)
+    * [isPathIgnored()](#cliengine-ispathignored)
+    * [getFormatter()](#cliengine-getformatter)
+    * [getErrorResults()](#cliengine-geterrorresults)
+    * [outputFixes()](#cliengine-outputfixes)
+    * [getRules()](#cliengine-getrules)
+    * [version](#cliengine-version)
 * [RuleTester](#ruletester)
     * [Customizing RuleTester](#customizing-ruletester)
 * [Deprecated APIs](#deprecated-apis)
diff --git a/docs/rules/array-callback-return.md b/docs/rules/array-callback-return.md
index 34ffeffce..44dccdeff 100644
--- a/docs/rules/array-callback-return.md
+++ b/docs/rules/array-callback-return.md
@@ -21,6 +21,7 @@ This rule finds callback functions of the following methods, then checks usage o
 * [`Array.prototype.filter`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.filter)
 * [`Array.prototype.find`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.find)
 * [`Array.prototype.findIndex`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.findindex)
+* [`Array.prototype.flatMap`](https://www.ecma-international.org/ecma-262/10.0/#sec-array.prototype.flatmap)
 * [`Array.prototype.map`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.map)
 * [`Array.prototype.reduce`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.reduce)
 * [`Array.prototype.reduceRight`](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.reduceright)
diff --git a/docs/rules/array-element-newline.md b/docs/rules/array-element-newline.md
index f67661f60..440990566 100644
--- a/docs/rules/array-element-newline.md
+++ b/docs/rules/array-element-newline.md
@@ -19,6 +19,20 @@ Or an object option (Requires line breaks if any of properties is satisfied. Oth
 * `"multiline": <boolean>` requires line breaks if there are line breaks inside elements. If this is false, this condition is disabled.
 * `"minItems": <number>` requires line breaks if the number of elements is at least the given integer. If this is 0, this condition will act the same as the option `"always"`. If this is `null` (the default), this condition is disabled.
 
+Alternatively, different configurations can be specified for array expressions and array patterns:
+
+```json
+{
+    "array-element-newline": ["error", {
+        "ArrayExpression": "consistent",
+        "ArrayPattern": { "minItems": 3 },
+    }]
+}
+```
+
+* `"ArrayExpression"` configuration for array expressions (if unspecified, this rule will not apply to array expressions)
+* `"ArrayPattern"` configuration for array patterns of destructuring assignments (if unspecified, this rule will not apply to array patterns)
+
 ### always
 
 Examples of **incorrect** code for this rule with the default `"always"` option:
@@ -283,6 +297,63 @@ var e = [
 ];
 ```
 
+### ArrayExpression and ArrayPattern
+
+Examples of **incorrect** code for this rule with the `{ "ArrayExpression": "always", "ArrayPattern": "never" }` options:
+
+```js
+/*eslint array-element-newline: ["error", { "ArrayExpression": "always", "ArrayPattern": "never" }]*/
+
+var a = [1, 2];
+var b = [1, 2, 3];
+var c = [
+    function foo() {
+        dosomething();
+    }, function bar() {
+        dosomething();
+    }
+];
+
+var [d,
+    e] = arr;
+var [f,
+    g,
+    h] = arr;
+var [i = function foo() {
+  dosomething()
+},
+j = function bar() {
+  dosomething()
+}] = arr
+```
+
+Examples of **correct** code for this rule with the `{ "ArrayExpression": "always", "ArrayPattern": "never" }` options:
+
+```js
+/*eslint object-curly-newline: ["error", { "ArrayExpression": "always", "ArrayPattern": "never" }]*/
+
+var a = [1,
+    2];
+var b = [1,
+    2,
+    3];
+var c = [
+    function foo() {
+        dosomething();
+    },
+    function bar() {
+        dosomething();
+    }
+];
+
+var [d, e] = arr
+var [f, g, h] = arr
+var [i = function foo() {
+    dosomething()
+}, j = function bar() {
+    dosomething()
+}] = arr
+```
 
 ## When Not To Use It
 
diff --git a/docs/rules/default-case-last.md b/docs/rules/default-case-last.md
new file mode 100644
index 000000000..c9eedbeec
--- /dev/null
+++ b/docs/rules/default-case-last.md
@@ -0,0 +1,125 @@
+# Enforce default clauses in switch statements to be last (default-case-last)
+
+A `switch` statement can optionally have a `default` clause.
+
+If present, it's usually the last clause, but it doesn't need to be. It is also allowed to put the `default` clause before all `case` clauses, or anywhere between. The behavior is mostly the same as if it was the last clause. The `default` block will be still executed only if there is no match in the `case` clauses (including those defined after the `default`), but there is also the ability to "fall through" from the `default` clause to the following clause in the list. However, such flow is not common and it would be confusing to the readers.
+
+Even if there is no "fall through" logic, it's still unexpected to see the `default` clause before or between the `case` clauses. By convention, it is expected to be the last clause.
+
+If a `switch` statement should have a `default` clause, it's considered a best practice to define it as the last clause.
+
+## Rule Details
+
+This rule enforces `default` clauses in `switch` statements to be last.
+
+It applies only to `switch` statements that already have a `default` clause.
+
+This rule does not enforce the existence of `default` clauses. See [default-case](default-case.md) if you also want to enforce the existence of `default` clauses in `switch` statements.
+
+Examples of **incorrect** code for this rule:
+
+```js
+/*eslint default-case-last: "error"*/
+
+switch (foo) {
+    default:
+        bar();
+        break;
+    case "a":
+        baz();
+        break;
+}
+
+switch (foo) {
+    case 1:
+        bar();
+        break;
+    default:
+        baz();
+        break;
+    case 2:
+        quux();
+        break;
+}
+
+switch (foo) {
+    case "x":
+        bar();
+        break;
+    default:
+    case "y":
+        baz();
+        break;
+}
+
+switch (foo) {
+    default:
+        break;
+    case -1:
+        bar();
+        break;
+}
+
+switch (foo) {
+  default:
+    doSomethingIfNotZero();
+  case 0:
+    doSomethingAnyway();
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+/*eslint default-case-last: "error"*/
+
+switch (foo) {
+    case "a":
+        baz();
+        break;
+    default:
+        bar();
+        break;
+}
+
+switch (foo) {
+    case 1:
+        bar();
+        break;
+    case 2:
+        quux();
+        break;
+    default:
+        baz();
+        break;
+}
+
+switch (foo) {
+    case "x":
+        bar();
+        break;
+    case "y":
+    default:
+        baz();
+        break;
+}
+
+switch (foo) {
+    case -1:
+        bar();
+        break;
+}
+
+if (foo !== 0) {
+    doSomethingIfNotZero();
+}
+doSomethingAnyway();
+```
+
+## Further Reading
+
+* [MDN switch statement](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
+
+## Related Rules
+
+* [default-case](default-case.md)
diff --git a/docs/rules/no-magic-numbers.md b/docs/rules/no-magic-numbers.md
index 7d1e5a558..f6e1bacbd 100644
--- a/docs/rules/no-magic-numbers.md
+++ b/docs/rules/no-magic-numbers.md
@@ -56,6 +56,9 @@ var dutyFreePrice = 100,
 An array of numbers to ignore. It's set to `[]` by default.
 If provided, it must be an `Array`.
 
+The array can contain values of `number` and `string` types.
+If it's a string, the text must be parsed as `bigint` literal (e.g., `"100n"`).
+
 Examples of **correct** code for the sample `{ "ignore": [1] }` option:
 
 ```js
@@ -65,6 +68,14 @@ var data = ['foo', 'bar', 'baz'];
 var dataLast = data.length && data[data.length - 1];
 ```
 
+Examples of **correct** code for the sample `{ "ignore": ["1n"] }` option:
+
+```js
+/*eslint no-magic-numbers: ["error", { "ignore": ["1n"] }]*/
+
+foo(1n);
+```
+
 ### ignoreArrayIndexes
 
 A boolean to specify if numbers used as array indexes are considered okay. `false` by default.
diff --git a/docs/rules/radix.md b/docs/rules/radix.md
index 64466ab68..da3196c85 100644
--- a/docs/rules/radix.md
+++ b/docs/rules/radix.md
@@ -43,6 +43,8 @@ var num = parseInt(someValue);
 
 var num = parseInt("071", "abc");
 
+var num = parseInt("071", 37);
+
 var num = parseInt();
 ```
 
diff --git a/docs/user-guide/command-line-interface.md b/docs/user-guide/command-line-interface.md
index 89f42744e..9a6e43a74 100644
--- a/docs/user-guide/command-line-interface.md
+++ b/docs/user-guide/command-line-interface.md
@@ -127,19 +127,19 @@ Examples:
 
 #### `--ext`
 
-This option allows you to specify which file extensions ESLint will use when searching for JavaScript files in the directories you specify.
-By default, it uses `.js` as the only file extension.
+This option allows you to specify which file extensions ESLint will use when searching for target files in the directories you specify.
+By default, ESLint lints `*.js` files and the files that match the `overrides` entries of your configuration.
 
 Examples:
 
-    # Use only .js2 extension
-    eslint . --ext .js2
+    # Use only .ts extension
+    eslint . --ext .ts
 
-    # Use both .js and .js2
-    eslint . --ext .js --ext .js2
+    # Use both .js and .ts
+    eslint . --ext .js --ext .ts
 
-    # Also use both .js and .js2
-    eslint . --ext .js,.js2
+    # Also use both .js and .ts
+    eslint . --ext .js,.ts
 
 **Note:** `--ext` is only used when the arguments are directories. If you use glob patterns or file names, then `--ext` is ignored.
 
diff --git a/docs/user-guide/configuring.md b/docs/user-guide/configuring.md
index 6771287d3..deb25484f 100644
--- a/docs/user-guide/configuring.md
+++ b/docs/user-guide/configuring.md
@@ -125,7 +125,7 @@ Processors may make named code blocks such as `0.js` and `1.js`. ESLint handles
 }
 ```
 
-ESLint checks the file extension of named code blocks then ignores those if [`--ext` CLI option](../user-guide/command-line-interface.md#--ext) didn't include the file extension. Be sure to specify the `--ext` option if you wanted to lint named code blocks other than `*.js`.
+ESLint checks the file path of named code blocks then ignores those if any `overrides` entry didn't match the file path. Be sure to make `overrides` entry if you wanted to lint named code blocks other than `*.js`.
 
 ## Specifying Environments
 
@@ -420,6 +420,25 @@ If a rule has additional options, you can specify them using array literal synta
 
 This comment specifies the "double" option for the [`quotes`](../rules/quotes) rule. The first item in the array is always the rule severity (number or string).
 
+Configuration comments can include descriptions to explain why the comment is necessary. The description must occur after the configuration and is separated from the configuration by two or more consecutive `-` characters. For example:
+
+```js
+/* eslint eqeqeq: "off", curly: "error" -- Here's a description about why this configuration is necessary. */
+```
+
+```js
+/* eslint eqeqeq: "off", curly: "error"
+    --------
+    Here's a description about why this configuration is necessary. */
+```
+
+```js
+/* eslint eqeqeq: "off", curly: "error"
+ * --------
+ * This will not work due to the line above starting with a '*' character.
+ */
+```
+
 ### Using Configuration Files
 
 To configure rules inside of a configuration file, use the `rules` key along with an error level and any options you want to use. For example:
@@ -574,6 +593,13 @@ foo(); // eslint-disable-line example/rule-name
 foo(); /* eslint-disable-line example/rule-name */
 ```
 
+Configuration comments can include descriptions to explain why the comment is necessary. The description must occur after the configuration and is separated from the configuration by two or more consecutive `-` characters. For example:
+
+```js
+// eslint-disable-next-line no-console -- Here's a description about why this configuration is necessary.
+console.log('hello');
+```
+
 **Note:** Comments that disable warnings for a portion of a file tell ESLint not to report rule violations for the disabled code. ESLint still parses the entire file, however, so disabled code still needs to be syntactically valid JavaScript.
 
 
@@ -964,6 +990,12 @@ In your `.eslintrc.json`:
 }
 ```
 
+### Specifying Target Files to Lint
+
+If you specified directories with CLI (e.g., `eslint lib`), ESLint searches target files in the directory to lint. The target files are `*.js` or the files that match any of `overrides` entries (but exclude entries that are any of `files` end with `*`).
+
+If you specified the [`--ext`](./command-line-interface#ext) command line option along with directories, the target files are only the files that have specified file extensions regardless of `overrides` entries.
+
 ## Comments in Configuration Files
 
 Both the JSON and YAML configuration file formats support comments (`package.json` files should not include them). You can use JavaScript-style comments or YAML-style comments in either type of file and ESLint will safely ignore them. This allows your configuration files to be more human-friendly. For example:
@@ -981,10 +1013,6 @@ Both the JSON and YAML configuration file formats support comments (`package.jso
 }
 ```
 
-## Specifying File extensions to Lint
-
-Currently the sole method for telling ESLint which file extensions to lint is by specifying a comma separated list of extensions using the [`--ext`](./command-line-interface#ext) command line option. Note this flag only takes effect in conjunction with directories, and will be ignored if used with filenames or glob patterns.
-
 ## Ignoring Files and Directories
 
 ### `ignorePatterns` in config files
diff --git a/lib/cli-engine/cascading-config-array-factory.js b/lib/cli-engine/cascading-config-array-factory.js
index ca03bec06..f91dea4c4 100644
--- a/lib/cli-engine/cascading-config-array-factory.js
+++ b/lib/cli-engine/cascading-config-array-factory.js
@@ -106,6 +106,7 @@ function createBaseConfigArray({
      */
     if (rulePaths && rulePaths.length > 0) {
         baseConfigArray.push({
+            type: "config",
             name: "--rulesdir",
             filePath: "",
             plugins: {
diff --git a/lib/cli-engine/cli-engine.js b/lib/cli-engine/cli-engine.js
index 22336a91d..6a0352399 100644
--- a/lib/cli-engine/cli-engine.js
+++ b/lib/cli-engine/cli-engine.js
@@ -57,7 +57,7 @@ const validFixTypes = new Set(["problem", "suggestion", "layout"]);
  * @property {string} configFile The configuration file to use.
  * @property {string} cwd The value to use for the current working directory.
  * @property {string[]} envs An array of environments to load.
- * @property {string[]} extensions An array of file extensions to check.
+ * @property {string[]|null} extensions An array of file extensions to check.
  * @property {boolean|Function} fix Execute in autofix mode. If a function, should return a boolean.
  * @property {string[]} fixTypes Array of rule types to apply fixes for.
  * @property {string[]} globals An array of global variables to declare.
@@ -201,7 +201,7 @@ function calculateStatsPerRun(results) {
  * @param {boolean} config.fix If `true` then it does fix.
  * @param {boolean} config.allowInlineConfig If `true` then it uses directive comments.
  * @param {boolean} config.reportUnusedDisableDirectives If `true` then it reports unused `eslint-disable` comments.
- * @param {RegExp} config.extensionRegExp The `RegExp` object that tests if a file path has the allowed file extensions.
+ * @param {FileEnumerator} config.fileEnumerator The file enumerator to check if a path is a target or not.
  * @param {Linter} config.linter The linter instance to verify.
  * @returns {LintResult} The result of linting.
  * @private
@@ -214,7 +214,7 @@ function verifyText({
     fix,
     allowInlineConfig,
     reportUnusedDisableDirectives,
-    extensionRegExp,
+    fileEnumerator,
     linter
 }) {
     const filePath = providedFilePath || "<text>";
@@ -238,13 +238,11 @@ function verifyText({
 
             /**
              * Check if the linter should adopt a given code block or not.
-             * Currently, the linter adopts code blocks if the name matches `--ext` option.
-             * In the future, `overrides` in the configuration would affect the adoption (https://github.com/eslint/rfcs/pull/20).
              * @param {string} blockFilename The virtual filename of a code block.
              * @returns {boolean} `true` if the linter should adopt the code block.
              */
             filterCodeBlock(blockFilename) {
-                return extensionRegExp.test(blockFilename);
+                return fileEnumerator.isTargetPath(blockFilename);
             }
         }
     );
@@ -704,7 +702,7 @@ class CLIEngine {
             return patterns.filter(Boolean);
         }
 
-        const extensions = options.extensions.map(ext => ext.replace(/^\./u, ""));
+        const extensions = (options.extensions || [".js"]).map(ext => ext.replace(/^\./u, ""));
         const dirSuffix = `/**/*.{${extensions.join(",")}}`;
 
         return patterns.filter(Boolean).map(pathname => {
@@ -803,7 +801,7 @@ class CLIEngine {
                 fix,
                 allowInlineConfig,
                 reportUnusedDisableDirectives,
-                extensionRegExp: fileEnumerator.extensionRegExp,
+                fileEnumerator,
                 linter
             });
 
@@ -891,7 +889,7 @@ class CLIEngine {
                 fix,
                 allowInlineConfig,
                 reportUnusedDisableDirectives,
-                extensionRegExp: fileEnumerator.extensionRegExp,
+                fileEnumerator,
                 linter
             }));
         }
diff --git a/lib/cli-engine/config-array-factory.js b/lib/cli-engine/config-array-factory.js
index 2f6595355..997a7e153 100644
--- a/lib/cli-engine/config-array-factory.js
+++ b/lib/cli-engine/config-array-factory.js
@@ -565,7 +565,7 @@ class ConfigArrayFactory {
      */
     *_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {
         const elements = this._normalizeObjectConfigData(
-            { ignorePatterns },
+            { type: "ignore", ignorePatterns },
             filePath,
             name
         );
@@ -667,6 +667,7 @@ class ConfigArrayFactory {
             root,
             rules,
             settings,
+            type = "config",
             overrides: overrideList = []
         },
         filePath,
@@ -698,6 +699,7 @@ class ConfigArrayFactory {
         yield {
 
             // Debug information.
+            type,
             name,
             filePath,
 
@@ -1047,6 +1049,7 @@ class ConfigArrayFactory {
                 if (processorId.startsWith(".")) {
                     yield* this._normalizeObjectConfigData(
                         {
+                            type: "implicit-processor",
                             files: [`*${processorId}`],
                             processor: `${pluginId}/${processorId}`
                         },
diff --git a/lib/cli-engine/config-array/config-array.js b/lib/cli-engine/config-array/config-array.js
index 4fae8deac..02f73b43e 100644
--- a/lib/cli-engine/config-array/config-array.js
+++ b/lib/cli-engine/config-array/config-array.js
@@ -454,6 +454,25 @@ class ConfigArray extends Array {
 
         return cache.get(cacheKey);
     }
+
+    /**
+     * Check if a given path is an additional lint target.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {boolean} `true` if the file is an additional lint target.
+     */
+    isAdditionalTargetPath(filePath) {
+        for (const { criteria, type } of this) {
+            if (
+                type === "config" &&
+                criteria &&
+                !criteria.endsWithWildcard &&
+                criteria.test(filePath)
+            ) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 
 const exportObject = {
diff --git a/lib/cli-engine/file-enumerator.js b/lib/cli-engine/file-enumerator.js
index f6f4987ea..16e5182ad 100644
--- a/lib/cli-engine/file-enumerator.js
+++ b/lib/cli-engine/file-enumerator.js
@@ -88,7 +88,7 @@ const IGNORED = 2;
  * @typedef {Object} FileEnumeratorInternalSlots
  * @property {CascadingConfigArrayFactory} configArrayFactory The factory for config arrays.
  * @property {string} cwd The base directory to start lookup.
- * @property {RegExp} extensionRegExp The RegExp to test if a string ends with specific file extensions.
+ * @property {RegExp|null} extensionRegExp The RegExp to test if a string ends with specific file extensions.
  * @property {boolean} globInputPaths Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} ignoreFlag The flag to check ignored files.
  * @property {(filePath:string, dot:boolean) => boolean} defaultIgnores The default predicate function to ignore files.
@@ -142,6 +142,27 @@ function readdirSafeSync(directoryPath) {
     }
 }
 
+/**
+ * Create a `RegExp` object to detect extensions.
+ * @param {string[] | null} extensions The extensions to create.
+ * @returns {RegExp | null} The created `RegExp` object or null.
+ */
+function createExtensionRegExp(extensions) {
+    if (extensions) {
+        const normalizedExts = extensions.map(ext => escapeRegExp(
+            ext.startsWith(".")
+                ? ext.slice(1)
+                : ext
+        ));
+
+        return new RegExp(
+            `.\\.(?:${normalizedExts.join("|")})$`,
+            "u"
+        );
+    }
+    return null;
+}
+
 /**
  * The error type when no files match a glob.
  */
@@ -188,7 +209,7 @@ class FileEnumerator {
     constructor({
         cwd = process.cwd(),
         configArrayFactory = new CascadingConfigArrayFactory({ cwd }),
-        extensions = [".js"],
+        extensions = null,
         globInputPaths = true,
         errorOnUnmatchedPattern = true,
         ignore = true
@@ -197,17 +218,7 @@ class FileEnumerator {
             configArrayFactory,
             cwd,
             defaultIgnores: IgnorePattern.createDefaultIgnore(cwd),
-            extensionRegExp: new RegExp(
-                `.\\.(?:${extensions
-                    .map(ext => escapeRegExp(
-                        ext.startsWith(".")
-                            ? ext.slice(1)
-                            : ext
-                    ))
-                    .join("|")
-                })$`,
-                "u"
-            ),
+            extensionRegExp: createExtensionRegExp(extensions),
             globInputPaths,
             errorOnUnmatchedPattern,
             ignoreFlag: ignore
@@ -215,11 +226,36 @@ class FileEnumerator {
     }
 
     /**
-     * The `RegExp` object that tests if a file path has the allowed file extensions.
-     * @type {RegExp}
+     * Check if a given file is target or not.
+     * @param {string} filePath The path to a candidate file.
+     * @param {ConfigArray} [providedConfig] Optional. The configuration for the file.
+     * @returns {boolean} `true` if the file is a target.
      */
-    get extensionRegExp() {
-        return internalSlotsMap.get(this).extensionRegExp;
+    isTargetPath(filePath, providedConfig) {
+        const {
+            configArrayFactory,
+            extensionRegExp
+        } = internalSlotsMap.get(this);
+
+        // If `--ext` option is present, use it.
+        if (extensionRegExp) {
+            return extensionRegExp.test(filePath);
+        }
+
+        // `.js` file is target by default.
+        if (filePath.endsWith(".js")) {
+            return true;
+        }
+
+        // use `overrides[].files` to check additional targets.
+        const config =
+            providedConfig ||
+            configArrayFactory.getConfigArrayForFile(
+                filePath,
+                { ignoreNotFoundError: true }
+            );
+
+        return config.isAdditionalTargetPath(filePath);
     }
 
     /**
@@ -380,7 +416,7 @@ class FileEnumerator {
      */
     *_iterateFilesRecursive(directoryPath, options) {
         debug(`Enter the directory: ${directoryPath}`);
-        const { configArrayFactory, extensionRegExp } = internalSlotsMap.get(this);
+        const { configArrayFactory } = internalSlotsMap.get(this);
 
         /** @type {ConfigArray|null} */
         let config = null;
@@ -403,17 +439,18 @@ class FileEnumerator {
                         { ignoreNotFoundError: true }
                     );
                 }
-                const ignored = this._isIgnoredFile(filePath, { ...options, config });
-                const flag = ignored ? IGNORED_SILENTLY : NONE;
                 const matched = options.selector
 
                     // Started with a glob pattern; choose by the pattern.
                     ? options.selector.match(filePath)
 
                     // Started with a directory path; choose by file extensions.
-                    : extensionRegExp.test(filePath);
+                    : this.isTargetPath(filePath, config);
 
                 if (matched) {
+                    const ignored = this._isIgnoredFile(filePath, { ...options, config });
+                    const flag = ignored ? IGNORED_SILENTLY : NONE;
+
                     debug(`Yield: ${entry.name}${ignored ? " but ignored" : ""}`);
                     yield {
                         config: configArrayFactory.getConfigArrayForFile(filePath),
diff --git a/lib/linter/linter.js b/lib/linter/linter.js
index 6d88cb5aa..76d35b49e 100644
--- a/lib/linter/linter.js
+++ b/lib/linter/linter.js
@@ -267,6 +267,15 @@ function createDisableDirectives(options) {
     return result;
 }
 
+/**
+ * Remove the ignored part from a given directive comment and trim it.
+ * @param {string} value The comment text to strip.
+ * @returns {string} The stripped text.
+ */
+function stripDirectiveComment(value) {
+    return value.split(/\s-{2,}\s/u)[0].trim();
+}
+
 /**
  * Parses comments in file to extract file-specific config of rules, globals
  * and environments and merges them with global config; also code blocks
@@ -286,7 +295,7 @@ function getDirectiveComments(filename, ast, ruleMapper, warnInlineConfig) {
     const disableDirectives = [];
 
     ast.comments.filter(token => token.type !== "Shebang").forEach(comment => {
-        const trimmedCommentText = comment.value.trim();
+        const trimmedCommentText = stripDirectiveComment(comment.value);
         const match = /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u.exec(trimmedCommentText);
 
         if (!match) {
@@ -444,8 +453,11 @@ function findEslintEnv(text) {
 
     eslintEnvPattern.lastIndex = 0;
 
-    while ((match = eslintEnvPattern.exec(text))) {
-        retv = Object.assign(retv || {}, commentParser.parseListConfig(match[1]));
+    while ((match = eslintEnvPattern.exec(text)) !== null) {
+        retv = Object.assign(
+            retv || {},
+            commentParser.parseListConfig(stripDirectiveComment(match[1]))
+        );
     }
 
     return retv;
diff --git a/lib/rules/array-callback-return.js b/lib/rules/array-callback-return.js
index d632a3f30..6e425dcdc 100644
--- a/lib/rules/array-callback-return.js
+++ b/lib/rules/array-callback-return.js
@@ -18,7 +18,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
-const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|map|reduce(?:Right)?|some|sort)$/u;
+const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|flatMap|map|reduce(?:Right)?|some|sort)$/u;
 
 /**
  * Checks a given code path segment is reachable.
diff --git a/lib/rules/array-element-newline.js b/lib/rules/array-element-newline.js
index 1da67667b..b7a967865 100644
--- a/lib/rules/array-element-newline.js
+++ b/lib/rules/array-element-newline.js
@@ -24,28 +24,52 @@ module.exports = {
 
         fixable: "whitespace",
 
-        schema: [
-            {
-                oneOf: [
-                    {
-                        enum: ["always", "never", "consistent"]
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            multiline: {
-                                type: "boolean"
+        schema: {
+            definitions: {
+                basicConfig: {
+                    oneOf: [
+                        {
+                            enum: ["always", "never", "consistent"]
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                multiline: {
+                                    type: "boolean"
+                                },
+                                minItems: {
+                                    type: ["integer", "null"],
+                                    minimum: 0
+                                }
                             },
-                            minItems: {
-                                type: ["integer", "null"],
-                                minimum: 0
-                            }
+                            additionalProperties: false
+                        }
+                    ]
+                }
+            },
+            items: [
+                {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/basicConfig"
                         },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
+                        {
+                            type: "object",
+                            properties: {
+                                ArrayExpression: {
+                                    $ref: "#/definitions/basicConfig"
+                                },
+                                ArrayPattern: {
+                                    $ref: "#/definitions/basicConfig"
+                                }
+                            },
+                            additionalProperties: false,
+                            minProperties: 1
+                        }
+                    ]
+                }
+            ]
+        },
 
         messages: {
             unexpectedLineBreak: "There should be no linebreak here.",
@@ -93,6 +117,20 @@ module.exports = {
          * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
          */
         function normalizeOptions(options) {
+            if (options && (options.ArrayExpression || options.ArrayPattern)) {
+                let expressionOptions, patternOptions;
+
+                if (options.ArrayExpression) {
+                    expressionOptions = normalizeOptionValue(options.ArrayExpression);
+                }
+
+                if (options.ArrayPattern) {
+                    patternOptions = normalizeOptionValue(options.ArrayPattern);
+                }
+
+                return { ArrayExpression: expressionOptions, ArrayPattern: patternOptions };
+            }
+
             const value = normalizeOptionValue(options);
 
             return { ArrayExpression: value, ArrayPattern: value };
@@ -177,6 +215,10 @@ module.exports = {
             const normalizedOptions = normalizeOptions(context.options[0]);
             const options = normalizedOptions[node.type];
 
+            if (!options) {
+                return;
+            }
+
             let elementBreak = false;
 
             /*
diff --git a/lib/rules/computed-property-spacing.js b/lib/rules/computed-property-spacing.js
index a0bd7f48c..48bea6a6f 100644
--- a/lib/rules/computed-property-spacing.js
+++ b/lib/rules/computed-property-spacing.js
@@ -67,7 +67,7 @@ module.exports = {
         function reportNoBeginningSpace(node, token, tokenAfter) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: token.loc.end, end: tokenAfter.loc.start },
                 messageId: "unexpectedSpaceAfter",
                 data: {
                     tokenValue: token.value
@@ -88,7 +88,7 @@ module.exports = {
         function reportNoEndingSpace(node, token, tokenBefore) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: tokenBefore.loc.end, end: token.loc.start },
                 messageId: "unexpectedSpaceBefore",
                 data: {
                     tokenValue: token.value
@@ -108,7 +108,7 @@ module.exports = {
         function reportRequiredBeginningSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 messageId: "missingSpaceAfter",
                 data: {
                     tokenValue: token.value
@@ -128,7 +128,7 @@ module.exports = {
         function reportRequiredEndingSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 messageId: "missingSpaceBefore",
                 data: {
                     tokenValue: token.value
diff --git a/lib/rules/default-case-last.js b/lib/rules/default-case-last.js
new file mode 100644
index 000000000..80c5d6bda
--- /dev/null
+++ b/lib/rules/default-case-last.js
@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Rule to enforce default clauses in switch statements to be last
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "enforce default clauses in switch statements to be last",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/default-case-last"
+        },
+
+        schema: [],
+
+        messages: {
+            notLast: "Default clause should be the last clause."
+        }
+    },
+
+    create(context) {
+        return {
+            SwitchStatement(node) {
+                const cases = node.cases,
+                    indexOfDefault = cases.findIndex(c => c.test === null);
+
+                if (indexOfDefault !== -1 && indexOfDefault !== cases.length - 1) {
+                    const defaultClause = cases[indexOfDefault];
+
+                    context.report({ node: defaultClause, messageId: "notLast" });
+                }
+            }
+        };
+    }
+};
diff --git a/lib/rules/id-blacklist.js b/lib/rules/id-blacklist.js
index 53be62e68..e5dcdc630 100644
--- a/lib/rules/id-blacklist.js
+++ b/lib/rules/id-blacklist.js
@@ -61,9 +61,12 @@ module.exports = {
          * @returns {boolean} whether an error should be reported or not
          */
         function shouldReport(effectiveParent, name) {
-            return effectiveParent.type !== "CallExpression" &&
+            return (
+                effectiveParent.type !== "CallExpression" &&
                 effectiveParent.type !== "NewExpression" &&
-                isInvalid(name);
+                effectiveParent.parent.type !== "ObjectPattern" &&
+                isInvalid(name)
+            );
         }
 
         /**
@@ -98,11 +101,11 @@ module.exports = {
                             report(node);
                         }
 
-                        // Report AssignmentExpressions only if they are the left side of the assignment
+                    // Report AssignmentExpressions only if they are the left side of the assignment
                     } else if (effectiveParent.type === "AssignmentExpression" &&
                         (effectiveParent.right.type !== "MemberExpression" ||
-                        effectiveParent.left.type === "MemberExpression" &&
-                        effectiveParent.left.property.name === node.name)) {
+                            effectiveParent.left.type === "MemberExpression" &&
+                            effectiveParent.left.property.name === node.name)) {
                         if (isInvalid(name)) {
                             report(node);
                         }
@@ -115,7 +118,7 @@ module.exports = {
                         report(node);
                     }
 
-                // Report anything that is a match and not a CallExpression
+                    // Report anything that is a match and not a CallExpression
                 } else if (shouldReport(effectiveParent, name)) {
                     report(node);
                 }
diff --git a/lib/rules/indent.js b/lib/rules/indent.js
index 59d50e2cc..d576fde03 100644
--- a/lib/rules/indent.js
+++ b/lib/rules/indent.js
@@ -933,7 +933,11 @@ module.exports = {
 
             parameterParens.add(openingParen);
             parameterParens.add(closingParen);
-            offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);
+
+            const offsetAfterToken = node.callee.type === "TaggedTemplateExpression" ? sourceCode.getFirstToken(node.callee.quasi) : openingParen;
+            const offsetToken = sourceCode.getTokenBefore(offsetAfterToken);
+
+            offsets.setDesiredOffset(openingParen, offsetToken, 0);
 
             addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);
         }
diff --git a/lib/rules/index.js b/lib/rules/index.js
index 74b0a3fb9..7f563eb2e 100644
--- a/lib/rules/index.js
+++ b/lib/rules/index.js
@@ -37,6 +37,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "constructor-super": () => require("./constructor-super"),
     curly: () => require("./curly"),
     "default-case": () => require("./default-case"),
+    "default-case-last": () => require("./default-case-last"),
     "default-param-last": () => require("./default-param-last"),
     "dot-location": () => require("./dot-location"),
     "dot-notation": () => require("./dot-notation"),
diff --git a/lib/rules/key-spacing.js b/lib/rules/key-spacing.js
index 6d1b9121c..c40504379 100644
--- a/lib/rules/key-spacing.js
+++ b/lib/rules/key-spacing.js
@@ -414,8 +414,7 @@ module.exports = {
             if (property.computed) {
                 return sourceCode.getText().slice(key.range[0], key.range[1]);
             }
-
-            return property.key.name || property.key.value;
+            return astUtils.getStaticPropertyName(property);
         }
 
         /**
diff --git a/lib/rules/new-cap.js b/lib/rules/new-cap.js
index cee979310..7cce968c5 100644
--- a/lib/rules/new-cap.js
+++ b/lib/rules/new-cap.js
@@ -9,6 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -160,13 +162,7 @@ module.exports = {
             let name = "";
 
             if (node.callee.type === "MemberExpression") {
-                const property = node.callee.property;
-
-                if (property.type === "Literal" && (typeof property.value === "string")) {
-                    name = property.value;
-                } else if (property.type === "Identifier" && !node.callee.computed) {
-                    name = property.name;
-                }
+                name = astUtils.getStaticPropertyName(node.callee) || "";
             } else {
                 name = node.callee.name;
             }
diff --git a/lib/rules/no-dupe-class-members.js b/lib/rules/no-dupe-class-members.js
index 6041e9e37..55639746b 100644
--- a/lib/rules/no-dupe-class-members.js
+++ b/lib/rules/no-dupe-class-members.js
@@ -5,6 +5,8 @@
 
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -53,21 +55,6 @@ module.exports = {
             return stateMap[key][isStatic ? "static" : "nonStatic"];
         }
 
-        /**
-         * Gets the name text of a given node.
-         * @param {ASTNode} node A node to get the name.
-         * @returns {string} The name text of the node.
-         */
-        function getName(node) {
-            switch (node.type) {
-                case "Identifier": return node.name;
-                case "Literal": return String(node.value);
-
-                /* istanbul ignore next: syntax error */
-                default: return "";
-            }
-        }
-
         return {
 
             // Initializes the stack of state of member declarations.
@@ -91,7 +78,7 @@ module.exports = {
                     return;
                 }
 
-                const name = getName(node.key);
+                const name = astUtils.getStaticPropertyName(node) || "";
                 const state = getState(name, node.static);
                 let isDuplicate = false;
 
diff --git a/lib/rules/no-extra-parens.js b/lib/rules/no-extra-parens.js
index e0ab32b4e..e70353576 100644
--- a/lib/rules/no-extra-parens.js
+++ b/lib/rules/no-extra-parens.js
@@ -342,6 +342,17 @@ module.exports = {
             return node.type === "CallExpression" && node.callee.type === "FunctionExpression";
         }
 
+        /**
+         * Determines if the given node can be the assignment target in destructuring or the LHS of an assignment.
+         * This is to avoid an autofix that could change behavior because parsers mistakenly allow invalid syntax,
+         * such as `(a = b) = c` and `[(a = b) = c] = []`. Ideally, this function shouldn't be necessary.
+         * @param {ASTNode} [node] The node to check
+         * @returns {boolean} `true` if the given node can be a valid assignment target
+         */
+        function canBeAssignmentTarget(node) {
+            return node && (node.type === "Identifier" || node.type === "MemberExpression");
+        }
+
         /**
          * Report the node
          * @param {ASTNode} node node to evaluate
@@ -679,6 +690,12 @@ module.exports = {
                     .forEach(report);
             },
 
+            ArrayPattern(node) {
+                node.elements
+                    .filter(e => canBeAssignmentTarget(e) && hasExcessParens(e))
+                    .forEach(report);
+            },
+
             ArrowFunctionExpression(node) {
                 if (isReturnAssignException(node)) {
                     return;
@@ -705,6 +722,10 @@ module.exports = {
             },
 
             AssignmentExpression(node) {
+                if (canBeAssignmentTarget(node.left) && hasExcessParens(node.left)) {
+                    report(node.left);
+                }
+
                 if (!isReturnAssignException(node) && hasExcessParensWithPrecedence(node.right, precedence(node))) {
                     report(node.right);
                 }
@@ -947,6 +968,15 @@ module.exports = {
                     .forEach(property => report(property.value));
             },
 
+            ObjectPattern(node) {
+                node.properties
+                    .filter(property => {
+                        const value = property.value;
+
+                        return canBeAssignmentTarget(value) && hasExcessParens(value);
+                    }).forEach(property => report(property.value));
+            },
+
             Property(node) {
                 if (node.computed) {
                     const { key } = node;
@@ -957,6 +987,14 @@ module.exports = {
                 }
             },
 
+            RestElement(node) {
+                const argument = node.argument;
+
+                if (canBeAssignmentTarget(argument) && hasExcessParens(argument)) {
+                    report(argument);
+                }
+            },
+
             ReturnStatement(node) {
                 const returnToken = sourceCode.getFirstToken(node);
 
@@ -1054,7 +1092,11 @@ module.exports = {
             },
 
             AssignmentPattern(node) {
-                const { right } = node;
+                const { left, right } = node;
+
+                if (canBeAssignmentTarget(left) && hasExcessParens(left)) {
+                    report(left);
+                }
 
                 if (right && hasExcessParensWithPrecedence(right, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
                     report(right);
diff --git a/lib/rules/no-magic-numbers.js b/lib/rules/no-magic-numbers.js
index 0909e3166..4bf24996c 100644
--- a/lib/rules/no-magic-numbers.js
+++ b/lib/rules/no-magic-numbers.js
@@ -5,10 +5,24 @@
 
 "use strict";
 
+const { isNumericLiteral } = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/**
+ * Convert the value to bigint if it's a string. Otherwise return the value as-is.
+ * @param {bigint|number|string} x The value to normalize.
+ * @returns {bigint|number} The normalized value.
+ */
+function normalizeIgnoreValue(x) {
+    if (typeof x === "string") {
+        return BigInt(x.slice(0, -1));
+    }
+    return x;
+}
+
 module.exports = {
     meta: {
         type: "suggestion",
@@ -34,7 +48,10 @@ module.exports = {
                 ignore: {
                     type: "array",
                     items: {
-                        type: "number"
+                        anyOf: [
+                            { type: "number" },
+                            { type: "string", pattern: "^[+-]?(?:0|[1-9][0-9]*)n$" }
+                        ]
                     },
                     uniqueItems: true
                 },
@@ -56,18 +73,9 @@ module.exports = {
         const config = context.options[0] || {},
             detectObjects = !!config.detectObjects,
             enforceConst = !!config.enforceConst,
-            ignore = config.ignore || [],
+            ignore = (config.ignore || []).map(normalizeIgnoreValue),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes;
 
-        /**
-         * Returns whether the node is number literal
-         * @param {Node} node the node literal being evaluated
-         * @returns {boolean} true if the node is a number literal
-         */
-        function isNumber(node) {
-            return typeof node.value === "number";
-        }
-
         /**
          * Returns whether the number should be ignored
          * @param {number} num the number
@@ -113,7 +121,7 @@ module.exports = {
             Literal(node) {
                 const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
-                if (!isNumber(node)) {
+                if (!isNumericLiteral(node)) {
                     return;
                 }
 
diff --git a/lib/rules/no-restricted-imports.js b/lib/rules/no-restricted-imports.js
index 5514b979c..c205dad8b 100644
--- a/lib/rules/no-restricted-imports.js
+++ b/lib/rules/no-restricted-imports.js
@@ -91,6 +91,7 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
         const options = Array.isArray(context.options) ? context.options : [];
         const isPathAndPatternsObject =
             typeof options[0] === "object" &&
@@ -216,30 +217,36 @@ module.exports = {
          */
         function checkNode(node) {
             const importSource = node.source.value.trim();
-            const importNames = node.specifiers ? node.specifiers.reduce((map, specifier) => {
-                let name;
-                const specifierData = { loc: specifier.loc };
-
-                if (specifier.type === "ImportDefaultSpecifier") {
-                    name = "default";
-                } else if (specifier.type === "ImportNamespaceSpecifier") {
-                    name = "*";
-                } else if (specifier.imported) {
-                    name = specifier.imported.name;
-                } else if (specifier.local) {
-                    name = specifier.local.name;
-                }
+            const importNames = new Map();
+
+            if (node.type === "ExportAllDeclaration") {
+                const starToken = sourceCode.getFirstToken(node, 1);
+
+                importNames.set("*", [{ loc: starToken.loc }]);
+            } else if (node.specifiers) {
+                for (const specifier of node.specifiers) {
+                    let name;
+                    const specifierData = { loc: specifier.loc };
+
+                    if (specifier.type === "ImportDefaultSpecifier") {
+                        name = "default";
+                    } else if (specifier.type === "ImportNamespaceSpecifier") {
+                        name = "*";
+                    } else if (specifier.imported) {
+                        name = specifier.imported.name;
+                    } else if (specifier.local) {
+                        name = specifier.local.name;
+                    }
 
-                if (name) {
-                    if (map.has(name)) {
-                        map.get(name).push(specifierData);
-                    } else {
-                        map.set(name, [specifierData]);
+                    if (name) {
+                        if (importNames.has(name)) {
+                            importNames.get(name).push(specifierData);
+                        } else {
+                            importNames.set(name, [specifierData]);
+                        }
                     }
                 }
-
-                return map;
-            }, new Map()) : new Map();
+            }
 
             checkRestrictedPathAndReport(importSource, importNames, node);
 
diff --git a/lib/rules/no-useless-computed-key.js b/lib/rules/no-useless-computed-key.js
index b5e53174e..0e0acbea7 100644
--- a/lib/rules/no-useless-computed-key.js
+++ b/lib/rules/no-useless-computed-key.js
@@ -71,14 +71,11 @@ module.exports = {
                     message: MESSAGE_UNNECESSARY_COMPUTED,
                     data: { property: sourceCode.getText(key) },
                     fix(fixer) {
-                        const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
-                        const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
-                        const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
+                        const leftSquareBracket = sourceCode.getTokenBefore(key, astUtils.isOpeningBracketToken);
+                        const rightSquareBracket = sourceCode.getTokenAfter(key, astUtils.isClosingBracketToken);
 
-                        if (tokensBetween.slice(0, -1).some((token, index) =>
-                            sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
-
-                            // If there are comments between the brackets and the property name, don't do a fix.
+                        // If there are comments between the brackets and the property name, don't do a fix.
+                        if (sourceCode.commentsExistBetween(leftSquareBracket, rightSquareBracket)) {
                             return null;
                         }
 
diff --git a/lib/rules/prefer-object-spread.js b/lib/rules/prefer-object-spread.js
index bbcd88bee..00f5fb6d4 100644
--- a/lib/rules/prefer-object-spread.js
+++ b/lib/rules/prefer-object-spread.js
@@ -25,6 +25,36 @@ function hasArraySpread(node) {
     return node.arguments.some(arg => arg.type === "SpreadElement");
 }
 
+/**
+ * Determines whether the given node is an accessor property (getter/setter).
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} `true` if the node is a getter or a setter.
+ */
+function isAccessorProperty(node) {
+    return node.type === "Property" &&
+        (node.kind === "get" || node.kind === "set");
+}
+
+/**
+ * Determines whether the given object expression node has accessor properties (getters/setters).
+ * @param {ASTNode} node `ObjectExpression` node to check.
+ * @returns {boolean} `true` if the node has at least one getter/setter.
+ */
+function hasAccessors(node) {
+    return node.properties.some(isAccessorProperty);
+}
+
+/**
+ * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
+ * @param {ASTNode} node `CallExpression` node to check.
+ * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
+ */
+function hasArgumentsWithAccessors(node) {
+    return node.arguments
+        .filter(arg => arg.type === "ObjectExpression")
+        .some(hasAccessors);
+}
+
 /**
  * Helper that checks if the node needs parentheses to be valid JS.
  * The default is to wrap the node in parentheses to avoid parsing errors.
@@ -249,7 +279,11 @@ module.exports = {
                     if (
                         node.arguments.length >= 1 &&
                         node.arguments[0].type === "ObjectExpression" &&
-                        !hasArraySpread(node)
+                        !hasArraySpread(node) &&
+                        !(
+                            node.arguments.length > 1 &&
+                            hasArgumentsWithAccessors(node)
+                        )
                     ) {
                         const messageId = node.arguments.length === 1
                             ? "useLiteralMessage"
diff --git a/lib/rules/quote-props.js b/lib/rules/quote-props.js
index ab09b8fa9..4cc53b988 100644
--- a/lib/rules/quote-props.js
+++ b/lib/rules/quote-props.js
@@ -8,8 +8,9 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const espree = require("espree"),
-    keywords = require("./utils/keywords");
+const espree = require("espree");
+const astUtils = require("./utils/ast-utils");
+const keywords = require("./utils/keywords");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -177,7 +178,7 @@ module.exports = {
                     data: { property: key.name },
                     fix: fixer => fixer.replaceText(key, getQuotedKey(key))
                 });
-            } else if (NUMBERS && key.type === "Literal" && typeof key.value === "number") {
+            } else if (NUMBERS && key.type === "Literal" && astUtils.isNumericLiteral(key)) {
                 context.report({
                     node,
                     message: MESSAGE_NUMERIC,
diff --git a/lib/rules/radix.js b/lib/rules/radix.js
index ed3c5cb66..2174e7d03 100644
--- a/lib/rules/radix.js
+++ b/lib/rules/radix.js
@@ -18,6 +18,8 @@ const astUtils = require("./utils/ast-utils");
 const MODE_ALWAYS = "always",
     MODE_AS_NEEDED = "as-needed";
 
+const validRadixValues = new Set(Array.from({ length: 37 - 2 }, (_, index) => index + 2));
+
 /**
  * Checks whether a given variable is shadowed or not.
  * @param {eslint-scope.Variable} variable A variable to check.
@@ -47,14 +49,14 @@ function isParseIntMethod(node) {
  *
  * The following values are invalid.
  *
- * - A literal except numbers.
+ * - A literal except integers between 2 and 36.
  * - undefined.
  * @param {ASTNode} radix A node of radix to check.
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidRadix(radix) {
     return !(
-        (radix.type === "Literal" && typeof radix.value !== "number") ||
+        (radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
         (radix.type === "Identifier" && radix.name === "undefined")
     );
 }
@@ -128,7 +130,7 @@ module.exports = {
                     } else if (!isValidRadix(args[1])) {
                         context.report({
                             node,
-                            message: "Invalid radix parameter."
+                            message: "Invalid radix parameter, must be an integer between 2 and 36."
                         });
                     }
                     break;
diff --git a/lib/rules/template-curly-spacing.js b/lib/rules/template-curly-spacing.js
index 07da6a39b..a16c0732d 100644
--- a/lib/rules/template-curly-spacing.js
+++ b/lib/rules/template-curly-spacing.js
@@ -57,7 +57,7 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingBefore(token) {
-            const prevToken = sourceCode.getTokenBefore(token);
+            const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });
 
             if (prevToken &&
                 CLOSE_PAREN.test(token.value) &&
@@ -86,7 +86,7 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingAfter(token) {
-            const nextToken = sourceCode.getTokenAfter(token);
+            const nextToken = sourceCode.getTokenAfter(token, { includeComments: true });
 
             if (nextToken &&
                 OPEN_PAREN.test(token.value) &&
diff --git a/lib/rules/utils/ast-utils.js b/lib/rules/utils/ast-utils.js
index b4e8e2980..e10544dd6 100644
--- a/lib/rules/utils/ast-utils.js
+++ b/lib/rules/utils/ast-utils.js
@@ -884,6 +884,9 @@ module.exports = {
                     if (node.regex) {
                         return `/${node.regex.pattern}/${node.regex.flags}`;
                     }
+                    if (node.bigint) {
+                        return node.bigint;
+                    }
 
                     // Otherwise, this is an unknown literal. The function will return null.
 
@@ -1014,6 +1017,7 @@ module.exports = {
      * 0o5     // false
      * 5e0     // false
      * '5'     // false
+     * 5n      // false
      */
     isDecimalInteger(node) {
         return node.type === "Literal" && typeof node.value === "number" &&
@@ -1333,6 +1337,18 @@ module.exports = {
         return node.type === "Literal" && node.value === null && !node.regex && !node.bigint;
     },
 
+    /**
+     * Check if a given node is a numeric literal or not.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} `true` if the node is a number or bigint literal.
+     */
+    isNumericLiteral(node) {
+        return (
+            node.type === "Literal" &&
+            (typeof node.value === "number" || Boolean(node.bigint))
+        );
+    },
+
     /**
      * Determines whether two tokens can safely be placed next to each other without merging into a single token
      * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
diff --git a/lib/rules/yoda.js b/lib/rules/yoda.js
index b00acf82c..be5c59ce0 100644
--- a/lib/rules/yoda.js
+++ b/lib/rules/yoda.js
@@ -53,8 +53,7 @@ function looksLikeLiteral(node) {
     return (node.type === "UnaryExpression" &&
         node.operator === "-" &&
         node.prefix &&
-        node.argument.type === "Literal" &&
-        typeof node.argument.value === "number");
+        astUtils.isNumericLiteral(node.argument));
 }
 
 /**
diff --git a/package.json b/package.json
index 713ca8c80..89f72eb52 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "6.8.0",
+  "version": "7.0.0-alpha.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -96,7 +96,7 @@
     "ejs": "^2.6.1",
     "eslint": "file:.",
     "eslint-config-eslint": "file:packages/eslint-config-eslint",
-    "eslint-plugin-eslint-plugin": "^2.0.1",
+    "eslint-plugin-eslint-plugin": "^2.2.1",
     "eslint-plugin-internal-rules": "file:tools/internal-rules",
     "eslint-plugin-jsdoc": "^15.9.5",
     "eslint-plugin-node": "^9.0.0",
diff --git a/tools/internal-rules/consistent-docs-description.js b/tools/internal-rules/consistent-docs-description.js
deleted file mode 100644
index 1519c0247..000000000
--- a/tools/internal-rules/consistent-docs-description.js
+++ /dev/null
@@ -1,134 +0,0 @@
-/**
- * @fileoverview Internal rule to enforce meta.docs.description conventions.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-const ALLOWED_FIRST_WORDS = [
-    "enforce",
-    "require",
-    "disallow"
-];
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property of the Object node passed in that has the name specified.
- * @param {string} property Name of the property to return.
- * @param {ASTNode} node The ObjectExpression node.
- * @returns {ASTNode} The Property node or null if not found.
- */
-function getPropertyFromObject(property, node) {
-    const properties = node.properties;
-
-    if (!Array.isArray(properties)) {
-
-        // if properties is not an array, "internal-no-invalid-meta" will already report this.
-        return null;
-    }
-
-    for (let i = 0; i < properties.length; i++) {
-        if (properties[i].key.name === property) {
-            return properties[i];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Verifies that the meta.docs.description property follows our internal conventions.
- * @param {RuleContext} context The ESLint rule context.
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @returns {void}
- */
-function checkMetaDocsDescription(context, exportsNode) {
-    if (exportsNode.type !== "ObjectExpression") {
-
-        // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const metaProperty = getPropertyFromObject("meta", exportsNode);
-    const metaDocs = metaProperty && getPropertyFromObject("docs", metaProperty.value);
-    const metaDocsDescription = metaDocs && getPropertyFromObject("description", metaDocs.value);
-
-    if (!metaDocsDescription) {
-
-        // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const description = metaDocsDescription.value.value;
-
-    if (typeof description !== "string") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should be a string."
-        });
-        return;
-    }
-
-    if (description === "") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not be empty."
-        });
-        return;
-    }
-
-    if (description.indexOf(" ") === 0) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not start with whitespace."
-        });
-        return;
-    }
-
-    const firstWord = description.split(" ")[0];
-
-    if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with \"{{ firstWord }}\" instead.",
-            data: {
-                allowedWords: ALLOWED_FIRST_WORDS.join(", "),
-                firstWord
-            }
-        });
-    }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-    meta: {
-        docs: {
-            description: "enforce correct conventions of `meta.docs.description` property in core rules",
-            category: "Internal",
-            recommended: false
-        },
-        type: "suggestion",
-        schema: []
-    },
-
-    create(context) {
-        return {
-            AssignmentExpression(node) {
-                if (node.left &&
-                    node.right &&
-                    node.left.type === "MemberExpression" &&
-                    node.left.object.name === "module" &&
-                    node.left.property.name === "exports") {
-
-                    checkMetaDocsDescription(context, node.right);
-                }
-            }
-        };
-    }
-};
diff --git a/tools/rule-types.json b/tools/rule-types.json
index 54f01e099..c3c249855 100644
--- a/tools/rule-types.json
+++ b/tools/rule-types.json
@@ -24,6 +24,7 @@
     "constructor-super": "problem",
     "curly": "suggestion",
     "default-case": "suggestion",
+    "default-case-last": "suggestion",
     "default-param-last": "suggestion",
     "dot-location": "layout",
     "dot-notation": "suggestion",


Test patch:
diff --git a/lib/cli-engine/config-array/override-tester.js b/lib/cli-engine/config-array/override-tester.js
index 67c8a6ed8..e7ba1202f 100644
--- a/lib/cli-engine/config-array/override-tester.js
+++ b/lib/cli-engine/config-array/override-tester.js
@@ -96,14 +96,22 @@ class OverrideTester {
     static create(files, excludedFiles, basePath) {
         const includePatterns = normalizePatterns(files);
         const excludePatterns = normalizePatterns(excludedFiles);
-        const allPatterns = includePatterns.concat(excludePatterns);
+        let endsWithWildcard = false;
 
-        if (allPatterns.length === 0) {
+        if (includePatterns.length === 0) {
             return null;
         }
 
         // Rejects absolute paths or relative paths to parents.
-        for (const pattern of allPatterns) {
+        for (const pattern of includePatterns) {
+            if (path.isAbsolute(pattern) || pattern.includes("..")) {
+                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
+            }
+            if (pattern.endsWith("*")) {
+                endsWithWildcard = true;
+            }
+        }
+        for (const pattern of excludePatterns) {
             if (path.isAbsolute(pattern) || pattern.includes("..")) {
                 throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
             }
@@ -112,7 +120,11 @@ class OverrideTester {
         const includes = toMatcher(includePatterns);
         const excludes = toMatcher(excludePatterns);
 
-        return new OverrideTester([{ includes, excludes }], basePath);
+        return new OverrideTester(
+            [{ includes, excludes }],
+            basePath,
+            endsWithWildcard
+        );
     }
 
     /**
@@ -125,28 +137,44 @@ class OverrideTester {
      */
     static and(a, b) {
         if (!b) {
-            return a && new OverrideTester(a.patterns, a.basePath);
+            return a && new OverrideTester(
+                a.patterns,
+                a.basePath,
+                a.endsWithWildcard
+            );
         }
         if (!a) {
-            return new OverrideTester(b.patterns, b.basePath);
+            return new OverrideTester(
+                b.patterns,
+                b.basePath,
+                b.endsWithWildcard
+            );
         }
 
         assert.strictEqual(a.basePath, b.basePath);
-        return new OverrideTester(a.patterns.concat(b.patterns), a.basePath);
+        return new OverrideTester(
+            a.patterns.concat(b.patterns),
+            a.basePath,
+            a.endsWithWildcard || b.endsWithWildcard
+        );
     }
 
     /**
      * Initialize this instance.
      * @param {Pattern[]} patterns The matchers.
      * @param {string} basePath The base path.
+     * @param {boolean} endsWithWildcard If `true` then a pattern ends with `*`.
      */
-    constructor(patterns, basePath) {
+    constructor(patterns, basePath, endsWithWildcard = false) {
 
         /** @type {Pattern[]} */
         this.patterns = patterns;
 
         /** @type {string} */
         this.basePath = basePath;
+
+        /** @type {boolean} */
+        this.endsWithWildcard = endsWithWildcard;
     }
 
     /**
diff --git a/tests/lib/cli-engine/cli-engine.js b/tests/lib/cli-engine/cli-engine.js
index 910200be3..03a0a79f6 100644
--- a/tests/lib/cli-engine/cli-engine.js
+++ b/tests/lib/cli-engine/cli-engine.js
@@ -3329,6 +3329,39 @@ describe("CLIEngine", () => {
                     engine.executeOnFiles(["test.md"]);
                 }, /ESLint configuration of processor in '\.eslintrc\.json' is invalid: 'markdown\/unknown' was not found\./u);
             });
+
+            it("should lint HTML blocks as well with multiple processors if 'overrides[].files' is present.", () => {
+                CLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        ...commonFiles,
+                        ".eslintrc.json": JSON.stringify({
+                            plugins: ["markdown", "html"],
+                            rules: { semi: "error" },
+                            overrides: [
+                                {
+                                    files: "*.html",
+                                    processor: "html/.html"
+                                },
+                                {
+                                    files: "*.md",
+                                    processor: "markdown/.md"
+                                }
+                            ]
+                        })
+                    }
+                }).CLIEngine;
+                engine = new CLIEngine({ cwd: root });
+
+                const { results } = engine.executeOnFiles(["test.md"]);
+
+                assert.strictEqual(results.length, 1);
+                assert.strictEqual(results[0].messages.length, 2);
+                assert.strictEqual(results[0].messages[0].ruleId, "semi"); // JS block
+                assert.strictEqual(results[0].messages[0].line, 2);
+                assert.strictEqual(results[0].messages[1].ruleId, "semi"); // JS block in HTML block
+                assert.strictEqual(results[0].messages[1].line, 7);
+            });
         });
 
         describe("MODULE_NOT_FOUND error handling", () => {
@@ -5451,4 +5484,232 @@ describe("CLIEngine", () => {
         });
 
     });
+
+    describe("'overrides[].files' adds lint targets", () => {
+        const root = getFixturePath("cli-engine/additional-lint-targets");
+        let InMemoryCLIEngine;
+
+        describe("if { files: 'foo/*.txt', excludedFiles: '**/ignore.txt' } is present,", () => {
+            beforeEach(() => {
+                InMemoryCLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        ".eslintrc.json": JSON.stringify({
+                            overrides: [
+                                {
+                                    files: "foo/*.txt",
+                                    excludedFiles: "**/ignore.txt"
+                                }
+                            ]
+                        }),
+                        "foo/nested/test.txt": "",
+                        "foo/test.js": "",
+                        "foo/test.txt": "",
+                        "foo/ignore.txt": "",
+                        "bar/test.js": "",
+                        "bar/test.txt": "",
+                        "bar/ignore.txt": "",
+                        "test.js": "",
+                        "test.txt": "",
+                        "ignore.txt": ""
+                    }
+                }).CLIEngine;
+            });
+
+            it("'executeOnFiles()' with a directory path should contain 'foo/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles(".")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "foo/test.txt"),
+                    path.join(root, "test.js")
+                ]);
+            });
+
+            it("'executeOnFiles()' with a glob pattern '*.js' should not contain 'foo/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles("**/*.js")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "test.js")
+                ]);
+            });
+        });
+
+        describe("if { files: 'foo/**/*.txt' } is present,", () => {
+            beforeEach(() => {
+                InMemoryCLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        ".eslintrc.json": JSON.stringify({
+                            overrides: [
+                                {
+                                    files: "foo/**/*.txt"
+                                }
+                            ]
+                        }),
+                        "foo/nested/test.txt": "",
+                        "foo/test.js": "",
+                        "foo/test.txt": "",
+                        "bar/test.js": "",
+                        "bar/test.txt": "",
+                        "test.js": "",
+                        "test.txt": ""
+                    }
+                }).CLIEngine;
+            });
+
+            it("'executeOnFiles()' with a directory path should contain 'foo/test.txt' and 'foo/nested/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles(".")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/nested/test.txt"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "foo/test.txt"),
+                    path.join(root, "test.js")
+                ]);
+            });
+        });
+
+        describe("if { files: 'foo/**/*' } is present,", () => {
+            beforeEach(() => {
+                InMemoryCLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        ".eslintrc.json": JSON.stringify({
+                            overrides: [
+                                {
+                                    files: "foo/**/*"
+                                }
+                            ]
+                        }),
+                        "foo/nested/test.txt": "",
+                        "foo/test.js": "",
+                        "foo/test.txt": "",
+                        "bar/test.js": "",
+                        "bar/test.txt": "",
+                        "test.js": "",
+                        "test.txt": ""
+                    }
+                }).CLIEngine;
+            });
+
+            it("'executeOnFiles()' with a directory path should NOT contain 'foo/test.txt' and 'foo/nested/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles(".")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "test.js")
+                ]);
+            });
+        });
+
+        describe("if { files: 'foo/**/*.txt' } is present in a shareable config,", () => {
+            beforeEach(() => {
+                InMemoryCLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        "node_modules/eslint-config-foo/index.js": `module.exports = ${JSON.stringify({
+                            overrides: [
+                                {
+                                    files: "foo/**/*.txt"
+                                }
+                            ]
+                        })}`,
+                        ".eslintrc.json": JSON.stringify({
+                            extends: "foo"
+                        }),
+                        "foo/nested/test.txt": "",
+                        "foo/test.js": "",
+                        "foo/test.txt": "",
+                        "bar/test.js": "",
+                        "bar/test.txt": "",
+                        "test.js": "",
+                        "test.txt": ""
+                    }
+                }).CLIEngine;
+            });
+
+            it("'executeOnFiles()' with a directory path should contain 'foo/test.txt' and 'foo/nested/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles(".")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/nested/test.txt"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "foo/test.txt"),
+                    path.join(root, "test.js")
+                ]);
+            });
+        });
+
+        describe("if { files: 'foo/**/*.txt' } is present in a plugin config,", () => {
+            beforeEach(() => {
+                InMemoryCLIEngine = defineCLIEngineWithInMemoryFileSystem({
+                    cwd: () => root,
+                    files: {
+                        "node_modules/eslint-plugin-foo/index.js": `exports.configs = ${JSON.stringify({
+                            bar: {
+                                overrides: [
+                                    {
+                                        files: "foo/**/*.txt"
+                                    }
+                                ]
+                            }
+                        })}`,
+                        ".eslintrc.json": JSON.stringify({
+                            extends: "plugin:foo/bar"
+                        }),
+                        "foo/nested/test.txt": "",
+                        "foo/test.js": "",
+                        "foo/test.txt": "",
+                        "bar/test.js": "",
+                        "bar/test.txt": "",
+                        "test.js": "",
+                        "test.txt": ""
+                    }
+                }).CLIEngine;
+            });
+
+            it("'executeOnFiles()' with a directory path should contain 'foo/test.txt' and 'foo/nested/test.txt'.", () => {
+                const engine = new InMemoryCLIEngine();
+                const filePaths = engine.executeOnFiles(".")
+                    .results
+                    .map(r => r.filePath)
+                    .sort();
+
+                assert.deepStrictEqual(filePaths, [
+                    path.join(root, "bar/test.js"),
+                    path.join(root, "foo/nested/test.txt"),
+                    path.join(root, "foo/test.js"),
+                    path.join(root, "foo/test.txt"),
+                    path.join(root, "test.js")
+                ]);
+            });
+        });
+    });
 });
diff --git a/tests/lib/cli-engine/config-array-factory.js b/tests/lib/cli-engine/config-array-factory.js
index 1fb5661fb..15823ca67 100644
--- a/tests/lib/cli-engine/config-array-factory.js
+++ b/tests/lib/cli-engine/config-array-factory.js
@@ -40,6 +40,7 @@ function assertConfigArrayElement(actual, providedExpected) {
         root: void 0,
         rules: void 0,
         settings: void 0,
+        type: "config",
         ...providedExpected
     };
 
diff --git a/tests/lib/linter/linter.js b/tests/lib/linter/linter.js
index e444aea92..71bfd262a 100644
--- a/tests/lib/linter/linter.js
+++ b/tests/lib/linter/linter.js
@@ -3759,6 +3759,314 @@ describe("Linter", () => {
             linter.verify("x", { rules: { "foo-bar-baz": "error" } });
             assert(spy.calledOnce);
         });
+
+        describe("descriptions in directive comments", () => {
+            it("should ignore the part preceded by '--' in '/*eslint*/'.", () => {
+                const aaa = sinon.stub().returns({});
+                const bbb = sinon.stub().returns({});
+
+                linter.defineRule("aaa", { create: aaa });
+                linter.defineRule("bbb", { create: bbb });
+                const messages = linter.verify(`
+                    /*eslint aaa:error -- bbb:error */
+                    console.log("hello")
+                `, {});
+
+                // Don't include syntax error of the comment.
+                assert.deepStrictEqual(messages, []);
+
+                // Use only `aaa`.
+                assert.strictEqual(aaa.callCount, 1);
+                assert.strictEqual(bbb.callCount, 0);
+            });
+
+            it("should ignore the part preceded by '--' in '/*eslint-env*/'.", () => {
+                const messages = linter.verify(`
+                    /*eslint-env es2015 -- es2017 */
+                    var Promise = {}
+                    var Atomics = {}
+                `, { rules: { "no-redeclare": "error" } });
+
+                // Don't include `Atomics`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endColumn: 32,
+                        endLine: 3,
+                        line: 3,
+                        message: "'Promise' is already defined as a built-in global variable.",
+                        messageId: "redeclaredAsBuiltin",
+                        nodeType: "Identifier",
+                        ruleId: "no-redeclare",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*global*/'.", () => {
+                const messages = linter.verify(`
+                    /*global aaa -- bbb */
+                    var aaa = {}
+                    var bbb = {}
+                `, { rules: { "no-redeclare": "error" } });
+
+                // Don't include `bbb`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 30,
+                        line: 2,
+                        message: "'aaa' is already defined by a variable declaration.",
+                        messageId: "redeclaredBySyntax",
+                        nodeType: "Block",
+                        ruleId: "no-redeclare",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*globals*/'.", () => {
+                const messages = linter.verify(`
+                    /*globals aaa -- bbb */
+                    var aaa = {}
+                    var bbb = {}
+                `, { rules: { "no-redeclare": "error" } });
+
+                // Don't include `bbb`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 31,
+                        line: 2,
+                        message: "'aaa' is already defined by a variable declaration.",
+                        messageId: "redeclaredBySyntax",
+                        nodeType: "Block",
+                        ruleId: "no-redeclare",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*exported*/'.", () => {
+                const messages = linter.verify(`
+                    /*exported aaa -- bbb */
+                    var aaa = {}
+                    var bbb = {}
+                `, { rules: { "no-unused-vars": "error" } });
+
+                // Don't include `aaa`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endColumn: 28,
+                        endLine: 4,
+                        line: 4,
+                        message: "'bbb' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*eslint-disable*/'.", () => {
+                const messages = linter.verify(`
+                    /*eslint-disable no-redeclare -- no-unused-vars */
+                    var aaa = {}
+                    var aaa = {}
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-unused-vars` but not `no-redeclare`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 3,
+                        endColumn: 28,
+                        line: 3,
+                        message: "'aaa' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*eslint-enable*/'.", () => {
+                const messages = linter.verify(`
+                    /*eslint-disable no-redeclare, no-unused-vars */
+                    /*eslint-enable no-redeclare -- no-unused-vars */
+                    var aaa = {}
+                    var aaa = {}
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-redeclare` but not `no-unused-vars`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 5,
+                        endColumn: 28,
+                        line: 5,
+                        message: "'aaa' is already defined.",
+                        messageId: "redeclared",
+                        nodeType: "Identifier",
+                        ruleId: "no-redeclare",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '//eslint-disable-line'.", () => {
+                const messages = linter.verify(`
+                    var aaa = {} //eslint-disable-line no-redeclare -- no-unused-vars
+                    var aaa = {} //eslint-disable-line no-redeclare -- no-unused-vars
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-unused-vars` but not `no-redeclare`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 2,
+                        endColumn: 28,
+                        line: 2,
+                        message: "'aaa' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*eslint-disable-line*/'.", () => {
+                const messages = linter.verify(`
+                    var aaa = {} /*eslint-disable-line no-redeclare -- no-unused-vars */
+                    var aaa = {} /*eslint-disable-line no-redeclare -- no-unused-vars */
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-unused-vars` but not `no-redeclare`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 2,
+                        endColumn: 28,
+                        line: 2,
+                        message: "'aaa' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '//eslint-disable-next-line'.", () => {
+                const messages = linter.verify(`
+                    //eslint-disable-next-line no-redeclare -- no-unused-vars
+                    var aaa = {}
+                    //eslint-disable-next-line no-redeclare -- no-unused-vars
+                    var aaa = {}
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-unused-vars` but not `no-redeclare`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 3,
+                        endColumn: 28,
+                        line: 3,
+                        message: "'aaa' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should ignore the part preceded by '--' in '/*eslint-disable-next-line*/'.", () => {
+                const messages = linter.verify(`
+                    /*eslint-disable-next-line no-redeclare -- no-unused-vars */
+                    var aaa = {}
+                    /*eslint-disable-next-line no-redeclare -- no-unused-vars */
+                    var aaa = {}
+                `, { rules: { "no-redeclare": "error", "no-unused-vars": "error" } });
+
+                // Do include `no-unused-vars` but not `no-redeclare`
+                assert.deepStrictEqual(
+                    messages,
+                    [{
+                        column: 25,
+                        endLine: 3,
+                        endColumn: 28,
+                        line: 3,
+                        message: "'aaa' is assigned a value but never used.",
+                        nodeType: "Identifier",
+                        ruleId: "no-unused-vars",
+                        severity: 2
+                    }]
+                );
+            });
+
+            it("should not ignore the part preceded by '--' if the '--' is not surrounded by whitespaces.", () => {
+                const rule = sinon.stub().returns({});
+
+                linter.defineRule("a--rule", { create: rule });
+                const messages = linter.verify(`
+                    /*eslint a--rule:error */
+                    console.log("hello")
+                `, {});
+
+                // Don't include syntax error of the comment.
+                assert.deepStrictEqual(messages, []);
+
+                // Use `a--rule`.
+                assert.strictEqual(rule.callCount, 1);
+            });
+
+            it("should ignore the part preceded by '--' even if the '--' is longer than 2.", () => {
+                const aaa = sinon.stub().returns({});
+                const bbb = sinon.stub().returns({});
+
+                linter.defineRule("aaa", { create: aaa });
+                linter.defineRule("bbb", { create: bbb });
+                const messages = linter.verify(`
+                    /*eslint aaa:error -------- bbb:error */
+                    console.log("hello")
+                `, {});
+
+                // Don't include syntax error of the comment.
+                assert.deepStrictEqual(messages, []);
+
+                // Use only `aaa`.
+                assert.strictEqual(aaa.callCount, 1);
+                assert.strictEqual(bbb.callCount, 0);
+            });
+
+            it("should ignore the part preceded by '--' with line breaks.", () => {
+                const aaa = sinon.stub().returns({});
+                const bbb = sinon.stub().returns({});
+
+                linter.defineRule("aaa", { create: aaa });
+                linter.defineRule("bbb", { create: bbb });
+                const messages = linter.verify(`
+                    /*eslint aaa:error
+                        --------
+                        bbb:error */
+                    console.log("hello")
+                `, {});
+
+                // Don't include syntax error of the comment.
+                assert.deepStrictEqual(messages, []);
+
+                // Use only `aaa`.
+                assert.strictEqual(aaa.callCount, 1);
+                assert.strictEqual(bbb.callCount, 0);
+            });
+        });
     });
 
     describe("context.getScope()", () => {
diff --git a/tests/lib/rules/array-callback-return.js b/tests/lib/rules/array-callback-return.js
index de39efcf6..2816d7962 100644
--- a/tests/lib/rules/array-callback-return.js
+++ b/tests/lib/rules/array-callback-return.js
@@ -36,6 +36,7 @@ ruleTester.run("array-callback-return", rule, {
         "foo.filter(function() { return true; })",
         "foo.find(function() { return true; })",
         "foo.findIndex(function() { return true; })",
+        "foo.flatMap(function() { return true; })",
         "foo.map(function() { return true; })",
         "foo.reduce(function() { return true; })",
         "foo.reduceRight(function() { return true; })",
@@ -47,6 +48,7 @@ ruleTester.run("array-callback-return", rule, {
         { code: "foo.filter(function() { return; })", options: allowImplicitOptions },
         { code: "foo.find(function() { return; })", options: allowImplicitOptions },
         { code: "foo.findIndex(function() { return; })", options: allowImplicitOptions },
+        { code: "foo.flatMap(function() { return; })", options: allowImplicitOptions },
         { code: "foo.map(function() { return; })", options: allowImplicitOptions },
         { code: "foo.reduce(function() { return; })", options: allowImplicitOptions },
         { code: "foo.reduceRight(function() { return; })", options: allowImplicitOptions },
@@ -94,6 +96,8 @@ ruleTester.run("array-callback-return", rule, {
         { code: "foo.find(function foo() {})", errors: [{ messageId: "expectedInside", data: { name: "function 'foo'" } }] },
         { code: "foo.findIndex(function() {})", errors: [{ messageId: "expectedInside", data: { name: "function" } }] },
         { code: "foo.findIndex(function foo() {})", errors: [{ messageId: "expectedInside", data: { name: "function 'foo'" } }] },
+        { code: "foo.flatMap(function() {})", errors: [{ messageId: "expectedInside", data: { name: "function" } }] },
+        { code: "foo.flatMap(function foo() {})", errors: [{ messageId: "expectedInside", data: { name: "function 'foo'" } }] },
         { code: "foo.map(function() {})", errors: [{ messageId: "expectedInside", data: { name: "function" } }] },
         { code: "foo.map(function foo() {})", errors: [{ messageId: "expectedInside", data: { name: "function 'foo'" } }] },
         { code: "foo.reduce(function() {})", errors: [{ messageId: "expectedInside", data: { name: "function" } }] },
diff --git a/tests/lib/rules/array-element-newline.js b/tests/lib/rules/array-element-newline.js
index 691e6afb6..b17af8376 100644
--- a/tests/lib/rules/array-element-newline.js
+++ b/tests/lib/rules/array-element-newline.js
@@ -135,9 +135,13 @@ ruleTester.run("array-element-newline", rule, {
         { code: "var [] = foo;", options: [{ minItems: 3 }], parserOptions: { ecmaVersion: 6 } },
         { code: "var [a] = foo;", options: [{ minItems: 3 }], parserOptions: { ecmaVersion: 6 } },
         { code: "var [a, b] = foo;", options: [{ minItems: 3 }], parserOptions: { ecmaVersion: 6 } },
-        { code: "var [a,\nb,\nc] = foo;", options: [{ minItems: 3 }], parserOptions: { ecmaVersion: 6 } }
+        { code: "var [a,\nb,\nc] = foo;", options: [{ minItems: 3 }], parserOptions: { ecmaVersion: 6 } },
 
-    ],
+        /*
+         * ArrayExpression & ArrayPattern
+         * { ArrayExpression: "always", ArrayPattern: "never" }
+         */
+        { code: "var [a, b] = [1,\n2]", options: [{ ArrayExpression: "always", ArrayPattern: "never" }], parserOptions: { ecmaVersion: 6 } }],
 
     invalid: [
 
@@ -826,6 +830,55 @@ ruleTester.run("array-element-newline", rule, {
                     column: 11
                 }
             ]
+        },
+
+        /*
+         * ArrayExpression & ArrayPattern
+         * { ArrayExpression: "always", ArrayPattern: "never" }
+         */
+        {
+            code: "var [a,\nb] = [1, 2]",
+            output: "var [a, b] = [1,\n2]",
+            options: [{ ArrayExpression: "always", ArrayPattern: "never" }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [
+                {
+                    messageId: "unexpectedLineBreak",
+                    line: 1,
+                    column: 8
+                },
+                {
+                    messageId: "missingLineBreak",
+                    line: 2,
+                    column: 9
+                }
+            ]
+        },
+        {
+            code: "var [a, b] = [1, 2]",
+            output: "var [a, b] = [1,\n2]",
+            options: [{ ArrayExpression: "always", ArrayPattern: "never" }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [
+                {
+                    messageId: "missingLineBreak",
+                    line: 1,
+                    column: 17
+                }
+            ]
+        },
+        {
+            code: "var [a,\nb] = [1,\n2]",
+            output: "var [a, b] = [1,\n2]",
+            options: [{ ArrayExpression: "always", ArrayPattern: "never" }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [
+                {
+                    messageId: "unexpectedLineBreak",
+                    line: 1,
+                    column: 8
+                }
+            ]
         }
     ]
 
diff --git a/tests/lib/rules/computed-property-spacing.js b/tests/lib/rules/computed-property-spacing.js
index 3a0bd9e0e..3f656ff55 100644
--- a/tests/lib/rules/computed-property-spacing.js
+++ b/tests/lib/rules/computed-property-spacing.js
@@ -184,6 +184,8 @@ ruleTester.run("computed-property-spacing", rule, {
             options: ["always", { enforceForClassMembers: true }],
             parserOptions: { ecmaVersion: 6 }
         },
+
+        // handling of parens and comments
         {
             code: [
                 "const foo = {",
@@ -277,8 +279,11 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
+                    line: 1,
                     column: 17,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 18
+
                 }
             ]
         },
@@ -291,8 +296,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
+                    line: 1,
                     column: 14,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 15
                 }
             ]
         },
@@ -305,8 +312,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
-                    column: 14,
-                    line: 1
+                    line: 1,
+                    column: 15,
+                    endLine: 1,
+                    endColumn: 16
                 }
             ]
         },
@@ -318,7 +327,11 @@ ruleTester.run("computed-property-spacing", rule, {
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
-                    type: "MemberExpression"
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 16,
+                    endLine: 1,
+                    endColumn: 17
                 }
             ]
         },
@@ -331,15 +344,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
-                    column: 4,
-                    line: 1
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 6
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
-                    column: 10,
-                    line: 1
+                    line: 1,
+                    column: 9,
+                    endLine: 1,
+                    endColumn: 10
                 }
             ]
         },
@@ -352,8 +369,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
-                    column: 9,
-                    line: 1
+                    line: 1,
+                    column: 8,
+                    endLine: 1,
+                    endColumn: 9
                 }
             ]
         },
@@ -366,8 +385,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
-                    column: 4,
-                    line: 1
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 6
                 }
             ]
         },
@@ -380,15 +401,128 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
+                    line: 1,
                     column: 14,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 15
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
+                    line: 1,
                     column: 16,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 17
+                }
+            ]
+        },
+
+        // multiple spaces
+        {
+            code: "obj[    foo]",
+            output: "obj[foo]",
+            options: ["never"],
+            errors: [
+                {
+                    messageId: "unexpectedSpaceAfter",
+                    data: { tokenValue: "[" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 9
+                }
+            ]
+        },
+        {
+            code: "obj[  foo  ]",
+            output: "obj[foo]",
+            options: ["never"],
+            errors: [
+                {
+                    messageId: "unexpectedSpaceAfter",
+                    data: { tokenValue: "[" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 7
+                },
+                {
+                    messageId: "unexpectedSpaceBefore",
+                    data: { tokenValue: "]" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 10,
+                    endLine: 1,
+                    endColumn: 12
+                }
+            ]
+        },
+        {
+            code: "obj[   foo ]",
+            output: "obj[foo]",
+            options: ["never"],
+            errors: [
+                {
+                    messageId: "unexpectedSpaceAfter",
+                    data: { tokenValue: "[" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 8
+                },
+                {
+                    messageId: "unexpectedSpaceBefore",
+                    data: { tokenValue: "]" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 11,
+                    endLine: 1,
+                    endColumn: 12
+                }
+            ]
+        },
+        {
+            code: "obj[ foo + \n  bar   ]",
+            output: "obj[foo + \n  bar]",
+            options: ["never"],
+            errors: [
+                {
+                    messageId: "unexpectedSpaceAfter",
+                    data: { tokenValue: "[" },
+                    type: "MemberExpression",
+                    line: 1,
+                    column: 5,
+                    endLine: 1,
+                    endColumn: 6
+                },
+                {
+                    messageId: "unexpectedSpaceBefore",
+                    data: { tokenValue: "]" },
+                    type: "MemberExpression",
+                    line: 2,
+                    column: 6,
+                    endLine: 2,
+                    endColumn: 9
+                }
+            ]
+        },
+        {
+            code: "obj[\n foo  ]",
+            output: "obj[\n foo]",
+            options: ["never"],
+            errors: [
+                {
+                    messageId: "unexpectedSpaceBefore",
+                    data: { tokenValue: "]" },
+                    type: "MemberExpression",
+                    line: 2,
+                    column: 5,
+                    endLine: 2,
+                    endColumn: 7
                 }
             ]
         },
@@ -404,15 +538,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 1,
                     column: 10,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 11
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 1,
                     column: 12,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 13
                 }
             ]
         },
@@ -426,8 +564,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 1,
                     column: 10,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 11
                 }
             ]
         },
@@ -441,8 +581,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 1,
                     column: 13,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 14
                 }
             ]
         },
@@ -458,15 +600,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 10,
-                    line: 1
+                    line: 1,
+                    column: 11,
+                    endLine: 1,
+                    endColumn: 12
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
-                    column: 14,
-                    line: 1
+                    line: 1,
+                    column: 13,
+                    endLine: 1,
+                    endColumn: 14
                 }
             ]
         },
@@ -480,8 +626,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
-                    column: 13,
-                    line: 1
+                    line: 1,
+                    column: 12,
+                    endLine: 1,
+                    endColumn: 13
                 }
             ]
         },
@@ -495,8 +643,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 10,
-                    line: 1
+                    line: 1,
+                    column: 11,
+                    endLine: 1,
+                    endColumn: 12
                 }
             ]
         },
@@ -510,17 +660,15 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 10,
-                    line: 1
+                    line: 1,
+                    column: 11,
+                    endLine: 1,
+                    endColumn: 12
                 }
             ]
         },
 
-        //------------------------------------------------------------------------------
-        // Classes
-        //------------------------------------------------------------------------------
-
-        // never
+        // never - classes
         {
             code: "class A { [ a](){} }",
             output: "class A { [a](){} }",
@@ -531,8 +679,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 11,
-                    line: 1
+                    line: 1,
+                    column: 12,
+                    endLine: 1,
+                    endColumn: 13
                 }
             ]
         },
@@ -546,8 +696,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 37,
-                    line: 1
+                    line: 1,
+                    column: 36,
+                    endLine: 1,
+                    endColumn: 37
                 }
             ]
         },
@@ -561,29 +713,37 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 18,
-                    line: 1
+                    line: 1,
+                    column: 17,
+                    endLine: 1,
+                    endColumn: 18
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 28,
-                    line: 1
+                    line: 1,
+                    column: 29,
+                    endLine: 1,
+                    endColumn: 30
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 81,
-                    line: 1
+                    line: 1,
+                    column: 82,
+                    endLine: 1,
+                    endColumn: 83
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 104,
-                    line: 1
+                    line: 1,
+                    column: 103,
+                    endLine: 1,
+                    endColumn: 104
                 }
             ]
         },
@@ -597,90 +757,114 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 13,
-                    line: 1
+                    line: 1,
+                    column: 14,
+                    endLine: 1,
+                    endColumn: 15
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 17,
-                    line: 1
+                    line: 1,
+                    column: 16,
+                    endLine: 1,
+                    endColumn: 17
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 27,
-                    line: 1
+                    line: 1,
+                    column: 28,
+                    endLine: 1,
+                    endColumn: 29
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 31,
-                    line: 1
+                    line: 1,
+                    column: 30,
+                    endLine: 1,
+                    endColumn: 31
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 41,
-                    line: 1
+                    line: 1,
+                    column: 42,
+                    endLine: 1,
+                    endColumn: 43
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 45,
-                    line: 1
+                    line: 1,
+                    column: 44,
+                    endLine: 1,
+                    endColumn: 45
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 61,
-                    line: 1
+                    line: 1,
+                    column: 62,
+                    endLine: 1,
+                    endColumn: 63
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 65,
-                    line: 1
+                    line: 1,
+                    column: 64,
+                    endLine: 1,
+                    endColumn: 65
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 82,
-                    line: 1
+                    line: 1,
+                    column: 83,
+                    endLine: 1,
+                    endColumn: 84
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 86,
-                    line: 1
+                    line: 1,
+                    column: 85,
+                    endLine: 1,
+                    endColumn: 86
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
-                    column: 103,
-                    line: 1
+                    line: 1,
+                    column: 104,
+                    endLine: 1,
+                    endColumn: 105
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
-                    column: 107,
-                    line: 1
+                    line: 1,
+                    column: 106,
+                    endLine: 1,
+                    endColumn: 107
                 }
             ]
         },
 
-        // always
+        // always - classes
         {
             code: "class A { [ a](){} }",
             output: "class A { [ a ](){} }",
@@ -691,8 +875,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 14,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 15
                 }
             ]
         },
@@ -706,8 +892,10 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 36,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 37
                 }
             ]
         },
@@ -721,29 +909,37 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 15,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 16
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 31,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 32
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 84,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 85
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 101,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 102
                 }
             ]
         },
@@ -757,88 +953,114 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 13,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 14
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 15,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 16
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 25,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 26
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 27,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 28
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 37,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 38
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 39,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 40
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 55,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 56
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 57,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 58
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 74,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 75
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 76,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 77
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 93,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 94
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MethodDefinition",
+                    line: 1,
                     column: 95,
-                    line: 1
+                    endLine: 1,
+                    endColumn: 96
                 }
             ]
         },
+
+        // handling of parens and comments
         {
             code: [
                 "const foo = {",
@@ -857,15 +1079,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 2,
                     column: 3,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 4
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 2,
                     column: 7,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 8
                 }
             ]
         },
@@ -887,15 +1113,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 2,
                     column: 3,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 4
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 2,
                     column: 9,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 10
                 }
             ]
         },
@@ -917,15 +1147,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 3,
-                    line: 2
+                    line: 2,
+                    column: 4,
+                    endLine: 2,
+                    endColumn: 5
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
-                    column: 11,
-                    line: 2
+                    line: 2,
+                    column: 10,
+                    endLine: 2,
+                    endColumn: 11
                 }
             ]
         },
@@ -947,15 +1181,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 2,
                     column: 3,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 4
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 2,
                     column: 15,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 16
                 }
             ]
         },
@@ -977,15 +1215,19 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 3,
-                    line: 2
+                    line: 2,
+                    column: 4,
+                    endLine: 2,
+                    endColumn: 5
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
-                    column: 17,
-                    line: 2
+                    line: 2,
+                    column: 16,
+                    endLine: 2,
+                    endColumn: 17
                 }
             ]
         },
@@ -1007,29 +1249,37 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 2,
                     column: 3,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 4
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
+                    line: 2,
                     column: 5,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 6
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
+                    line: 2,
                     column: 7,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 8
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 2,
                     column: 8,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 9
                 }
             ]
         },
@@ -1051,29 +1301,37 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 3,
-                    line: 2
+                    line: 2,
+                    column: 4,
+                    endLine: 2,
+                    endColumn: 5
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
-                    column: 6,
-                    line: 2
+                    line: 2,
+                    column: 7,
+                    endLine: 2,
+                    endColumn: 8
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
-                    column: 10,
-                    line: 2
+                    line: 2,
+                    column: 9,
+                    endLine: 2,
+                    endColumn: 10
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
-                    column: 12,
-                    line: 2
+                    line: 2,
+                    column: 11,
+                    endLine: 2,
+                    endColumn: 12
                 }
             ]
         },
@@ -1095,22 +1353,28 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
+                    line: 2,
                     column: 3,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 4
                 },
                 {
                     messageId: "missingSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
+                    line: 2,
                     column: 5,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 6
                 },
                 {
                     messageId: "missingSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "Property",
+                    line: 2,
                     column: 18,
-                    line: 2
+                    endLine: 2,
+                    endColumn: 19
                 }
             ]
         },
@@ -1132,22 +1396,28 @@ ruleTester.run("computed-property-spacing", rule, {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "Property",
-                    column: 3,
-                    line: 2
+                    line: 2,
+                    column: 4,
+                    endLine: 2,
+                    endColumn: 5
                 },
                 {
                     messageId: "unexpectedSpaceAfter",
                     data: { tokenValue: "[" },
                     type: "MemberExpression",
-                    column: 10,
-                    line: 2
+                    line: 2,
+                    column: 11,
+                    endLine: 2,
+                    endColumn: 12
                 },
                 {
                     messageId: "unexpectedSpaceBefore",
                     data: { tokenValue: "]" },
                     type: "MemberExpression",
-                    column: 19,
-                    line: 2
+                    line: 2,
+                    column: 18,
+                    endLine: 2,
+                    endColumn: 19
                 }
             ]
         }
diff --git a/tests/lib/rules/default-case-last.js b/tests/lib/rules/default-case-last.js
new file mode 100644
index 000000000..9f75329ab
--- /dev/null
+++ b/tests/lib/rules/default-case-last.js
@@ -0,0 +1,128 @@
+/**
+ * @fileoverview Tests for the default-case-last rule
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../../lib/rules/default-case-last");
+const { RuleTester } = require("../../../lib/rule-tester");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Creates an error object.
+ * @param {number} [column] Reported column.
+ * @returns {Object} The error object.
+ */
+function error(column) {
+    const errorObject = {
+        messageId: "notLast",
+        type: "SwitchCase"
+    };
+
+    if (column) {
+        errorObject.column = column;
+    }
+
+    return errorObject;
+}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("default-case-last", rule, {
+    valid: [
+        "switch (foo) {}",
+        "switch (foo) { case 1: bar(); break; }",
+        "switch (foo) { case 1: break; }",
+        "switch (foo) { case 1: }",
+        "switch (foo) { case 1: bar(); break; case 2: baz(); break; }",
+        "switch (foo) { case 1: break; case 2: break; }",
+        "switch (foo) { case 1: case 2: break; }",
+        "switch (foo) { case 1: case 2: }",
+        "switch (foo) { default: bar(); break; }",
+        "switch (foo) { default: bar(); }",
+        "switch (foo) { default: break; }",
+        "switch (foo) { default: }",
+        "switch (foo) { case 1: break; default: break; }",
+        "switch (foo) { case 1: break; default: }",
+        "switch (foo) { case 1: default: break; }",
+        "switch (foo) { case 1: default: }",
+        "switch (foo) { case 1: baz(); break; case 2: quux(); break; default: quuux(); break; }",
+        "switch (foo) { case 1: break; case 2: break; default: break; }",
+        "switch (foo) { case 1: break; case 2: break; default: }",
+        "switch (foo) { case 1: case 2: break; default: break; }",
+        "switch (foo) { case 1: break; case 2: default: break; }",
+        "switch (foo) { case 1: break; case 2: default: }",
+        "switch (foo) { case 1: case 2: default: }"
+    ],
+
+    invalid: [
+        {
+            code: "switch (foo) { default: bar(); break; case 1: baz(); break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: break; case 1: break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: break; case 1: }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: case 1: break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: case 1: }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: break; case 1: break; case 2: break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: case 1: break; case 2: break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: case 1: case 2: break; }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { default: case 1: case 2: }",
+            errors: [error(16)]
+        },
+        {
+            code: "switch (foo) { case 1: break; default: break; case 2: break; }",
+            errors: [error(31)]
+        },
+        {
+            code: "switch (foo) { case 1: default: break; case 2: break; }",
+            errors: [error(24)]
+        },
+        {
+            code: "switch (foo) { case 1: break; default: case 2: break; }",
+            errors: [error(31)]
+        },
+        {
+            code: "switch (foo) { case 1: default: case 2: break; }",
+            errors: [error(24)]
+        },
+        {
+            code: "switch (foo) { case 1: default: case 2: }",
+            errors: [error(24)]
+        }
+    ]
+});
diff --git a/tests/lib/rules/id-blacklist.js b/tests/lib/rules/id-blacklist.js
index f4380e2b8..5e92a4d5b 100644
--- a/tests/lib/rules/id-blacklist.js
+++ b/tests/lib/rules/id-blacklist.js
@@ -65,6 +65,26 @@ ruleTester.run("id-blacklist", rule, {
             code: "var obj = { key: foo.bar };",
             options: ["f", "fo", "fooo", "b", "ba", "barr", "bazz", "bingg"]
         },
+        {
+            code: "const {foo: bar} = baz",
+            options: ["foo", "bar"],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "const {foo: {bar: baz}} = qux",
+            options: ["foo", "bar", "baz"],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "function foo({ bar: baz }) {}",
+            options: ["bar", "baz"],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "function foo({ bar: {baz: qux} }) {}",
+            options: ["bar", "baz", "qux"],
+            parserOptions: { ecmaVersion: 6 }
+        },
         {
             code: "var arr = [foo.bar];",
             options: ["f", "fo", "fooo", "b", "ba", "barr", "bazz", "bingg"]
diff --git a/tests/lib/rules/indent.js b/tests/lib/rules/indent.js
index 99e7dfa02..7496da218 100644
--- a/tests/lib/rules/indent.js
+++ b/tests/lib/rules/indent.js
@@ -5506,6 +5506,224 @@ ruleTester.run("indent", rule, {
                 )
             `,
             parserOptions: { ecmaVersion: 2020 }
+        },
+
+        // https://github.com/eslint/eslint/issues/12122
+        {
+            code: unIndent`
+                foo(() => {
+                    tag\`
+                    multiline
+                    template
+                    literal
+                    \`(() => {
+                        bar();
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                {
+                    tag\`
+                    multiline
+                    template
+                    \${a} \${b}
+                    literal
+                    \`(() => {
+                        bar();
+                    });
+                }
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo(() => {
+                    tagOne\`
+                    multiline
+                    template
+                    literal
+                    \${a} \${b}
+                    \`(() => {
+                        tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                        baz();
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                {
+                    tagOne\`
+                    \${a} \${b}
+                    multiline
+                    template
+                    literal
+                    \`(() => {
+                        tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                        baz();
+                    });
+                };
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                tagOne\`multiline
+                        \${a} \${b}
+                        template
+                        literal
+                        \`(() => {        
+                    foo();
+                    
+                    tagTwo\`multiline
+                            template
+                            literal
+                        \`({
+                        bar: 1,
+                        baz: 2
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                tagOne\`multiline
+                    template
+                    literal
+                    \${a} \${b}\`({        
+                    foo: 1,
+                    bar: tagTwo\`multiline
+                        template
+                        literal\`(() => {
+                        
+                        baz();
+                    })
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo.bar\` template literal \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo.bar.baz\` template literal \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                    .bar\` template
+                        literal \`(() => {
+                        baz();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                    .bar
+                    .baz\` template 
+                        literal \`(() => {
+                        baz();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo.bar\`
+                    \${a} \${b}
+                    \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo.bar1.bar2\`
+                    \${a} \${b}
+                    \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                    .bar1
+                    .bar2\`
+                    \${a} \${b}
+                    \`(() => {
+                        baz();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                    .bar\`
+                    \${a} \${b}
+                    \`(() => {
+                        baz();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                .test\`
+                    \${a} \${b}
+                    \`(() => {
+                    baz();
+                })
+            `,
+            options: [4, { MemberExpression: 0 }],
+            parserOptions: { ecmaVersion: 2015 }
+        },
+        {
+            code: unIndent`
+                foo
+                        .test\`
+                    \${a} \${b}
+                    \`(() => {
+                            baz();
+                        })
+            `,
+            options: [4, { MemberExpression: 2 }],
+            parserOptions: { ecmaVersion: 2015 }
         }
     ],
 
@@ -10831,6 +11049,331 @@ ruleTester.run("indent", rule, {
                 [2, 4, 0, "Identifier"],
                 [3, 0, 4, "Punctuator"]
             ])
+        },
+
+        // https://github.com/eslint/eslint/issues/12122
+        {
+            code: unIndent`
+                foo(() => {
+                    tag\`
+                    multiline
+                    template\${a} \${b}
+                    literal
+                    \`(() => {
+                    bar();
+                    });
+                });
+            `,
+            output: unIndent`
+                foo(() => {
+                    tag\`
+                    multiline
+                    template\${a} \${b}
+                    literal
+                    \`(() => {
+                        bar();
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [7, 8, 4, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                {
+                        tag\`
+                    multiline
+                    template
+                    literal
+                    \${a} \${b}\`(() => {
+                            bar();
+                        });
+                }
+            `,
+            output: unIndent`
+                {
+                    tag\`
+                    multiline
+                    template
+                    literal
+                    \${a} \${b}\`(() => {
+                        bar();
+                    });
+                }
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [2, 4, 8, "Identifier"],
+                [7, 8, 12, "Identifier"],
+                [8, 4, 8, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo(() => {
+                    tagOne\`\${a} \${b}
+                    multiline
+                    template
+                    literal
+                    \`(() => {
+                            tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                            baz();
+                });
+                });
+            `,
+            output: unIndent`
+                foo(() => {
+                    tagOne\`\${a} \${b}
+                    multiline
+                    template
+                    literal
+                    \`(() => {
+                        tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                        baz();
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [7, 8, 12, "Identifier"],
+                [15, 8, 12, "Identifier"],
+                [16, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                {
+                    tagOne\`
+                    multiline
+                    template
+                    literal
+                    \${a} \${b}\`(() => {
+                            tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                            baz();
+                });
+                }
+            `,
+            output: unIndent`
+                {
+                    tagOne\`
+                    multiline
+                    template
+                    literal
+                    \${a} \${b}\`(() => {
+                        tagTwo\`
+                        multiline
+                        template
+                        literal
+                        \`(() => {
+                            bar();
+                        });
+
+                        baz();
+                    });
+                }
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [7, 8, 12, "Identifier"],
+                [15, 8, 12, "Identifier"],
+                [16, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                tagOne\`multiline \${a} \${b}
+                        template
+                        literal
+                        \`(() => {        
+                foo();
+                    
+                    tagTwo\`multiline
+                            template
+                            literal
+                        \`({
+                    bar: 1,
+                        baz: 2
+                    });
+                });
+            `,
+            output: unIndent`
+                tagOne\`multiline \${a} \${b}
+                        template
+                        literal
+                        \`(() => {        
+                    foo();
+                    
+                    tagTwo\`multiline
+                            template
+                            literal
+                        \`({
+                        bar: 1,
+                        baz: 2
+                    });
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [5, 4, 0, "Identifier"],
+                [11, 8, 4, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                tagOne\`multiline
+                    template \${a} \${b}
+                    literal\`({
+                        foo: 1,
+                bar: tagTwo\`multiline
+                        template
+                        literal\`(() => {
+                        
+                baz();
+                    })
+                });
+            `,
+            output: unIndent`
+                tagOne\`multiline
+                    template \${a} \${b}
+                    literal\`({
+                    foo: 1,
+                    bar: tagTwo\`multiline
+                        template
+                        literal\`(() => {
+                        
+                        baz();
+                    })
+                });
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [4, 4, 8, "Identifier"],
+                [5, 4, 0, "Identifier"],
+                [9, 8, 0, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo.bar\` template literal \`(() => {
+                        baz();
+                })
+            `,
+            output: unIndent`
+                foo.bar\` template literal \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [2, 4, 8, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo.bar.baz\` template literal \`(() => {
+                baz();
+                    })
+            `,
+            output: unIndent`
+                foo.bar.baz\` template literal \`(() => {
+                    baz();
+                })
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [2, 4, 0, "Identifier"],
+                [3, 0, 4, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo
+                    .bar\` template
+                        literal \`(() => {
+                        baz();
+                })
+            `,
+            output: unIndent`
+                foo
+                    .bar\` template
+                        literal \`(() => {
+                        baz();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [5, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo
+                    .test\`
+                    \${a} \${b}
+                    \`(() => {
+                bar();
+                    })
+            `,
+            output: unIndent`
+                foo
+                    .test\`
+                    \${a} \${b}
+                    \`(() => {
+                        bar();
+                    })
+            `,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [5, 8, 0, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                foo
+                    .test\`
+                    \${a} \${b}
+                    \`(() => {
+                bar();
+                    })
+            `,
+            output: unIndent`
+                foo
+                .test\`
+                    \${a} \${b}
+                    \`(() => {
+                    bar();
+                })
+            `,
+            options: [4, { MemberExpression: 0 }],
+            parserOptions: { ecmaVersion: 2015 },
+            errors: expectedErrors([
+                [2, 0, 4, "Punctuator"],
+                [5, 4, 0, "Identifier"],
+                [6, 0, 4, "Punctuator"]
+            ])
         }
     ]
 });
diff --git a/tests/lib/rules/no-extend-native.js b/tests/lib/rules/no-extend-native.js
index 7c1b2514a..a38177431 100644
--- a/tests/lib/rules/no-extend-native.js
+++ b/tests/lib/rules/no-extend-native.js
@@ -56,6 +56,14 @@ ruleTester.run("no-extend-native", rule, {
             data: { builtin: "Object" },
             type: "AssignmentExpression"
         }]
+    }, {
+        code: "BigInt.prototype.p = 0",
+        env: { es2020: true },
+        errors: [{
+            messageId: "unexpected",
+            data: { builtin: "BigInt" },
+            type: "AssignmentExpression"
+        }]
     }, {
         code: "Function.prototype['p'] = 0",
         errors: [{
diff --git a/tests/lib/rules/no-extra-parens.js b/tests/lib/rules/no-extra-parens.js
index 26f682bae..8d20ba7cd 100644
--- a/tests/lib/rules/no-extra-parens.js
+++ b/tests/lib/rules/no-extra-parens.js
@@ -1403,6 +1403,30 @@ ruleTester.run("no-extra-parens", rule, {
         invalid("const [a = (b)] = []", "const [a = b] = []", "Identifier"),
         invalid("const {a = (b)} = {}", "const {a = b} = {}", "Identifier"),
 
+        // LHS of assigments/Assignment targets
+        invalid("(a) = b", "a = b", "Identifier"),
+        invalid("(a.b) = c", "a.b = c", "MemberExpression"),
+        invalid("(a) += b", "a += b", "Identifier"),
+        invalid("(a.b) >>= c", "a.b >>= c", "MemberExpression"),
+        invalid("[(a) = b] = []", "[a = b] = []", "Identifier"),
+        invalid("[(a.b) = c] = []", "[a.b = c] = []", "MemberExpression"),
+        invalid("({ a: (b) = c } = {})", "({ a: b = c } = {})", "Identifier"),
+        invalid("({ a: (b.c) = d } = {})", "({ a: b.c = d } = {})", "MemberExpression"),
+        invalid("[(a)] = []", "[a] = []", "Identifier"),
+        invalid("[(a.b)] = []", "[a.b] = []", "MemberExpression"),
+        invalid("[,(a),,] = []", "[,a,,] = []", "Identifier"),
+        invalid("[...(a)] = []", "[...a] = []", "Identifier"),
+        invalid("[...(a.b)] = []", "[...a.b] = []", "MemberExpression"),
+        invalid("({ a: (b) } = {})", "({ a: b } = {})", "Identifier"),
+        invalid("({ a: (b.c) } = {})", "({ a: b.c } = {})", "MemberExpression"),
+
+        /*
+         * TODO: Add these tests for RestElement's parenthesized arguments in object patterns when that becomes supported by Espree.
+         *
+         * invalid("({ ...(a) } = {})", "({ ...a } = {})", "Identifier"),
+         * invalid("({ ...(a.b) } = {})", "({ ...a.b } = {})", "MemberExpression")
+         */
+
         // https://github.com/eslint/eslint/issues/11706 (also in valid[])
         {
             code: "for ((a = (b in c)); ;);",
diff --git a/tests/lib/rules/no-magic-numbers.js b/tests/lib/rules/no-magic-numbers.js
index 8ebd8c93d..bda02662e 100644
--- a/tests/lib/rules/no-magic-numbers.js
+++ b/tests/lib/rules/no-magic-numbers.js
@@ -75,6 +75,16 @@ ruleTester.run("no-magic-numbers", rule, {
                     jsx: true
                 }
             }
+        },
+        {
+            code: "f(100n)",
+            options: [{ ignore: ["100n"] }],
+            parserOptions: { ecmaVersion: 2020 }
+        },
+        {
+            code: "f(-100n)",
+            options: [{ ignore: ["-100n"] }],
+            parserOptions: { ecmaVersion: 2020 }
         }
     ],
     invalid: [
@@ -93,6 +103,26 @@ ruleTester.run("no-magic-numbers", rule, {
                 { messageId: "noMagic", data: { raw: "1" } }
             ]
         },
+        {
+            code: "var foo = 42n",
+            options: [{
+                enforceConst: true
+            }],
+            parserOptions: {
+                ecmaVersion: 2020
+            },
+            errors: [{ messageId: "useConst" }]
+        },
+        {
+            code: "var foo = 0n + 1n;",
+            parserOptions: {
+                ecmaVersion: 2020
+            },
+            errors: [
+                { messageId: "noMagic", data: { raw: "0n" } },
+                { messageId: "noMagic", data: { raw: "1n" } }
+            ]
+        },
         {
             code: "a = a + 5;",
             errors: [
@@ -227,6 +257,37 @@ ruleTester.run("no-magic-numbers", rule, {
                 { messageId: "noMagic", data: { raw: "10" }, line: 1 },
                 { messageId: "noMagic", data: { raw: "4" }, line: 1 }
             ]
+        },
+        {
+            code: "f(100n)",
+            options: [{ ignore: [100] }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [
+                { messageId: "noMagic", data: { raw: "100n" }, line: 1 }
+            ]
+        },
+        {
+            code: "f(-100n)",
+            options: [{ ignore: ["100n"] }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [
+                { messageId: "noMagic", data: { raw: "-100n" }, line: 1 }
+            ]
+        },
+        {
+            code: "f(100n)",
+            options: [{ ignore: ["-100n"] }],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [
+                { messageId: "noMagic", data: { raw: "100n" }, line: 1 }
+            ]
+        },
+        {
+            code: "f(100)",
+            options: [{ ignore: ["100n"] }],
+            errors: [
+                { messageId: "noMagic", data: { raw: "100" }, line: 1 }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/no-restricted-imports.js b/tests/lib/rules/no-restricted-imports.js
index 958395f45..680bc1352 100644
--- a/tests/lib/rules/no-restricted-imports.js
+++ b/tests/lib/rules/no-restricted-imports.js
@@ -168,6 +168,17 @@ ruleTester.run("no-restricted-imports", rule, {
         {
             code: "import {\nAllowedObject,\nDisallowedObject, // eslint-disable-line\n} from \"foo\";",
             options: [{ paths: [{ name: "foo", importNames: ["DisallowedObject"] }] }]
+        },
+        {
+            code: "export * from \"foo\";",
+            options: ["bar"]
+        },
+        {
+            code: "export * from \"foo\";",
+            options: [{
+                name: "bar",
+                importNames: ["DisallowedObject"]
+            }]
         }
     ],
     invalid: [{
@@ -356,6 +367,37 @@ ruleTester.run("no-restricted-imports", rule, {
             endColumn: 16
         }]
     },
+    {
+        code: "export * from \"foo\";",
+        options: [{
+            paths: [{
+                name: "foo",
+                importNames: ["DisallowedObject"],
+                message: "Please import 'DisallowedObject' from /bar/ instead."
+            }]
+        }],
+        errors: [{
+            message: "* import is invalid because 'DisallowedObject' from 'foo' is restricted. Please import 'DisallowedObject' from /bar/ instead.",
+            type: "ExportAllDeclaration",
+            line: 1,
+            column: 8,
+            endColumn: 9
+        }]
+    },
+    {
+        code: "export * from \"foo\";",
+        options: [{
+            name: "foo",
+            importNames: ["DisallowedObject1, DisallowedObject2"]
+        }],
+        errors: [{
+            message: "* import is invalid because 'DisallowedObject1, DisallowedObject2' from 'foo' is restricted.",
+            type: "ExportAllDeclaration",
+            line: 1,
+            column: 8,
+            endColumn: 9
+        }]
+    },
     {
         code: "import { DisallowedObject } from \"foo\";",
         options: [{
diff --git a/tests/lib/rules/no-useless-computed-key.js b/tests/lib/rules/no-useless-computed-key.js
index cd33cc732..a5907aede 100644
--- a/tests/lib/rules/no-useless-computed-key.js
+++ b/tests/lib/rules/no-useless-computed-key.js
@@ -40,7 +40,16 @@ ruleTester.run("no-useless-computed-key", rule, {
         { code: "class Foo { ['x']() {} }", options: [{ enforceForClassMembers: false }] },
         { code: "(class { ['x']() {} })", options: [{ enforceForClassMembers: false }] },
         { code: "class Foo { static ['constructor']() {} }", options: [{ enforceForClassMembers: false }] },
-        { code: "class Foo { ['prototype']() {} }", options: [{ enforceForClassMembers: false }] }
+        { code: "class Foo { ['prototype']() {} }", options: [{ enforceForClassMembers: false }] },
+
+        /*
+         * Well-known browsers throw syntax error bigint literals on property names,
+         * so, this rule doesn't touch those for now.
+         */
+        {
+            code: "({ [99999999999999999n]: 0 })",
+            parserOptions: { ecmaVersion: 2020 }
+        }
     ],
     invalid: [
         {
diff --git a/tests/lib/rules/prefer-object-spread.js b/tests/lib/rules/prefer-object-spread.js
index 11c16d60c..9ec3cf630 100644
--- a/tests/lib/rules/prefer-object-spread.js
+++ b/tests/lib/rules/prefer-object-spread.js
@@ -59,7 +59,19 @@ ruleTester.run("prefer-object-spread", rule, {
         `
         import { Object, Array } from 'globals';
         Object.assign({ foo: 'bar' });
-        `
+        `,
+
+        // ignore Object.assign() with > 1 arguments if any of the arguments is an object expression with a getter/setter
+        "Object.assign({ get a() {} }, {})",
+        "Object.assign({ set a(val) {} }, {})",
+        "Object.assign({ get a() {} }, foo)",
+        "Object.assign({ set a(val) {} }, foo)",
+        "Object.assign({ foo: 'bar', get a() {}, baz: 'quux' }, quuux)",
+        "Object.assign({ foo: 'bar', set a(val) {} }, { baz: 'quux' })",
+        "Object.assign({}, { get a() {} })",
+        "Object.assign({}, { set a(val) {} })",
+        "Object.assign({}, { foo: 'bar', get a() {} }, {})",
+        "Object.assign({ foo }, bar, {}, { baz: 'quux', set a(val) {}, quuux }, {})"
     ],
 
     invalid: [
@@ -834,6 +846,20 @@ ruleTester.run("prefer-object-spread", rule, {
                     column: 1
                 }
             ]
+        },
+
+        // report Object.assign() with getters/setters if the function call has only 1 argument
+        {
+            code: "Object.assign({ get a() {}, set b(val) {} })",
+            output: "({get a() {}, set b(val) {}})",
+            errors: [
+                {
+                    messageId: "useLiteralMessage",
+                    type: "CallExpression",
+                    line: 1,
+                    column: 1
+                }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/quote-props.js b/tests/lib/rules/quote-props.js
index c1cd10e50..9d033dfb8 100644
--- a/tests/lib/rules/quote-props.js
+++ b/tests/lib/rules/quote-props.js
@@ -73,7 +73,13 @@ ruleTester.run("quote-props", rule, {
         { code: "({1: 1, x: 2})", options: ["consistent-as-needed", { numbers: true }] },
         { code: "({ ...x })", options: ["as-needed"], parserOptions: { ecmaVersion: 2018 } },
         { code: "({ ...x })", options: ["consistent"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "({ ...x })", options: ["consistent-as-needed"], parserOptions: { ecmaVersion: 2018 } }
+        { code: "({ ...x })", options: ["consistent-as-needed"], parserOptions: { ecmaVersion: 2018 } },
+        { code: "({ 1n: 1 })", options: ["as-needed"], parserOptions: { ecmaVersion: 2020 } },
+        { code: "({ 1n: 1 })", options: ["as-needed", { numbers: false }], parserOptions: { ecmaVersion: 2020 } },
+        { code: "({ 1n: 1 })", options: ["consistent"], parserOptions: { ecmaVersion: 2020 } },
+        { code: "({ 1n: 1 })", options: ["consistent-as-needed"], parserOptions: { ecmaVersion: 2020 } },
+        { code: "({ '99999999999999999': 1 })", options: ["as-needed"], parserOptions: { ecmaVersion: 2020 } },
+        { code: "({ '1n': 1 })", options: ["as-needed"], parserOptions: { ecmaVersion: 2020 } }
     ],
     invalid: [{
         code: "({ a: 0 })",
@@ -304,5 +310,17 @@ ruleTester.run("quote-props", rule, {
         errors: [{
             message: "Unquoted property '5' found."
         }]
+    }, {
+        code: "({ 1n: 1 })",
+        output: "({ \"1\": 1 })",
+        options: ["always"],
+        parserOptions: { ecmaVersion: 2020 },
+        errors: [{ message: "Unquoted property '1' found." }]
+    }, {
+        code: "({ 1n: 1 })",
+        output: "({ \"1\": 1 })",
+        options: ["as-needed", { numbers: true }],
+        parserOptions: { ecmaVersion: 2020 },
+        errors: [{ message: "Unquoted number literal '1' used as key." }]
     }]
 });
diff --git a/tests/lib/rules/radix.js b/tests/lib/rules/radix.js
index 0acb063a3..5e27c9c13 100644
--- a/tests/lib/rules/radix.js
+++ b/tests/lib/rules/radix.js
@@ -18,6 +18,11 @@ ruleTester.run("radix", rule, {
 
     valid: [
         "parseInt(\"10\", 10);",
+        "parseInt(\"10\", 2);",
+        "parseInt(\"10\", 36);",
+        "parseInt(\"10\", 0x10);",
+        "parseInt(\"10\", 1.6e1);",
+        "parseInt(\"10\", 10.0);",
         "parseInt(\"10\", foo);",
         "Number.parseInt(\"10\", foo);",
         {
@@ -75,35 +80,56 @@ ruleTester.run("radix", rule, {
         {
             code: "parseInt(\"10\", null);",
             errors: [{
-                message: "Invalid radix parameter.",
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
                 type: "CallExpression"
             }]
         },
         {
             code: "parseInt(\"10\", undefined);",
             errors: [{
-                message: "Invalid radix parameter.",
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
                 type: "CallExpression"
             }]
         },
         {
             code: "parseInt(\"10\", true);",
             errors: [{
-                message: "Invalid radix parameter.",
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
                 type: "CallExpression"
             }]
         },
         {
             code: "parseInt(\"10\", \"foo\");",
             errors: [{
-                message: "Invalid radix parameter.",
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
                 type: "CallExpression"
             }]
         },
         {
             code: "parseInt(\"10\", \"123\");",
             errors: [{
-                message: "Invalid radix parameter.",
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
+        {
+            code: "parseInt(\"10\", 1);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
+        {
+            code: "parseInt(\"10\", 37);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
+        {
+            code: "parseInt(\"10\", 10.5);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
                 type: "CallExpression"
             }]
         },
@@ -129,6 +155,27 @@ ruleTester.run("radix", rule, {
                 type: "CallExpression"
             }]
         },
+        {
+            code: "Number.parseInt(\"10\", 1);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
+        {
+            code: "Number.parseInt(\"10\", 37);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
+        {
+            code: "Number.parseInt(\"10\", 10.5);",
+            errors: [{
+                message: "Invalid radix parameter, must be an integer between 2 and 36.",
+                type: "CallExpression"
+            }]
+        },
         {
             code: "parseInt(\"10\", 10);",
             options: ["as-needed"],
diff --git a/tests/lib/rules/template-curly-spacing.js b/tests/lib/rules/template-curly-spacing.js
index 909ee8ccf..85fa87056 100644
--- a/tests/lib/rules/template-curly-spacing.js
+++ b/tests/lib/rules/template-curly-spacing.js
@@ -26,7 +26,31 @@ ruleTester.run("template-curly-spacing", rule, {
         { code: "`${ foo } ${ bar } ${\n  baz\n}`", options: ["always"] },
         "tag`${foo} ${bar}`",
         { code: "tag`${foo} ${bar} ${\n  baz\n}`", options: ["never"] },
-        { code: "tag`${ foo } ${ bar } ${\n  baz\n}`", options: ["always"] }
+        { code: "tag`${ foo } ${ bar } ${\n  baz\n}`", options: ["always"] },
+
+        "`${/*  */ foo} ${bar /*  */}`",
+        "`${/*  */foo/*  */} ${/*  */  bar  /*  */}`",
+        "`${\n  /*  */  foo  /*  */  \n} ${/*\n  */  bar  /*  \n*/}`",
+        "tag`${/*  */ foo} ${bar /*  */}}`",
+        "tag`${/*  */foo/*  */} ${/*  */  bar  /*  */}`",
+        "tag`${\n  /*  */  foo  /*  */  \n} ${/*\n  */  bar  /*  \n*/}`",
+        "`${// comment\n foo} ${bar // comment \n}`",
+
+        { code: "`${/*  */ foo} ${bar /*  */}`", options: ["never"] },
+        { code: "`${/*  */foo/*  */} ${/*  */  bar  /*  */}`", options: ["never"] },
+        { code: "`${\n  /*  */  foo  /*  */  \n} ${/*\n  */  bar  /*  \n*/}`", options: ["never"] },
+        { code: "tag`${/*  */ foo} ${bar /*  */}}`", options: ["never"] },
+        { code: "tag`${/*  */foo/*  */} ${/*  */  bar  /*  */}`", options: ["never"] },
+        { code: "tag`${\n  /*  */  foo  /*  */  \n} ${/*\n  */  bar  /*  \n*/}`", options: ["never"] },
+        { code: "`${// comment\n foo} ${bar // comment \n}`", options: ["never"] },
+
+        { code: "`${ /*  */ foo } ${ bar /*  */ }`", options: ["always"] },
+        { code: "`${ /*  */foo/*  */ } ${ /*  */  bar  /*  */ }`", options: ["always"] },
+        { code: "`${\n  /*  */  foo  /*  */  \n} ${ /*\n  */  bar  /*  \n*/ }`", options: ["always"] },
+        { code: "tag`${ /*  */ foo } ${ bar /*  */ }`", options: ["always"] },
+        { code: "tag`${ /*  */foo/*  */ } ${ /*  */  bar  /*  */ }`", options: ["always"] },
+        { code: "tag`${\n  /*  */  foo  /*  */  \n} ${ /*\n  */  bar  /*  \n*/ }`", options: ["always"] },
+        { code: "`${ // comment\n foo } ${ bar // comment \n}`", options: ["always"] }
     ],
     invalid: [
         {
@@ -92,6 +116,157 @@ ruleTester.run("template-curly-spacing", rule, {
                 { messageId: "expectedAfter", column: 12 },
                 { messageId: "expectedBefore", column: 17 }
             ]
+        },
+        {
+            code: "`${ /*  */foo } ${ bar/*  */ }`",
+            output: "`${/*  */foo} ${bar/*  */}`",
+            errors: [
+                { messageId: "unexpectedAfter", column: 2 },
+                { messageId: "unexpectedBefore", column: 15 },
+                { messageId: "unexpectedAfter", column: 17 },
+                { messageId: "unexpectedBefore", column: 30 }
+            ]
+        },
+        {
+            code: "`${ /*\n  */foo } ${ bar/*  \n*/ }`",
+            output: "`${/*\n  */foo} ${bar/*  \n*/}`",
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 2 },
+                { messageId: "unexpectedBefore", line: 2, column: 9 },
+                { messageId: "unexpectedAfter", line: 2, column: 11 },
+                { messageId: "unexpectedBefore", line: 3, column: 4 }
+            ]
+        },
+        {
+            code: "`${ /*  */ foo } ${ bar /*  */ }`",
+            output: "`${/*  */ foo} ${bar /*  */}`",
+            options: ["never"],
+            errors: [
+                { messageId: "unexpectedAfter", column: 2 },
+                { messageId: "unexpectedBefore", column: 16 },
+                { messageId: "unexpectedAfter", column: 18 },
+                { messageId: "unexpectedBefore", column: 32 }
+            ]
+        },
+        {
+            code: "`${ /*\n  */ foo } ${ bar /*  \n*/ }`",
+            output: "`${/*\n  */ foo} ${bar /*  \n*/}`",
+            options: ["never"],
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 2 },
+                { messageId: "unexpectedBefore", line: 2, column: 10 },
+                { messageId: "unexpectedAfter", line: 2, column: 12 },
+                { messageId: "unexpectedBefore", line: 3, column: 4 }
+            ]
+        },
+        {
+            code: "`${/*  */foo} ${bar/*  */}`",
+            output: "`${ /*  */foo } ${ bar/*  */ }`",
+            options: ["always"],
+            errors: [
+                { messageId: "expectedAfter", column: 2 },
+                { messageId: "expectedBefore", column: 13 },
+                { messageId: "expectedAfter", column: 15 },
+                { messageId: "expectedBefore", column: 26 }
+            ]
+        },
+        {
+            code: "`${/*\n  */foo} ${bar/*  \n*/}`",
+            output: "`${ /*\n  */foo } ${ bar/*  \n*/ }`",
+            options: ["always"],
+            errors: [
+                { messageId: "expectedAfter", line: 1, column: 2 },
+                { messageId: "expectedBefore", line: 2, column: 8 },
+                { messageId: "expectedAfter", line: 2, column: 10 },
+                { messageId: "expectedBefore", line: 3, column: 3 }
+            ]
+        },
+        {
+            code: "tag`${ /*  */foo } ${ bar/*  */ }`",
+            output: "tag`${/*  */foo} ${bar/*  */}`",
+            errors: [
+                { messageId: "unexpectedAfter", column: 5 },
+                { messageId: "unexpectedBefore", column: 18 },
+                { messageId: "unexpectedAfter", column: 20 },
+                { messageId: "unexpectedBefore", column: 33 }
+            ]
+        },
+        {
+            code: "tag`${ /*\n  */foo } ${ bar/*  \n*/ }`",
+            output: "tag`${/*\n  */foo} ${bar/*  \n*/}`",
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 5 },
+                { messageId: "unexpectedBefore", line: 2, column: 9 },
+                { messageId: "unexpectedAfter", line: 2, column: 11 },
+                { messageId: "unexpectedBefore", line: 3, column: 4 }
+            ]
+        },
+        {
+            code: "tag`${ /*  */foo } ${ bar/*  */ }`",
+            output: "tag`${/*  */foo} ${bar/*  */}`",
+            options: ["never"],
+            errors: [
+                { messageId: "unexpectedAfter", column: 5 },
+                { messageId: "unexpectedBefore", column: 18 },
+                { messageId: "unexpectedAfter", column: 20 },
+                { messageId: "unexpectedBefore", column: 33 }
+            ]
+        },
+        {
+            code: "tag`${ /*\n  */foo } ${ bar/*  \n*/ }`",
+            output: "tag`${/*\n  */foo} ${bar/*  \n*/}`",
+            options: ["never"],
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 5 },
+                { messageId: "unexpectedBefore", line: 2, column: 9 },
+                { messageId: "unexpectedAfter", line: 2, column: 11 },
+                { messageId: "unexpectedBefore", line: 3, column: 4 }
+            ]
+        },
+        {
+            code: "tag`${/*  */foo} ${bar/*  */}`",
+            output: "tag`${ /*  */foo } ${ bar/*  */ }`",
+            options: ["always"],
+            errors: [
+                { messageId: "expectedAfter", column: 5 },
+                { messageId: "expectedBefore", column: 16 },
+                { messageId: "expectedAfter", column: 18 },
+                { messageId: "expectedBefore", column: 29 }
+            ]
+        },
+        {
+            code: "tag`${/*\n  */foo} ${bar/*  \n*/}`",
+            output: "tag`${ /*\n  */foo } ${ bar/*  \n*/ }`",
+            options: ["always"],
+            errors: [
+                { messageId: "expectedAfter", line: 1, column: 5 },
+                { messageId: "expectedBefore", line: 2, column: 8 },
+                { messageId: "expectedAfter", line: 2, column: 10 },
+                { messageId: "expectedBefore", line: 3, column: 3 }
+            ]
+        },
+        {
+            code: "`${ // comment\n foo} ${bar // comment \n}`",
+            output: "`${// comment\n foo} ${bar // comment \n}`",
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 2 }
+            ]
+        },
+        {
+            code: "`${ // comment\n foo} ${bar // comment \n}`",
+            output: "`${// comment\n foo} ${bar // comment \n}`",
+            options: ["never"],
+            errors: [
+                { messageId: "unexpectedAfter", line: 1, column: 2 }
+            ]
+        },
+        {
+            code: "`${// comment\n foo } ${ bar // comment \n}`",
+            output: "`${ // comment\n foo } ${ bar // comment \n}`",
+            options: ["always"],
+            errors: [
+                { messageId: "expectedAfter", line: 1, column: 2 }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/yoda.js b/tests/lib/rules/yoda.js
index 414cb5a04..72f013964 100644
--- a/tests/lib/rules/yoda.js
+++ b/tests/lib/rules/yoda.js
@@ -91,6 +91,22 @@ ruleTester.run("yoda", rule, {
         }, {
             code: "if (0 <= a.b && a[\"b\"] <= 100) {}",
             options: ["never", { exceptRange: true }]
+        }, {
+            code: "if (-1n < x && x <= 1n) {}",
+            options: ["never", { exceptRange: true }],
+            parserOptions: { ecmaVersion: 2020 }
+        }, {
+            code: "if (x < -1n || 1n <= x) {}",
+            options: ["never", { exceptRange: true }],
+            parserOptions: { ecmaVersion: 2020 }
+        }, {
+            code: "if (-1n <= x && x < 1n) {}",
+            options: ["always", { exceptRange: true }],
+            parserOptions: { ecmaVersion: 2020 }
+        }, {
+            code: "if (x < -1n || 1n <= x) {}",
+            options: ["always", { exceptRange: true }],
+            parserOptions: { ecmaVersion: 2020 }
         }, {
             code: "if (1 <= a['/(?<zero>0)/'] && a[/(?<zero>0)/] <= 100) {}",
             options: ["never", { exceptRange: true }],
@@ -140,6 +156,19 @@ ruleTester.run("yoda", rule, {
                 }
             ]
         },
+        {
+            code: "if (5n != value) {}",
+            output: "if (value != 5n) {}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [
+                {
+                    messageId: "expected",
+                    data: { expectedSide: "right", operator: "!=" },
+                    type: "BinaryExpression"
+                }
+            ]
+        },
         {
             code: "if (null !== value) {}",
             output: "if (value !== null) {}",
@@ -236,6 +265,19 @@ ruleTester.run("yoda", rule, {
                 }
             ]
         },
+        {
+            code: "if (value === 5n) {}",
+            output: "if (5n === value) {}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [
+                {
+                    messageId: "expected",
+                    data: { expectedSide: "left", operator: "===" },
+                    type: "BinaryExpression"
+                }
+            ]
+        },
         {
             code: "if (a < 0 && 0 <= b && b < 1) {}",
             output: "if (a < 0 && b >= 0 && b < 1) {}",
diff --git a/tests/tools/internal-rules/consistent-docs-description.js b/tests/tools/internal-rules/consistent-docs-description.js
deleted file mode 100644
index 80fa7784a..000000000
--- a/tests/tools/internal-rules/consistent-docs-description.js
+++ /dev/null
@@ -1,264 +0,0 @@
-/**
- * @fileoverview Tests for internal-consistent-docs-description rule.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const rule = require("../../../tools/internal-rules/consistent-docs-description"),
-    { RuleTester } = require("../../../lib/rule-tester");
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const ruleTester = new RuleTester();
-
-ruleTester.run("consistent-docs-description", rule, {
-    valid: [
-
-        // wrong exports format: "internal-no-invalid-meta" reports this already
-        [
-            "module.exports = function(context) {",
-            "    return {",
-            "        Program: function(node) {}",
-            "    };",
-            "};"
-        ].join("\n"),
-
-        // missing `meta.docs.description` property: "internal-no-invalid-meta" reports this already
-        [
-            "module.exports = {",
-            "    meta: {},",
-            "    create: function(context) {",
-            "        return {};",
-            "    }",
-            "};"
-        ].join("\n"),
-        [
-            "module.exports = {",
-            "    meta: {",
-            "        docs: {",
-            "            description: 'enforce some stuff'",
-            "        }",
-            "    },",
-
-            "    create: function(context) {",
-            "        return {};",
-            "    }",
-            "};"
-        ].join("\n"),
-        [
-            "module.exports = {",
-            "    meta: {",
-            "        docs: {",
-            "            description: 'require some things'",
-            "        }",
-            "    },",
-
-            "    create: function(context) {",
-            "        return {};",
-            "    }",
-            "};"
-        ].join("\n"),
-        [
-            "module.exports = {",
-            "    meta: {",
-            "        docs: {",
-            "            description: 'disallow bad things'",
-            "        }",
-            "    },",
-
-            "    create: function(context) {",
-            "        return {};",
-            "    }",
-            "};"
-        ].join("\n")
-    ],
-    invalid: [
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: 'do stuff'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should start with one of the following words: enforce, require, disallow. Started with \"do\" instead.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: 'Require stuff'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should start with one of the following words: enforce, require, disallow. Started with \"Require\" instead.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: 'Enforce stuff'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should start with one of the following words: enforce, require, disallow. Started with \"Enforce\" instead.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: 'Disallow stuff'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should start with one of the following words: enforce, require, disallow. Started with \"Disallow\" instead.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: ' disallow (whitespace in the beginning)'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should not start with whitespace.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: '    disallow (whitespaces in the beginning)'",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should not start with whitespace.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: '  '",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should not start with whitespace.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: ''",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should not be empty.",
-                line: 4,
-                column: 26
-            }]
-        },
-        {
-            code: [
-                "module.exports = {",
-                "    meta: {",
-                "        docs: {",
-                "            description: true",
-                "        }",
-                "    },",
-
-                "    create: function(context) {",
-                "        return {};",
-                "    }",
-                "};"
-            ].join("\n"),
-            errors: [{
-                message: "`meta.docs.description` should be a string.",
-                line: 4,
-                column: 26
-            }]
-        }
-    ]
-});