Repository: eslint/eslint
Pull request #10152 (2018-03-30 20:40:45)

Breaking: Upgrade to Espree v4 alpha (refs #9990)
<!--
    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: Upgrade to the Espree v4 alpha and remove now-redundant `experimentalObjectRestSpread` tests.

<!--
    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 upgrades Espree to v4.0.0-alpha.0 and removes our duplicated tests that pair `experimentalObjectRestSpread` and `ecmaVersion: 2018`. It does not implement the deprecation warning or translating the former to the latter in the background. It also enables `ecmaVersion: 2018` in the config initializer when React is enabled instead of enabling `experimentalObjectRestSpread`.

**Is there anything you'd like reviewers to focus on?**

All of the tests that were deleted should have an existing pair that's equivalent except for using `ecmaVersion: 2018` instead of `experimentalObjectRestSpread`.



Patch:
diff --git a/docs/rules/rest-spread-spacing.md b/docs/rules/rest-spread-spacing.md
index 27cc626c1..d8d6063b9 100644
--- a/docs/rules/rest-spread-spacing.md
+++ b/docs/rules/rest-spread-spacing.md
@@ -41,15 +41,12 @@ As with other operators, whitespace is allowed between the rest or spread operat
 
 ## Rule Details
 
-This rule aims to enforce consistent spacing between rest and spread operators and their expressions. The rule also supports the currently experimental object rest and spread properties when enabled:
+This rule aims to enforce consistent spacing between rest and spread operators and their expressions. The rule also supports object rest and spread properties in ES2018:
 
 ```json
 {
     "parserOptions": {
-        "ecmaVersion": 6,
-        "ecmaFeatures": {
-            "experimentalObjectRestSpread": true
-        }
+        "ecmaVersion": 2018
     }
 }
 ```
diff --git a/docs/user-guide/migrating-to-5.0.0.md b/docs/user-guide/migrating-to-5.0.0.md
new file mode 100644
index 000000000..95123b57c
--- /dev/null
+++ b/docs/user-guide/migrating-to-5.0.0.md
@@ -0,0 +1,168 @@
+# Migrating to v5.0.0
+
+ESLint v5.0.0 is the fifth major version release. We have made a few breaking changes in this release, but we expect that most users will be able to upgrade without any modifications to their build. This guide is intended to walk you through the breaking changes.
+
+The lists below are ordered roughly by the number of users each change is expected to affect, where the first items are expected to affect the most users.
+
+### Breaking changes for users
+
+1. [Node.js 4 is no longer supported](#drop-node-4)
+1. [The `experimentalObjectRestSpread` option has been deprecated](#experimental-object-rest-spread)
+1. [Linting nonexistent files from the command line is now a fatal error](#nonexistent-files)
+1. [Empty files are now linted](#empty-files)
+1. [Plugins in scoped packages are now resolvable in configs](#scoped-plugins)
+
+### Breaking changes for plugin/custom rule developers
+
+1. [The `parent` property of AST nodes is now set before rules start running](#parent-before-rules)
+1. [When using the default parser, text nodes in JSX elements now have type `JSXText`](#jsx-text-nodes)
+1. [`RuleTester` now uses strict equality checks in its assertions](#rule-tester-equality)
+1. [Rules are now required to provide messages along with reports](#required-report-messages)
+
+### Breaking changes for integration developers
+
+1. [The `source` property is no longer available on individual linting messages](#source-property)
+1. [Fatal errors now result in an exit code of 2](#exit-code-two)
+1. [The `eslint.linter` property is now non-enumerable](#non-enumerable-linter)
+
+---
+
+## <a name="drop-node-4"></a> Node.js 4 is no longer supported
+
+As of April 30th, 2018, Node.js 4 will be at EOL and will no longer be receiving security updates. As a result, we have decided to drop support for it in ESLint v5. We now support the following versions of Node.js:
+
+* Node.js 6 (6.14.0 and above)
+* Node.js 8 (8.11.0 and above)
+* Anything above Node.js 9.10.0
+
+**To address:** Make sure you upgrade to at least Node.js 6 when using ESLint v5. If you are unable to upgrade, we recommend continuing to use ESLint v4.x until you are able to upgrade Node.js.
+
+*Note: The latest alpha release of ESLint v5 may still function on Node.js 4, but we plan to officially drop support for it before the first stable release.*
+
+## <a name="experimental-object-rest-spread"></a> The `experimentalObjectRestSpread` option has been deprecated
+
+Previously, when using the default parser it was possible to use the `experimentalObjectRestSpread` option to enable support for [rest/spread properties](https://developers.google.com/web/updates/2017/06/object-rest-spread), as follows:
+
+```json
+{
+  "parserOptions": {
+    "ecmaFeatures": {
+      "experimentalObjectRestSpread": true
+    }
+  }
+}
+```
+
+Object rest/spread is now an official part of the JavaScript language, so our support for it is no longer experimental. In both ESLint v4 and ESLint v5, object rest/spread can now be enabled with the `"ecmaVersion": 2018` option:
+
+```json
+{
+  "parserOptions": {
+    "ecmaVersion": 2018
+  }
+}
+```
+
+Note that this also enables parsing for other features from ES2018, such as [async iteration](https://github.com/tc39/proposal-async-iteration). When using ESLint v5 with the default parser, it is no longer possible to toggle syntax support for object rest/spread independently of other features.
+
+For compatibility, ESLint v5 will treat `ecmaFeatures: { experimentalObjectRestSpread: true }` as an alias for `ecmaVersion: 2018` when the former is found in a config file. As a result, if you use object rest/spread, your code should still parse successfully with ESLint v5. However, note that this alias will be removed in ESLint v6.
+
+**To address:** If you use the `experimentalObjectRestSpread` option, you should be able to upgrade to ESLint v5 without any changes, but you will encounter a deprecation warning. To avoid the warning, use `ecmaVersion: 2018` in your config file rather than `ecmaFeatures: { experimentalObjectRestSpread: true }`. If you would like to disallow the use of other ES2018 features, consider using rules such as [`no-restricted-syntax`](/docs/rules/no-restricted-syntax).
+
+*Note: In the latest alpha release of ESLint v5, `experimentalObjectRestSpread` is not yet implemented as an alias for `ecmaVersion: 2018`, so configs that use `experimentalObjectRestSpread` may temporarily cause parsing errors. We plan to add this alias in a future prerelease.*
+
+## <a name="nonexistent-files"></a> Linting nonexistent files from the command line is now a fatal error
+
+Previous versions of ESLint silently ignored any nonexistent files and globs provided on the command line:
+
+```bash
+$ eslint nonexistent-file.js 'nonexistent-folder/**/*.js' # exits without any errors in ESLint v4
+```
+
+Many users found this behavior confusing, because if they made a typo in a filename, ESLint would appear to lint that file successfully while actually not linting anything.
+
+ESLint v5 will report a fatal error when either of the following conditions is met:
+
+* A file provided on the command line does not exist
+* A glob or folder provided on the command line does not match any lintable files
+
+Note that this also affects the [`CLIEngine.executeOnFiles()`](https://eslint.org/docs/developer-guide/nodejs-api#cliengineexecuteonfiles) API.
+
+**To address:** If you encounter an error about missing files after upgrading to ESLint v5, you may want to double-check that there are no typos in the paths you provide to ESLint. To make the error go away, you can simply remove the given files or globs from the list of arguments provided to ESLint on the command line.
+
+If you use a boilerplate generator that relies on this behavior (e.g. to generate a script that runs `eslint tests/` in a new project before any test files are actually present), you can work around this issue by adding a dummy file that matches the given pattern (e.g. an empty `tests/index.js` file).
+
+*Note: This change has not yet appeared in the latest alpha release. We plan to add it in a future prerelease.*
+
+## <a name="empty-files"></a> Empty files are now linted
+
+ESLint v4 had a special behavior when linting files that only contain whitespace: it would skip running the parser and rules, and it would always return zero errors. This led to some confusion for users and rule authors, particularly when writing tests for rules. (When writing a stylistic rule, rule authors would occasionally write a test where the source code only contained whitespace, to ensure that the rule behaved correctly when no applicable code was found. However, a test like this would actually not run the rule at all, so an aspect of the rule would end up untested.)
+
+ESLint v5 treats whitespace-only files the same way as all other files: it parses them and runs enabled rules on them as appropriate. This could lead to additional linting problems if you use a custom rule that reports errors on empty files.
+
+**To address:** If you have an empty file in your project and you don't want it to be linted, consider adding it to an [`.eslintignore` file](/docs/user-guide/configuring#ignoring-files-and-directories).
+
+If you have a custom rule, you should make sure it handles empty files appropriately. (In most cases, no changes should be necessary.)
+
+## <a name="scoped-plugins"></a> Plugins in scoped packages are now resolvable in configs
+
+When it encounters a plugin name in a config starting with `@`, ESLint v5 will resolve it as a [scoped npm package](https://docs.npmjs.com/misc/scope). For example, if a config contains `"plugins": ["@foo"]`, ESLint v5 will attempt to load a package called `@foo/eslint-plugin`. (On the other hand, ESLint v4 would attempt to load a package called `eslint-plugin-@foo`.) This is a breaking change because users might have been relying on ESLint finding a package at `node_modules/eslint-plugin-@foo`. However, we think it is unlikely that many users were relying on this behavior, because packages published to npm cannot contain an `@` character in the middle.
+
+**To address:** If you rely on ESLint loading a package like `eslint-config-@foo`, consider renaming the package to something else.
+
+---
+
+## <a name="parent-before-rules"></a> The `parent` property of AST nodes is now set before rules start running
+
+Previously, ESLint would set the `parent` property on each AST node immediately before running rule listeners for that node. This caused some confusion for rule authors, because the `parent` property would not initially be present on any nodes, and it was sometimes necessary to complicate the structure of a rule to ensure that the `parent` property of a given node would be available when needed.
+
+In ESLint v5, the `parent` property is set on all AST nodes before any rules have access to the AST. This makes it easier to write some rules, because the `parent` property is always available rather than being mutated behind the scenes. However, as a side-effect of having `parent` properties, the AST object has a circular structure the first time a rule sees it (previously, it only had a circular structure after the first rule listeners were called). As a result, a custom rule that enumerates all properties of an node in order to traverse the AST might now loop forever or run out of memory if it does not check for cycles properly.
+
+**To address:** If you have written a custom rule that enumerates all properties of an AST node, consider excluding the `parent` property or implementing cycle detection to ensure that you obtain the correct result.
+
+## <a name="jsx-text-nodes"></a> When using the default parser, text nodes in JSX elements now have type `JSXText`
+
+When parsing JSX code like `<a>foo</a>`, the default parser will now give the `foo` AST node the `JSXText` type, rather than the `Literal` type. This makes the AST compliant with a recent update to the JSX spec.
+
+**To address:** If you have written a custom rule that relies on text nodes in JSX elements having the `Literal` type, you should update it to also work with nodes that have the `JSXText` type.
+
+## <a name="rule-tester-equality"></a> `RuleTester` now uses strict equality checks in its assertions
+
+Previously, `RuleTester` used loose equality when making some of its assertions. For example, if a rule produced the string `"7"` as a result of autofixing, `RuleTester` would allow the number `7` in an `output` assertion, rather than the string `"7"`. In ESLint v5, comparisons from `RuleTester` use strict equality, so an assertion like this will no longer pass.
+
+**To address:** If you use `RuleTester` to write tests for your custom rules, make sure the expected values in your assertions are strictly equal to the actual values.
+
+## <a name="required-report-messages"></a> Rules are now required to provide messages along with reports
+
+Previously, it was possible for rules to report AST nodes without providing a report message. This was not intended behavior, and as a result the default formatter would crash if a rule omitted a message. However, it was possible to avoid a crash when using a non-default formatter, such as `json`.
+
+In ESLint v5, reporting a problem without providing a message always results in an error.
+
+**To address:** If you have written a custom rule that reports a problem without providing a message, update it to provide a message along with the report.
+
+---
+
+## <a name="source-property"></a> The `source` property is no longer available on individual linting messages
+
+As announced in [October 2016](/blog/2016/10/eslint-v3.8.0-released#additional-property-on-linting-results), the `source` property has been removed from individual lint message objects.
+
+**To address:** If you have a formatter or integration which relies on using the `source` property on individual linting messages, you should update it to use the `source` property on file results objects instead.
+
+## <a name="exit-code-two"></a> Fatal errors now result in an exit code of 2
+
+When using ESLint v4, both of the following scenarios resulted in an exit code of 1 when running ESLint on the command line:
+
+* Linting completed successfully, but there are some linting errors
+* Linting was unsuccessful due to a fatal error (e.g. an invalid config file)
+
+As a result, it was difficult for an integration to distinguish between the two cases to determine whether it should try to extract linting results from the output.
+
+In ESLint v5, an unsuccessful linting run due to a fatal error will result in an exit code of 2, rather than 1.
+
+**To address:** If you have an integration that detects all problems with linting runs by checking whether the exit code is equal to 1, update it to check whether the exit code is nonzero instead.
+
+## <a name="non-enumerable-linter"></a> The `eslint.linter` property is now non-enumerable
+
+When using ESLint's Node.js API, the [`linter`](/docs/developer-guide/nodejs-api#linter-1) property is now non-enumerable. Note that the `linter` property was deprecated in ESLint v4 in favor of the [`Linter`](/docs/developer-guide/nodejs-api#linter) property.
+
+**To address:** If you rely on enumerating all the properties of the `eslint` object, use something like `Object.getOwnPropertyNames` to ensure that non-enumerable keys are captured.
diff --git a/lib/config/config-initializer.js b/lib/config/config-initializer.js
index e4865a008..3e99be9ec 100644
--- a/lib/config/config-initializer.js
+++ b/lib/config/config-initializer.js
@@ -270,7 +270,7 @@ function processAnswers(answers) {
         config.parserOptions.ecmaFeatures.jsx = true;
         if (answers.react) {
             config.plugins = ["react"];
-            config.parserOptions.ecmaFeatures.experimentalObjectRestSpread = true;
+            config.parserOptions.ecmaVersion = 2018;
         }
     }
 
diff --git a/package.json b/package.json
index 6bb7690c9..e381ef2fe 100644
--- a/package.json
+++ b/package.json
@@ -43,7 +43,7 @@
     "doctrine": "^2.1.0",
     "eslint-scope": "^3.7.1",
     "eslint-visitor-keys": "^1.0.0",
-    "espree": "^3.5.4",
+    "espree": "^4.0.0-alpha.0",
     "esquery": "^1.0.0",
     "esutils": "^2.0.2",
     "file-entry-cache": "^2.0.0",


Test patch:
diff --git a/tests/lib/config/config-initializer.js b/tests/lib/config/config-initializer.js
index 47f180fb1..e1a24dc36 100644
--- a/tests/lib/config/config-initializer.js
+++ b/tests/lib/config/config-initializer.js
@@ -170,7 +170,7 @@ describe("configInitializer", () => {
                 const config = init.processAnswers(answers);
 
                 assert.strictEqual(config.parserOptions.ecmaFeatures.jsx, true);
-                assert.strictEqual(config.parserOptions.ecmaFeatures.experimentalObjectRestSpread, true);
+                assert.strictEqual(config.parserOptions.ecmaVersion, 2018);
                 assert.deepStrictEqual(config.plugins, ["react"]);
             });
 
diff --git a/tests/lib/linter.js b/tests/lib/linter.js
index 80301cbc8..a64a6a55e 100644
--- a/tests/lib/linter.js
+++ b/tests/lib/linter.js
@@ -3255,14 +3255,11 @@ describe("Linter", () => {
             });
         });
 
-        it("should properly parse object spread when passed ecmaFeatures", () => {
+        it("should properly parse object spread when ecmaVersion is 2018", () => {
 
             const messages = linter.verify("var x = { ...y };", {
                 parserOptions: {
-                    ecmaVersion: 6,
-                    ecmaFeatures: {
-                        experimentalObjectRestSpread: true
-                    }
+                    ecmaVersion: 2018
                 }
             }, filename);
 
diff --git a/tests/lib/rules/comma-dangle.js b/tests/lib/rules/comma-dangle.js
index 0a8403ebc..7cd958231 100644
--- a/tests/lib/rules/comma-dangle.js
+++ b/tests/lib/rules/comma-dangle.js
@@ -129,11 +129,6 @@ ruleTester.run("comma-dangle", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/7297
-        {
-            code: "var {foo, ...bar} = baz",
-            options: ["always"],
-            parserOptions: { ecmaVersion: 8, ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var {foo, ...bar} = baz",
             options: ["always"],
diff --git a/tests/lib/rules/key-spacing.js b/tests/lib/rules/key-spacing.js
index 183c91eb0..2ed67e08e 100644
--- a/tests/lib/rules/key-spacing.js
+++ b/tests/lib/rules/key-spacing.js
@@ -312,78 +312,6 @@ ruleTester.run("key-spacing", rule, {
 
     // https://github.com/eslint/eslint/issues/4763
     {
-        code: "({a : foo, ...x, b : bar})['a'];",
-        options: [{
-            beforeColon: true,
-            afterColon: true
-        }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
-    }, {
-        code: [
-            "var obj = {",
-            "    'a'     : (42 - 12),",
-            "    ...x,",
-            "    foobar  : 'value',",
-            "    [(expr)]: val",
-            "};"
-        ].join("\n"),
-        options: [{
-            align: "colon"
-        }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
-    }, {
-        code: [
-            "callExpr(arg, {",
-            "    key       :val,",
-            "    ...x,",
-            "    ...y,",
-            "    'another' :false,",
-            "    [compute] :'value'",
-            "});"
-        ].join("\n"),
-        options: [{
-            align: "colon",
-            beforeColon: true,
-            afterColon: false
-        }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
-    }, {
-        code: [
-            "var obj = {",
-            "    a:        (42 - 12),",
-            "    ...x,",
-            "    'foobar': 'value',",
-            "    bat:      function() {",
-            "        return this.a;",
-            "    },",
-            "    baz: 42",
-            "};"
-        ].join("\n"),
-        options: [{
-            align: "value"
-        }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
-    }, {
-        code: [
-            "({",
-            "    ...x,",
-            "    a  : 0,",
-            "    // same group",
-            "    bcd: 0, /*",
-            "    end of group */",
-            "",
-            "    // different group",
-            "    e: 0,",
-            "    ...y,",
-            "    /* group b */",
-            "    f: 0",
-            "})"
-        ].join("\n"),
-        options: [{
-            align: "colon"
-        }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
-    }, {
         code: "({a : foo, ...x, b : bar})['a'];",
         options: [{
             beforeColon: true,
@@ -574,7 +502,7 @@ ruleTester.run("key-spacing", rule, {
         options: [{
             align: "colon"
         }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }
+        parserOptions: { ecmaVersion: 2018 }
     },
 
     // https://github.com/eslint/eslint/issues/5613
@@ -1359,43 +1287,6 @@ ruleTester.run("key-spacing", rule, {
 
     // https://github.com/eslint/eslint/issues/4763
     {
-        code: [
-            "({",
-            "    ...x,",
-            "    a : 0,",
-            "    // same group",
-            "    bcd: 0, /*",
-            "    end of group */",
-            "",
-            "    // different group",
-            "    e: 0,",
-            "    ...y,",
-            "    /* group b */",
-            "    f : 0",
-            "})"
-        ].join("\n"),
-        output: [
-            "({",
-            "    ...x,",
-            "    a  : 0,",
-            "    // same group",
-            "    bcd: 0, /*",
-            "    end of group */",
-            "",
-            "    // different group",
-            "    e: 0,",
-            "    ...y,",
-            "    /* group b */",
-            "    f: 0",
-            "})"
-        ].join("\n"),
-        options: [{ align: "colon" }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-        errors: [
-            { message: "Missing space after key 'a'.", line: 3, column: 5, type: "Identifier" },
-            { message: "Extra space after key 'f'.", line: 12, column: 5, type: "Identifier" }
-        ]
-    }, {
         code: [
             "({",
             "    ...x,",
@@ -1642,15 +1533,6 @@ ruleTester.run("key-spacing", rule, {
 
     // https://github.com/eslint/eslint/issues/5724
     {
-        code: "({ a:b, ...object, c : d })",
-        output: "({ a: b, ...object, c: d })",
-        options: [{ align: "colon" }],
-        parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-        errors: [
-            { message: "Missing space before value for key 'a'.", line: 1, column: 6, type: "Identifier" },
-            { message: "Extra space after key 'c'.", line: 1, column: 20, type: "Identifier" }
-        ]
-    }, {
         code: "({ a:b, ...object, c : d })",
         output: "({ a: b, ...object, c: d })",
         options: [{ align: "colon" }],
diff --git a/tests/lib/rules/no-dupe-keys.js b/tests/lib/rules/no-dupe-keys.js
index aeccfb4ce..76a6c7ec1 100644
--- a/tests/lib/rules/no-dupe-keys.js
+++ b/tests/lib/rules/no-dupe-keys.js
@@ -24,7 +24,6 @@ ruleTester.run("no-dupe-keys", rule, {
         "var x = { foo: 1, bar: 2 };",
         "+{ get a() { }, set a(b) { } };",
         { code: "var x = { a: b, [a]: b };", parserOptions: { ecmaVersion: 6 } },
-        { code: "var x = { a: b, ...c }", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var x = { a: b, ...c }", parserOptions: { ecmaVersion: 2018 } },
         { code: "var x = { get a() {}, set a (value) {} };", parserOptions: { ecmaVersion: 6 } },
         { code: "var x = { a: 1, b: { a: 2 } };", parserOptions: { ecmaVersion: 6 } },
diff --git a/tests/lib/rules/no-extra-parens.js b/tests/lib/rules/no-extra-parens.js
index 10d30ce2c..1738b1a66 100644
--- a/tests/lib/rules/no-extra-parens.js
+++ b/tests/lib/rules/no-extra-parens.js
@@ -408,13 +408,13 @@ ruleTester.run("no-extra-parens", rule, {
         "let a = { ...b }",
         {
             code: "let a = { ...b }",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
+            parserOptions: { ecmaVersion: 2018 }
         },
         "let a = [ ...(b, c) ]",
         "let a = { ...(b, c) }",
         {
             code: "let a = { ...(b, c) }",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
+            parserOptions: { ecmaVersion: 2018 }
         },
         "var [x = (1, foo)] = bar",
         "class A extends B {}",
@@ -964,7 +964,7 @@ ruleTester.run("no-extra-parens", rule, {
             "let a = {...b}",
             "Identifier",
             1,
-            { parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } }
+            { parserOptions: { ecmaVersion: 2018 } }
         ),
         invalid(
             "let a = [...((b, c))]",
@@ -983,7 +983,7 @@ ruleTester.run("no-extra-parens", rule, {
             "let a = {...(b, c)}",
             "SequenceExpression",
             1,
-            { parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } }
+            { parserOptions: { ecmaVersion: 2018 } }
         ),
         invalid(
             "class A extends (B) {}",
diff --git a/tests/lib/rules/no-self-assign.js b/tests/lib/rules/no-self-assign.js
index 553ac4602..6623f4c9d 100644
--- a/tests/lib/rules/no-self-assign.js
+++ b/tests/lib/rules/no-self-assign.js
@@ -39,7 +39,6 @@ ruleTester.run("no-self-assign", rule, {
         { code: "({a} = {a: b})", parserOptions: { ecmaVersion: 6 } },
         { code: "({a} = {a() {}})", parserOptions: { ecmaVersion: 6 } },
         { code: "({a} = {[a]: a})", parserOptions: { ecmaVersion: 6 } },
-        { code: "({a, ...b} = {a, ...b})", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "({a, ...b} = {a, ...b})", parserOptions: { ecmaVersion: 2018 } },
         { code: "a.b = a.c", options: [{ props: true }] },
         { code: "a.b = c.b", options: [{ props: true }] },
@@ -68,7 +67,6 @@ ruleTester.run("no-self-assign", rule, {
         { code: "({a, b} = {b, a})", parserOptions: { ecmaVersion: 6 }, errors: ["'b' is assigned to itself.", "'a' is assigned to itself."] },
         { code: "({a, b} = {c, a})", parserOptions: { ecmaVersion: 6 }, errors: ["'a' is assigned to itself."] },
         { code: "({a: {b}, c: [d]} = {a: {b}, c: [d]})", parserOptions: { ecmaVersion: 6 }, errors: ["'b' is assigned to itself.", "'d' is assigned to itself."] },
-        { code: "({a, b} = {a, ...x, b})", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } }, errors: ["'b' is assigned to itself."] },
         { code: "({a, b} = {a, ...x, b})", parserOptions: { ecmaVersion: 2018 }, errors: ["'b' is assigned to itself."] },
         { code: "a.b = a.b", options: [{ props: true }], errors: ["'a.b' is assigned to itself."] },
         { code: "a.b.c = a.b.c", options: [{ props: true }], errors: ["'a.b.c' is assigned to itself."] },
diff --git a/tests/lib/rules/no-undef.js b/tests/lib/rules/no-undef.js
index bf7e775a6..2372b87d5 100644
--- a/tests/lib/rules/no-undef.js
+++ b/tests/lib/rules/no-undef.js
@@ -72,16 +72,6 @@ ruleTester.run("no-undef", rule, {
         { code: "class A { constructor() { new.target; } }", parserOptions: { ecmaVersion: 6 } },
 
         // Experimental,
-        {
-            code: "var {bacon, ...others} = stuff; foo(others)",
-            parserOptions: {
-                ecmaVersion: 6,
-                ecmaFeatures: {
-                    experimentalObjectRestSpread: true
-                }
-            },
-            globals: { stuff: false, foo: false }
-        },
         {
             code: "var {bacon, ...others} = stuff; foo(others)",
             parserOptions: {
@@ -105,16 +95,6 @@ ruleTester.run("no-undef", rule, {
         { code: "[obj.a, obj.b] = [0, 1];", parserOptions: { ecmaVersion: 6 }, errors: [{ message: "'obj' is not defined." }, { message: "'obj' is not defined." }] },
 
         // Experimental
-        {
-            code: "const c = 0; const a = {...b, c};",
-            parserOptions: {
-                ecmaVersion: 6,
-                ecmaFeatures: {
-                    experimentalObjectRestSpread: true
-                }
-            },
-            errors: [{ message: "'b' is not defined." }]
-        },
         {
             code: "const c = 0; const a = {...b, c};",
             parserOptions: {
diff --git a/tests/lib/rules/no-unused-vars.js b/tests/lib/rules/no-unused-vars.js
index 5fd39ede7..3f529aa39 100644
--- a/tests/lib/rules/no-unused-vars.js
+++ b/tests/lib/rules/no-unused-vars.js
@@ -180,11 +180,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // Using object rest for variable omission
-        {
-            code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(coords);",
-            options: [{ ignoreRestSiblings: true }],
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(coords);",
             options: [{ ignoreRestSiblings: true }],
@@ -272,11 +267,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/8119
-        {
-            code: "(({a, ...rest}) => rest)",
-            options: [{ args: "all", ignoreRestSiblings: true }],
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "(({a, ...rest}) => rest)",
             options: [{ args: "all", ignoreRestSiblings: true }],
@@ -376,13 +366,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // Rest property sibling without ignoreRestSiblings
-        {
-            code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(coords);",
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                { line: 2, column: 9, message: "'type' is assigned a value but never used." }
-            ]
-        },
         {
             code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(coords);",
             parserOptions: { ecmaVersion: 2018 },
@@ -392,14 +375,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // Unused rest property with ignoreRestSiblings
-        {
-            code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(type)",
-            options: [{ ignoreRestSiblings: true }],
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                { line: 2, column: 18, message: "'coords' is assigned a value but never used." }
-            ]
-        },
         {
             code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(type)",
             options: [{ ignoreRestSiblings: true }],
@@ -410,13 +385,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // Unused rest property without ignoreRestSiblings
-        {
-            code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(type)",
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                { line: 2, column: 18, message: "'coords' is assigned a value but never used." }
-            ]
-        },
         {
             code: "const data = { type: 'coords', x: 1, y: 2 };\nconst { type, ...coords } = data;\n console.log(type)",
             parserOptions: { ecmaVersion: 2018 },
@@ -426,13 +394,6 @@ ruleTester.run("no-unused-vars", rule, {
         },
 
         // Nested array destructuring with rest property
-        {
-            code: "const data = { vars: ['x','y'], x: 1, y: 2 };\nconst { vars: [x], ...coords } = data;\n console.log(coords)",
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                { line: 2, column: 16, message: "'x' is assigned a value but never used." }
-            ]
-        },
         {
             code: "const data = { vars: ['x','y'], x: 1, y: 2 };\nconst { vars: [x], ...coords } = data;\n console.log(coords)",
             parserOptions: { ecmaVersion: 2018 },
@@ -444,19 +405,13 @@ ruleTester.run("no-unused-vars", rule, {
         // Nested object destructuring with rest property
         {
             code: "const data = { defaults: { x: 0 }, x: 1, y: 2 };\nconst { defaults: { x }, ...coords } = data;\n console.log(coords)",
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
+            parserOptions: { ecmaVersion: 2018 },
             errors: [
                 { line: 2, column: 21, message: "'x' is assigned a value but never used." }
             ]
         },
 
         // https://github.com/eslint/eslint/issues/8119
-        {
-            code: "(({a, ...rest}) => {})",
-            options: [{ args: "all", ignoreRestSiblings: true }],
-            parserOptions: { ecmaVersion: 2015, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: ["'rest' is defined but never used."]
-        },
         {
             code: "(({a, ...rest}) => {})",
             options: [{ args: "all", ignoreRestSiblings: true }],
diff --git a/tests/lib/rules/no-useless-rename.js b/tests/lib/rules/no-useless-rename.js
index 325ab3cef..2a864c06b 100644
--- a/tests/lib/rules/no-useless-rename.js
+++ b/tests/lib/rules/no-useless-rename.js
@@ -48,26 +48,14 @@ ruleTester.run("no-useless-rename", rule, {
         "export {foo as bar, baz as qux};",
         "export {foo as bar} from 'foo';",
         "export {foo as bar, baz as qux} from 'foo';",
-        {
-            code: "const {...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "const {...stuff} = myObject;",
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "const {foo, ...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "const {foo, ...stuff} = myObject;",
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "const {foo: bar, ...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "const {foo: bar, ...stuff} = myObject;",
             parserOptions: { ecmaVersion: 2018 }
@@ -234,36 +222,18 @@ ruleTester.run("no-useless-rename", rule, {
             output: "({foo, bar}) => {}",
             errors: ["Destructuring assignment foo unnecessarily renamed.", "Destructuring assignment bar unnecessarily renamed."]
         },
-        {
-            code: "const {foo: foo, ...stuff} = myObject;",
-            output: "const {foo, ...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: ["Destructuring assignment foo unnecessarily renamed."]
-        },
         {
             code: "const {foo: foo, ...stuff} = myObject;",
             output: "const {foo, ...stuff} = myObject;",
             parserOptions: { ecmaVersion: 2018 },
             errors: ["Destructuring assignment foo unnecessarily renamed."]
         },
-        {
-            code: "const {foo: foo, bar: baz, ...stuff} = myObject;",
-            output: "const {foo, bar: baz, ...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: ["Destructuring assignment foo unnecessarily renamed."]
-        },
         {
             code: "const {foo: foo, bar: baz, ...stuff} = myObject;",
             output: "const {foo, bar: baz, ...stuff} = myObject;",
             parserOptions: { ecmaVersion: 2018 },
             errors: ["Destructuring assignment foo unnecessarily renamed."]
         },
-        {
-            code: "const {foo: foo, bar: bar, ...stuff} = myObject;",
-            output: "const {foo, bar, ...stuff} = myObject;",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: ["Destructuring assignment foo unnecessarily renamed.", "Destructuring assignment bar unnecessarily renamed."]
-        },
         {
             code: "const {foo: foo, bar: bar, ...stuff} = myObject;",
             output: "const {foo, bar, ...stuff} = myObject;",
diff --git a/tests/lib/rules/object-property-newline.js b/tests/lib/rules/object-property-newline.js
index 6a6a2616c..28cc282ac 100644
--- a/tests/lib/rules/object-property-newline.js
+++ b/tests/lib/rules/object-property-newline.js
@@ -31,11 +31,8 @@ ruleTester.run("object-property-newline", rule, {
         "var obj = {\nk1: 'val1'\n};",
         "var obj = {};",
         { code: "var obj = {\n[bar]: 'baz',\nbaz\n};", parserOptions: { ecmaVersion: 6 } },
-        { code: "var obj = {\nk1: 'val1',\nk2: 'val2',\n...{}\n};", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = {\nk1: 'val1',\nk2: 'val2',\n...{}\n};", parserOptions: { ecmaVersion: 2018 } },
-        { code: "var obj = { k1: 'val1',\nk2: 'val2',\n...{} };", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = { k1: 'val1',\nk2: 'val2',\n...{} };", parserOptions: { ecmaVersion: 2018 } },
-        { code: "var obj = { ...{} };", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = { ...{} };", parserOptions: { ecmaVersion: 2018 } },
         "foo({ k1: 'val1',\nk2: 'val2' });",
         "foo({\nk1: 'val1',\nk2: 'val2'\n});",
@@ -43,11 +40,8 @@ ruleTester.run("object-property-newline", rule, {
         { code: "foo({\na,\nb,\n});", parserOptions: { ecmaVersion: 6 } },
         { code: "foo({\nbar() {},\nbaz\n});", parserOptions: { ecmaVersion: 6 } },
         { code: "foo({\n[bar]: 'baz',\nbaz \n})", parserOptions: { ecmaVersion: 6 } },
-        { code: "foo({\nk1: 'val1',\nk2: 'val2',\n...{}\n});", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "foo({\nk1: 'val1',\nk2: 'val2',\n...{}\n});", parserOptions: { ecmaVersion: 2018 } },
-        { code: "foo({ k1: 'val1',\nk2: 'val2',\n...{} });", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "foo({ k1: 'val1',\nk2: 'val2',\n...{} });", parserOptions: { ecmaVersion: 2018 } },
-        { code: "foo({ ...{} });", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "foo({ ...{} });", parserOptions: { ecmaVersion: 2018 } },
 
         // allowAllPropertiesOnSameLine: true
@@ -56,18 +50,14 @@ ruleTester.run("object-property-newline", rule, {
         { code: "var obj = { k1: 'val1' };", options: [{ allowAllPropertiesOnSameLine: true }] },
         { code: "var obj = {\nk1: 'val1'\n};", options: [{ allowAllPropertiesOnSameLine: true }] },
         { code: "var obj = {};", options: [{ allowAllPropertiesOnSameLine: true }] },
-        { code: "var obj = { 'k1': 'val1', k2: 'val2', ...{} };", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = { 'k1': 'val1', k2: 'val2', ...{} };", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 2018 } },
-        { code: "var obj = {\n'k1': 'val1', k2: 'val2', ...{}\n};", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = {\n'k1': 'val1', k2: 'val2', ...{}\n};", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 2018 } },
         { code: "foo({ k1: 'val1', k2: 'val2' });", options: [{ allowAllPropertiesOnSameLine: true }] },
         { code: "foo({\nk1: 'val1', k2: 'val2'\n});", options: [{ allowAllPropertiesOnSameLine: true }] },
         { code: "foo({ a, b });", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6 } },
         { code: "foo({ bar() {}, baz });", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6 } },
         { code: "foo({ [bar]: 'baz', baz })", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6 } },
-        { code: "foo({ 'k1': 'val1', k2: 'val2', ...{} });", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "foo({ 'k1': 'val1', k2: 'val2', ...{} });", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 2018 } },
-        { code: "foo({\n'k1': 'val1', k2: 'val2', ...{}\n});", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "foo({\n'k1': 'val1', k2: 'val2', ...{}\n});", options: [{ allowAllPropertiesOnSameLine: true }], parserOptions: { ecmaVersion: 2018 } },
         { code: "var obj = {k1: ['foo', 'bar'], k2: 'val1', k3: 'val2'};", options: [{ allowAllPropertiesOnSameLine: true }] },
         { code: "var obj = {\nk1: ['foo', 'bar'], k2: 'val1', k3: 'val2'\n};", options: [{ allowAllPropertiesOnSameLine: true }] },
@@ -213,19 +203,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "var obj = { k1: 'val1', ...{} };",
-            output: "var obj = { k1: 'val1',\n...{} };",
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line.",
-                    type: "ObjectExpression",
-                    line: 1,
-                    column: 25
-                }
-            ]
-        },
         {
             code: "var obj = { k1: 'val1', ...{} };",
             output: "var obj = { k1: 'val1',\n...{} };",
@@ -239,19 +216,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "var obj = {\nk1: 'val1', ...{}\n};",
-            output: "var obj = {\nk1: 'val1',\n...{}\n};",
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line.",
-                    type: "ObjectExpression",
-                    line: 2,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "var obj = {\nk1: 'val1', ...{}\n};",
             output: "var obj = {\nk1: 'val1',\n...{}\n};",
@@ -354,19 +318,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "foo({ k1: 'val1', ...{} })",
-            output: "foo({ k1: 'val1',\n...{} })",
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line.",
-                    type: "ObjectExpression",
-                    line: 1,
-                    column: 19
-                }
-            ]
-        },
         {
             code: "foo({ k1: 'val1', ...{} })",
             output: "foo({ k1: 'val1',\n...{} })",
@@ -380,19 +331,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "foo({\nk1: 'val1', ...{}\n})",
-            output: "foo({\nk1: 'val1',\n...{}\n})",
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line.",
-                    type: "ObjectExpression",
-                    line: 2,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "foo({\nk1: 'val1', ...{}\n})",
             output: "foo({\nk1: 'val1',\n...{}\n})",
@@ -548,20 +486,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "var obj = {\nk1: 'val1',\nk2: 'val2', ...{}\n};",
-            output: "var obj = {\nk1: 'val1',\nk2: 'val2',\n...{}\n};",
-            options: [{ allowAllPropertiesOnSameLine: true }],
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line if they aren't all on the same line.",
-                    type: "ObjectExpression",
-                    line: 3,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "var obj = {\nk1: 'val1',\nk2: 'val2', ...{}\n};",
             output: "var obj = {\nk1: 'val1',\nk2: 'val2',\n...{}\n};",
@@ -576,20 +500,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "var obj = {\n...{},\nk1: 'val1', k2: 'val2'\n};",
-            output: "var obj = {\n...{},\nk1: 'val1',\nk2: 'val2'\n};",
-            options: [{ allowAllPropertiesOnSameLine: true }],
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line if they aren't all on the same line.",
-                    type: "ObjectExpression",
-                    line: 3,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "var obj = {\n...{},\nk1: 'val1', k2: 'val2'\n};",
             output: "var obj = {\n...{},\nk1: 'val1',\nk2: 'val2'\n};",
@@ -618,20 +528,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "foo({\nk1: 'val1',\nk2: 'val2', ...{}\n})",
-            output: "foo({\nk1: 'val1',\nk2: 'val2',\n...{}\n})",
-            options: [{ allowAllPropertiesOnSameLine: true }],
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line if they aren't all on the same line.",
-                    type: "ObjectExpression",
-                    line: 3,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "foo({\nk1: 'val1',\nk2: 'val2', ...{}\n})",
             output: "foo({\nk1: 'val1',\nk2: 'val2',\n...{}\n})",
@@ -646,20 +542,6 @@ ruleTester.run("object-property-newline", rule, {
                 }
             ]
         },
-        {
-            code: "foo({\n...{},\nk1: 'val1', k2: 'val2'\n})",
-            output: "foo({\n...{},\nk1: 'val1',\nk2: 'val2'\n})",
-            options: [{ allowAllPropertiesOnSameLine: true }],
-            parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [
-                {
-                    message: "Object properties must go on a new line if they aren't all on the same line.",
-                    type: "ObjectExpression",
-                    line: 3,
-                    column: 13
-                }
-            ]
-        },
         {
             code: "foo({\n...{},\nk1: 'val1', k2: 'val2'\n})",
             output: "foo({\n...{},\nk1: 'val1',\nk2: 'val2'\n})",
diff --git a/tests/lib/rules/object-shorthand.js b/tests/lib/rules/object-shorthand.js
index e0b30b992..31abe8faa 100644
--- a/tests/lib/rules/object-shorthand.js
+++ b/tests/lib/rules/object-shorthand.js
@@ -171,11 +171,6 @@ ruleTester.run("object-shorthand", rule, {
             code: "let {a, b} = o;",
             options: ["never"]
         },
-        {
-            code: "var x = {foo: foo, bar: bar, ...baz}",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {foo: foo, bar: bar, ...baz}",
             options: ["never"],
@@ -199,41 +194,21 @@ ruleTester.run("object-shorthand", rule, {
             code: "var x = {a, b, get test() { return 1; }}",
             options: ["consistent"]
         },
-        {
-            code: "var x = {...bar}",
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {...bar}",
             options: ["consistent-as-needed"],
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "var x = {foo, bar, ...baz}",
-            options: ["consistent"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {foo, bar, ...baz}",
             options: ["consistent"],
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "var x = {bar: baz, ...qux}",
-            options: ["consistent"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {bar: baz, ...qux}",
             options: ["consistent"],
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "var x = {...foo, bar: bar, baz: baz}",
-            options: ["consistent"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {...foo, bar: bar, baz: baz}",
             options: ["consistent"],
@@ -273,31 +248,16 @@ ruleTester.run("object-shorthand", rule, {
             code: "var x = {[foo]: 'foo'}",
             options: ["consistent-as-needed"]
         },
-        {
-            code: "var x = {bar, ...baz}",
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {bar, ...baz}",
             options: ["consistent-as-needed"],
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "var x = {bar: baz, ...qux}",
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {bar: baz, ...qux}",
             options: ["consistent-as-needed"],
             parserOptions: { ecmaVersion: 2018 }
         },
-        {
-            code: "var x = {...foo, bar, baz}",
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "var x = {...foo, bar, baz}",
             options: ["consistent-as-needed"],
@@ -723,13 +683,6 @@ ruleTester.run("object-shorthand", rule, {
             options: ["never"],
             errors: [LONGFORM_METHOD_ERROR]
         },
-        {
-            code: "var x = {foo: foo, bar: baz, ...qux}",
-            output: "var x = {foo, bar: baz, ...qux}",
-            options: ["always"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [PROPERTY_ERROR]
-        },
         {
             code: "var x = {foo: foo, bar: baz, ...qux}",
             output: "var x = {foo, bar: baz, ...qux}",
@@ -737,13 +690,6 @@ ruleTester.run("object-shorthand", rule, {
             parserOptions: { ecmaVersion: 2018 },
             errors: [PROPERTY_ERROR]
         },
-        {
-            code: "var x = {foo, bar: baz, ...qux}",
-            output: "var x = {foo: foo, bar: baz, ...qux}",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [LONGFORM_PROPERTY_ERROR]
-        },
         {
             code: "var x = {foo, bar: baz, ...qux}",
             output: "var x = {foo: foo, bar: baz, ...qux}",
@@ -797,13 +743,6 @@ ruleTester.run("object-shorthand", rule, {
             options: ["consistent"],
             errors: [MIXED_SHORTHAND_ERROR]
         },
-        {
-            code: "var x = {foo, bar: baz, ...qux}",
-            output: null,
-            options: ["consistent"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [MIXED_SHORTHAND_ERROR]
-        },
         {
             code: "var x = {foo, bar: baz, ...qux}",
             output: null,
@@ -832,13 +771,6 @@ ruleTester.run("object-shorthand", rule, {
             options: ["consistent-as-needed"],
             errors: [ALL_SHORTHAND_ERROR]
         },
-        {
-            code: "var x = {a: a, b: b, ...baz}",
-            output: null,
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [ALL_SHORTHAND_ERROR]
-        },
         {
             code: "var x = {a: a, b: b, ...baz}",
             output: null,
@@ -846,13 +778,6 @@ ruleTester.run("object-shorthand", rule, {
             parserOptions: { ecmaVersion: 2018 },
             errors: [ALL_SHORTHAND_ERROR]
         },
-        {
-            code: "var x = {foo, bar: bar, ...qux}",
-            output: null,
-            options: ["consistent-as-needed"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [MIXED_SHORTHAND_ERROR]
-        },
         {
             code: "var x = {foo, bar: bar, ...qux}",
             output: null,
diff --git a/tests/lib/rules/prefer-const.js b/tests/lib/rules/prefer-const.js
index a86335c0d..85916648f 100644
--- a/tests/lib/rules/prefer-const.js
+++ b/tests/lib/rules/prefer-const.js
@@ -90,11 +90,6 @@ ruleTester.run("prefer-const", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/8187
-        {
-            code: "let { name, ...otherStuff } = obj; otherStuff = {};",
-            options: [{ destructuring: "all" }],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } }
-        },
         {
             code: "let { name, ...otherStuff } = obj; otherStuff = {};",
             options: [{ destructuring: "all" }],
@@ -309,13 +304,6 @@ ruleTester.run("prefer-const", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/8187
-        {
-            code: "let { name, ...otherStuff } = obj; otherStuff = {};",
-            output: null,
-            options: [{ destructuring: "any" }],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{ message: "'name' is never reassigned. Use 'const' instead.", type: "Identifier", column: 7 }]
-        },
         {
             code: "let { name, ...otherStuff } = obj; otherStuff = {};",
             output: null,
diff --git a/tests/lib/rules/quote-props.js b/tests/lib/rules/quote-props.js
index 9c87da607..6291960d3 100644
--- a/tests/lib/rules/quote-props.js
+++ b/tests/lib/rules/quote-props.js
@@ -71,11 +71,8 @@ ruleTester.run("quote-props", rule, {
         { code: "({'1': 1})", options: ["as-needed", { numbers: true }] },
         { code: "({1: 1, x: 2})", options: ["consistent", { numbers: true }] },
         { code: "({1: 1, x: 2})", options: ["consistent-as-needed", { numbers: true }] },
-        { code: "({ ...x })", options: ["as-needed"], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "({ ...x })", options: ["as-needed"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "({ ...x })", options: ["consistent"], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "({ ...x })", options: ["consistent"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "({ ...x })", options: ["consistent-as-needed"], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "({ ...x })", options: ["consistent-as-needed"], parserOptions: { ecmaVersion: 2018 } }
     ],
     invalid: [{
diff --git a/tests/lib/rules/rest-spread-spacing.js b/tests/lib/rules/rest-spread-spacing.js
index c7f28aa4a..a4f93ba88 100644
--- a/tests/lib/rules/rest-spread-spacing.js
+++ b/tests/lib/rules/rest-spread-spacing.js
@@ -35,29 +35,17 @@ ruleTester.run("rest-spread-spacing", rule, {
         { code: "let [a, b, ... arr] = [1, 2, 3, 4, 5];", options: ["always"] },
         { code: "let [a, b, ...\tarr] = [1, 2, 3, 4, 5];", options: ["always"] },
         { code: "let [a, b, ...\narr] = [1, 2, 3, 4, 5];", options: ["always"] },
-        { code: "let n = { x, y, ...z };", parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...z };", parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ...(z) };", parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...(z) };", parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ...( z ) };", parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...( z ) };", parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ...z };", options: ["never"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...z };", options: ["never"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ... z };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ... z };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ...\tz };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...\tz };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let n = { x, y, ...\nz };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let n = { x, y, ...\nz };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", parserOptions: { ecmaVersion: 2018 } },
-        { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["never"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["never"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
-        { code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } }
     ],
 
@@ -368,17 +356,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let n = { x, y, ... z };",
-            output: "let n = { x, y, ...z };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ... z };",
             output: "let n = { x, y, ...z };",
@@ -390,17 +367,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...\tz };",
-            output: "let n = { x, y, ...z };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...\tz };",
             output: "let n = { x, y, ...z };",
@@ -412,17 +378,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...\nz };",
-            output: "let n = { x, y, ...z };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...\nz };",
             output: "let n = { x, y, ...z };",
@@ -434,18 +389,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ... z };",
-            output: "let n = { x, y, ...z };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ... z };",
             output: "let n = { x, y, ...z };",
@@ -458,18 +401,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...\tz };",
-            output: "let n = { x, y, ...z };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...\tz };",
             output: "let n = { x, y, ...z };",
@@ -482,18 +413,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...\nz };",
-            output: "let n = { x, y, ...z };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...\nz };",
             output: "let n = { x, y, ...z };",
@@ -506,18 +425,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...z };",
-            output: "let n = { x, y, ... z };",
-            options: ["always"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Expected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...z };",
             output: "let n = { x, y, ... z };",
@@ -530,18 +437,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ... (z) };",
-            output: "let n = { x, y, ...(z) };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ... (z) };",
             output: "let n = { x, y, ...(z) };",
@@ -554,18 +449,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ... ( z ) };",
-            output: "let n = { x, y, ...( z ) };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Unexpected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ... ( z ) };",
             output: "let n = { x, y, ...( z ) };",
@@ -578,18 +461,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...(z) };",
-            output: "let n = { x, y, ... (z) };",
-            options: ["always"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Expected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...(z) };",
             output: "let n = { x, y, ... (z) };",
@@ -602,18 +473,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let n = { x, y, ...( z ) };",
-            output: "let n = { x, y, ... ( z ) };",
-            options: ["always"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 20,
-                message: "Expected whitespace after spread property operator.",
-                type: "ExperimentalSpreadProperty"
-            }]
-        },
         {
             code: "let n = { x, y, ...( z ) };",
             output: "let n = { x, y, ... ( z ) };",
@@ -626,17 +485,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "SpreadElement"
             }]
         },
-        {
-            code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -648,17 +496,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -670,17 +507,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -692,18 +518,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -716,18 +530,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -740,18 +542,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            options: ["never"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Unexpected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
@@ -764,18 +554,6 @@ ruleTester.run("rest-spread-spacing", rule, {
                 type: "RestElement"
             }]
         },
-        {
-            code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
-            output: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
-            options: ["always"],
-            parserOptions: { ecmaFeatures: { experimentalObjectRestSpread: true } },
-            errors: [{
-                line: 1,
-                column: 16,
-                message: "Expected whitespace after rest property operator.",
-                type: "ExperimentalRestProperty"
-            }]
-        },
         {
             code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
             output: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
diff --git a/tests/lib/rules/sort-keys.js b/tests/lib/rules/sort-keys.js
index 2a94850a0..c7cf8ecf4 100644
--- a/tests/lib/rules/sort-keys.js
+++ b/tests/lib/rules/sort-keys.js
@@ -34,7 +34,6 @@ ruleTester.run("sort-keys", rule, {
         { code: "var obj = {a:1, b:3, [a + b]: -1, c:2}", options: [], parserOptions: { ecmaVersion: 6 } },
 
         // ignore spread properties.
-        { code: "var obj = {a:1, ...z, b:1}", options: [], parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = {a:1, ...z, b:1}", options: [], parserOptions: { ecmaVersion: 2018 } },
 
         // ignore destructuring patterns.
@@ -159,16 +158,6 @@ ruleTester.run("sort-keys", rule, {
         },
 
         // ignore spred properties.
-        {
-            code: "var obj = {b:1, ...z, a:1}",
-            parserOptions: {
-                ecmaVersion: 6,
-                ecmaFeatures: { experimentalObjectRestSpread: true }
-            },
-            errors: [
-                "Expected object keys to be in ascending order. 'a' should be before 'b'."
-            ]
-        },
         {
             code: "var obj = {b:1, ...z, a:1}",
             parserOptions: {