Breaking: add ES2016/2017 features to no-unsupported-features (fixes #46)

Author: mysticatea

docs/rules/no-unsupported-features.md

@@ -1,31 +1,38 @@
 # Disallow unsupported ECMAScript features on the specified version (no-unsupported-features)
 
-Node.js v0.12, v4, and v5 don't support all ECMAScript 2015 (ES6) features.
-This rule reports when you used unsupported ECMAScript 2015 features on the specified Node version.
+Node.js doesn't support all ECMAScript standard features.
+This rule reports when you used unsupported ECMAScript 2015-2017 features on the specified Node.js version.
 
-## Rule Details
+> ※ About ECMAScript 2017, this rule reports only features which have arrived at stage 4 until 2016-10-31.
+> It needs a major version bump in order to cover newer features.
 
-**This rule expects to be used with `"env": {"es6": true}` configuration.**
+## Rule Details
 
-This rule requires a Node version.
-For Example:
+:warning: This rule expects to be used with the following configuration:
 
 ```json
 {
-    "node/no-unsupported-features": ["error", {"version": 4}]
+    "env": {"es6": true},
+    "parserOptions": {"ecmaVersion": 2017}
 }
 ```
 
-This rule accepts the following version number:
+:warning: This rule reads the [engines] field of `package.json` to detect Node.js version.
 
-- `0.10`
-- `0.12`
-- `4`
-- `5`
-- `6`
+I recommend a use of the [engines] field since it's the official way to indicate what Node.js versions your module is supporting.
+For example of `package.json`:
+
+```json
+{
+    "name": "your-module",
+    "version": "1.0.0",
+    "engines": {
+        "node": ">=4.0.0"
+    }
+}
+```
 
-If the version was omitted, this rule will read the [engines](https://docs.npmjs.com/files/package.json#engines) field of `package.json`.
-If both the `version` option and the `engines` field don't exist, this rule will use the minimum version Node community is maintaining (It's `0.10` currently).
+If the [engines] field is omitted, this rule chooses `0.12` since it's the minimum version the community is maintaining.
 
 Examples of :-1: **incorrect** code for this rule:
 
@@ -98,16 +105,33 @@ var p = new Promise((resolve, reject) => {
 
 ## Options
 
-This rule has `"ignores"` option to ignore to use the specified features.
-
 ```json
 {
-    "node/no-unsupported-features": ["error", {"version": 4, "ignores": []}]
+    "node/no-unsupported-features": ["error", {
+        "version": 4,
+        "ignores": []
+    }]
 }
 ```
 
-Features which are specified by this `"ignores"` option are not warned.
-This `"ignores"` option accepts an array of the following strings.
+### version
+
+As mentioned above, this rule reads the [engines] field of `package.json` to detect Node.js version.
+Also, you can overwrite the version by `version` option.
+The `version` option accepts the following version number:
+
+- `0.10`
+- `0.12`
+- `4`
+- `5`
+- `6`
+- `7`
+
+### ignores
+
+If you are using transpilers, maybe you want to ignore the warnings about some features.
+You can use this `ignores` option to ignore the given features.
+The `"ignores"` option accepts an array of the following strings.
 
 - `"syntax"` (group)
   - `"defaultParameters"`
@@ -130,6 +154,9 @@ This `"ignores"` option accepts an array of the following strings.
   - `"generatorFunctions"`
   - `"classes"`
   - `"modules"`
+  - `"exponentialOperators"`
+  - `"asyncAwait"`
+  - `"trailingCommasInFunctionSyntax"`
 - `"runtime"` (group)
   - `"globalObjects"` (group)
     - `"typedArrays"` (group)
@@ -157,6 +184,9 @@ This `"ignores"` option accepts an array of the following strings.
       - `"Object.is"`
       - `"Object.getOwnPropertySymbols"`
       - `"Object.setPrototypeOf"`
+      - `"Object.values"`
+      - `"Object.entries"`
+      - `"Object.getOwnPropertyDescriptors"`
     - `"String.*"` (group)
       - `"String.raw"`
       - `"String.fromCodePoint"`
@@ -211,6 +241,7 @@ This `"ignores"` option accepts an array of the following strings.
     - `"extendsString"`
     - `"extendsMap"`
     - `"extendsSet"`
+    - `"extendsNull"`
 
 If a group value is given, all sub items of the value are ignored.
 e.g. if `"String.*"` is given then `"String.raw"` and `"String.fromCodePoint"` are ignored.
@@ -226,7 +257,14 @@ function foo(a = 1) {
 }
 ```
 
+## Known Limitations
+
+This rule cannot report non-static things.
+E.g., a use of instance methods.
+
 ## Further Reading
 
 - http://node.green/
 - http://kangax.github.io/compat-table/es6/
+
+[engines]: https://docs.npmjs.com/files/package.json#engines

lib/rules/no-unsupported-features.js

@@ -18,7 +18,7 @@ var getValueIfString = require("../util/get-value-if-string")
 // Helpers
 //------------------------------------------------------------------------------
 
-var VERSIONS = [0.10, 0.12, 4, 5, 6]
+var VERSIONS = [0.10, 0.12, 4, 5, 6, 7]
 var OPTIONS = Object.keys(features)
 var FUNC_TYPE = /^(?:Arrow)?Function(?:Declaration|Expression)$/
 var CLASS_TYPE = /^Class(?:Declaration|Expression)$/
@@ -37,7 +37,10 @@ var SUBCLASSING_TEST_TARGETS = [
     "Map", "Set",
 ]
 var PROPERTY_TEST_TARGETS = {
-    Object: ["assign", "is", "getOwnPropertySymbols", "setPrototypeOf"],
+    Object: [
+        "assign", "is", "getOwnPropertySymbols", "setPrototypeOf", "values",
+        "entries", "getOwnPropertyDescriptors",
+    ],
     String: ["raw", "fromCodePoint"],
     Array: ["from", "of"],
     Number: [
@@ -294,6 +297,48 @@ module.exports = function(context) {
         return scope.isStrict
     }
 
+    /**
+     * Checks whether the given function has trailing commas or not.
+     *
+     * @param {ASTNode} node - The function node to check.
+     * @returns {boolean} `true` if the function has trailing commas.
+     */
+    function hasTrailingCommaForFunction(node) {
+        var length = node.params.length
+
+        return (
+            length >= 1 &&
+            sourceCode.getTokenAfter(node.params[length - 1]).value === ","
+        )
+    }
+
+    /**
+     * Checks whether the given call expression has trailing commas or not.
+     *
+     * @param {ASTNode} node - The call expression node to check.
+     * @returns {boolean} `true` if the call expression has trailing commas.
+     */
+    function hasTrailingCommaForCall(node) {
+        return (
+            node.arguments.length >= 1 &&
+            sourceCode.getLastToken(node, 1).value === ","
+        )
+    }
+
+    /**
+     * Checks whether the given class extends from null or not.
+     *
+     * @param {ASTNode} node - The class node to check.
+     * @returns {boolean} `true` if the class extends from null.
+     */
+    function extendsNull(node) {
+        return (
+            node.superClass != null &&
+            node.superClass.type === "Literal" &&
+            node.superClass.value === null
+        )
+    }
+
     /**
      * Reports a given node if the specified feature is not supported.
      *
@@ -387,6 +432,12 @@ module.exports = function(context) {
 
         "ArrowFunctionExpression": function(node) {
             report(node, "arrowFunctions")
+            if (node.async) {
+                report(node, "asyncAwait")
+            }
+            if (hasTrailingCommaForFunction(node)) {
+                report(node, "trailingCommasInFunctionSyntax")
+            }
         },
 
         "AssignmentPattern": function(node) {
@@ -403,12 +454,24 @@ module.exports = function(context) {
             if (node.generator) {
                 report(node, "generatorFunctions")
             }
+            if (node.async) {
+                report(node, "asyncAwait")
+            }
+            if (hasTrailingCommaForFunction(node)) {
+                report(node, "trailingCommasInFunctionSyntax")
+            }
         },
 
         "FunctionExpression": function(node) {
             if (node.generator) {
                 report(node, "generatorFunctions")
             }
+            if (node.async) {
+                report(node, "asyncAwait")
+            }
+            if (hasTrailingCommaForFunction(node)) {
+                report(node, "trailingCommasInFunctionSyntax")
+            }
         },
 
         "MetaProperty": function(node) {
@@ -431,10 +494,18 @@ module.exports = function(context) {
 
         "ClassDeclaration": function(node) {
             report(node, "classes")
+
+            if (extendsNull(node)) {
+                report(node, "extendsNull")
+            }
         },
 
         "ClassExpression": function(node) {
             report(node, "classes")
+
+            if (extendsNull(node)) {
+                report(node, "extendsNull")
+            }
         },
 
         //----------------------------------------------------------------------
@@ -464,6 +535,28 @@ module.exports = function(context) {
             }
         },
 
+        "AssignmentExpression": function(node) {
+            if (node.operator === "**=") {
+                report(node, "exponentialOperators")
+            }
+        },
+
+        "AwaitExpression": function(node) {
+            report(node, "asyncAwait")
+        },
+
+        "BinaryExpression": function(node) {
+            if (node.operator === "**") {
+                report(node, "exponentialOperators")
+            }
+        },
+
+        "CallExpression": function(node) {
+            if (hasTrailingCommaForCall(node)) {
+                report(node, "trailingCommasInFunctionSyntax")
+            }
+        },
+
         "Identifier": function(node) {
             var raw = sourceCode.getText(node)
             if (hasUnicodeCodePointEscape(raw)) {
@@ -509,6 +602,9 @@ module.exports = function(context) {
                     report(node, "regexpU")
                 }
             }
+            if (hasTrailingCommaForCall(node)) {
+                report(node, "trailingCommasInFunctionSyntax")
+            }
         },
 
         "ObjectPattern": function(node) {
@@ -563,7 +659,7 @@ module.exports = function(context) {
 module.exports.schema = [
     {
         oneOf: [
-        {enum: VERSIONS},
+            {enum: VERSIONS},
             {
                 type: "object",
                 properties: {
@@ -575,7 +671,6 @@ module.exports.schema = [
                     },
                 },
                 additionalProperties: false,
-                required: ["version"],
             },
         ],
     },

lib/util/features.js

@@ -129,7 +129,22 @@ module.exports = {
     "modules": {
         alias: ["syntax"],
         name: "Import and Export Declarations",
-        node: 6,
+        node: NaN,
+    },
+    "exponentialOperators": {
+        alias: ["syntax"],
+        name: "Exponential Operators (**)",
+        node: 7,
+    },
+    "asyncAwait": {
+        alias: ["syntax"],
+        name: "Async Functions",
+        node: NaN,
+    },
+    "trailingCommasInFunctionSyntax": {
+        alias: ["syntax"],
+        name: "Trailing Commas in Function Syntax",
+        node: NaN,
     },
 
     //--------------------------------------------------------------------------
@@ -269,6 +284,24 @@ module.exports = {
         singular: true,
         node: 0.12,
     },
+    "Object.values": {
+        alias: ["runtime", "staticMethods", "Object.*"],
+        name: "'Object.values'",
+        singular: true,
+        node: 7,
+    },
+    "Object.entries": {
+        alias: ["runtime", "staticMethods", "Object.*"],
+        name: "'Object.entries'",
+        singular: true,
+        node: 7,
+    },
+    "Object.getOwnPropertyDescriptors": {
+        alias: ["runtime", "staticMethods", "Object.*"],
+        name: "'Object.getOwnPropertyDescriptors'",
+        singular: true,
+        node: 7,
+    },
 
     "String.raw": {
         alias: ["runtime", "staticMethods", "String.*"],
@@ -563,4 +596,10 @@ module.exports = {
         singular: true,
         node: 4,
     },
+    "extendsNull": {
+        alias: ["runtime", "extends"],
+        name: "'extends null'",
+        singular: true,
+        node: NaN,
+    },
 }