add es2021 #33

README.md

@@ -30,6 +30,7 @@ It doesn't check browser/runtime-specific APIs (see [eslint-plugin-compat](https
 
 ## ECMAScript version coverage
 
+- ✅ [ES2021](https://v8.dev/features/tags/es2021)
 - ✅ [ES2020](https://v8.dev/features/tags/es2020)
 - ✅ [ES2019](https://flaviocopes.com/es2019)<sup>1, 2</sup>
 - ✅ [ES2018](https://flaviocopes.com/es2018)

packages/eslint-plugin-ecmascript-compat-example/.eslintrc.json

@@ -1,8 +1,8 @@
 {
   "root": true,
   "plugins": ["ecmascript-compat"],
-  "parserOptions": { "ecmaVersion": 2020 },
-  "env": { "es2020": true },
+  "parserOptions": { "ecmaVersion": 2021 },
+  "env": { "es2021": true },
   "rules": {
     "ecmascript-compat/compat": "error"
   }

packages/eslint-plugin-ecmascript-compat-example/src/app.js

@@ -1,3 +1,21 @@
+/**
+ * ES2021
+ */
+foo = {};
+foo.replaceAll; // no error
+
+String.prototype.replaceAll;
+
+foo = foo &&= null;
+foo = foo ??= '';
+foo = foo ||= {};
+
+Promise.any();
+
+foo = 1_000_000_00;
+foo = new WeakRef();
+foo = new FinalizationRegistry(() => {});
+
 /**
  * ES2020 (all implemented, but these examples not complete)
  */

packages/eslint-plugin-ecmascript-compat/lib/features/es-versions.md

@@ -6,6 +6,16 @@ Static detectability of recently-added features
 - 😐 = statically detectable, but chance of false positives
 - 👎 = statically detectable, but not worth the false positives
 
+### ES2021
+
+| Name                                 | ESLint / eslint-plugin-es          | Chrome since |
+| ------------------------------------ | ---------------------------------- | ------------ |
+| Logical Assignment \|\|=, \&\&=, ??= | es/no-logical-assignment-operators | 85           |
+| Numeric separators                   | es/no-numeric-separators           | 75           |
+| `Promise.any`                        | es/no-promise-any                  | 85           |
+| `String.prototype.replaceAll`        | 😐 no-restricted-properties        | 85           |
+| `WeakRef and FinalizationRegistry`   | es/no-weakrefs                     | 84           |
+
 ### ES2020
 
 | Name                        | ESLint / eslint-plugin-es          | Chrome since |

packages/eslint-plugin-ecmascript-compat/lib/features/es2021.js

@@ -0,0 +1,39 @@
+const eslint = require('eslint');
+const compatData = require('@mdn/browser-compat-data');
+const esPlugin = require('eslint-plugin-es');
+const { noRestrictedSyntaxPrototypeMethod } = require('./ruleOptionsUtil');
+
+const coreRules = new eslint.Linter().getRules();
+
+module.exports = [
+  {
+    ruleConfig: {
+      definition: coreRules.get('no-restricted-syntax'),
+      options: noRestrictedSyntaxPrototypeMethod('String.prototype.replaceAll', 'ES2021'),
+    },
+    compatFeatures: [compatData.javascript.builtins.String.replaceAll],
+  },
+  {
+    ruleConfig: { definition: esPlugin.rules['no-logical-assignment-operators'] },
+    compatFeatures: [
+      compatData.javascript.operators.logical_or_assignment,
+      compatData.javascript.operators.logical_and_assignment,
+      compatData.javascript.operators.logical_nullish_assignment,
+    ],
+  },
+  {
+    ruleConfig: { definition: esPlugin.rules['no-numeric-separators'] },
+    compatFeatures: [compatData.javascript.grammar.numeric_separators],
+  },
+  {
+    ruleConfig: { definition: esPlugin.rules['no-promise-any'] },
+    compatFeatures: [compatData.javascript.builtins.Promise.any],
+  },
+  {
+    ruleConfig: { definition: esPlugin.rules['no-weakrefs'] },
+    compatFeatures: [
+      compatData.javascript.builtins.WeakRef,
+      compatData.javascript.builtins.FinalizationRegistry,
+    ],
+  },
+];

packages/eslint-plugin-ecmascript-compat/lib/features/es2021.spec.js

@@ -0,0 +1,56 @@
+const { RuleTester } = require('eslint');
+
+// Browser that doesn't support any features of this version - see es-versions.md
+process.env.BROWSERSLIST = 'Chrome >= 74';
+jest.resetModules();
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2021,
+  },
+  globals: {
+    // ES2021 global, required by es/no-weakrefs
+    WeakRef: 'readonly',
+    FinalizationRegistry: 'readonly',
+    // ES6 global, required by es/no-promise-all-settled
+    Promise: 'readonly',
+  },
+});
+
+ruleTester.run('compat', require('../rule'), {
+  valid: [],
+  invalid: [
+    {
+      code: '"A dog".replaceAll("dog", "monkey");',
+      errors: [{ message: "ES2021 method 'String.prototype.replaceAll' is forbidden" }],
+    },
+    {
+      code: 'a ||= 1;',
+      errors: [{ message: 'ES2021 logical assignment operators are forbidden.' }],
+    },
+    {
+      code: 'a &&= 1;',
+      errors: [{ message: 'ES2021 logical assignment operators are forbidden.' }],
+    },
+    {
+      code: 'a ??= 1;',
+      errors: [{ message: 'ES2021 logical assignment operators are forbidden.' }],
+    },
+    {
+      code: 'const a = 1_000_00;',
+      errors: [{ message: 'ES2021 numeric separators are forbidden.' }],
+    },
+    {
+      code: 'const a = Promise.any([]);',
+      errors: [{ message: "ES2021 'Promise.any' is forbidden." }],
+    },
+    {
+      code: 'const a = new WeakRef();',
+      errors: [{ message: "ES2021 'WeakRef' class is forbidden." }],
+    },
+    {
+      code: 'const a = new FinalizationRegistry(() => {});',
+      errors: [{ message: "ES2021 'FinalizationRegistry' class is forbidden." }],
+    },
+  ],
+});

packages/eslint-plugin-ecmascript-compat/lib/features/index.js

@@ -4,4 +4,5 @@ module.exports = [
   ...require('./es2018'),
   ...require('./es2019'),
   ...require('./es2020'),
+  ...require('./es2021'),
 ];