eslint 7.0.0-alpha.1 → 7.0.0

package/lib/rules/curly.js

@@ -141,33 +141,14 @@ module.exports = {
         }
 
         /**
-         * Checks a given IfStatement node requires braces of the consequent chunk.
-         * This returns `true` when below:
-         *
-         * 1. The given node has the `alternate` node.
-         * 2. There is a `IfStatement` which doesn't have `alternate` node in the
-         *    trailing statement chain of the `consequent` node.
-         * @param {ASTNode} node A IfStatement node to check.
-         * @returns {boolean} `true` if the node requires braces of the consequent chunk.
+         * Determines whether the given node has an `else` keyword token as the first token after.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} `true` if the node is followed by an `else` keyword token.
          */
-        function requiresBraceOfConsequent(node) {
-            if (node.alternate && node.consequent.type === "BlockStatement") {
-                if (node.consequent.body.length >= 2) {
-                    return true;
-                }
-
-                for (
-                    let currentNode = node.consequent.body[0];
-                    currentNode;
-                    currentNode = astUtils.getTrailingStatement(currentNode)
-                ) {
-                    if (currentNode.type === "IfStatement" && !currentNode.alternate) {
-                        return true;
-                    }
-                }
-            }
+        function isFollowedByElseKeyword(node) {
+            const nextToken = sourceCode.getTokenAfter(node);
 
-            return false;
+            return Boolean(nextToken) && isElseKeywordToken(nextToken);
         }
 
         /**
@@ -224,6 +205,110 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Determines whether the code represented by the given node contains an `if` statement
+         * that would become associated with an `else` keyword directly appended to that code.
+         *
+         * Examples where it returns `true`:
+         *
+         *    if (a)
+         *        foo();
+         *
+         *    if (a) {
+         *        foo();
+         *    }
+         *
+         *    if (a)
+         *        foo();
+         *    else if (b)
+         *        bar();
+         *
+         *    while (a)
+         *        if (b)
+         *            if(c)
+         *                foo();
+         *            else
+         *                bar();
+         *
+         * Examples where it returns `false`:
+         *
+         *    if (a)
+         *        foo();
+         *    else
+         *        bar();
+         *
+         *    while (a) {
+         *        if (b)
+         *            if(c)
+         *                foo();
+         *            else
+         *                bar();
+         *    }
+         *
+         *    while (a)
+         *        if (b) {
+         *            if(c)
+         *                foo();
+         *        }
+         *        else
+         *            bar();
+         * @param {ASTNode} node Node representing the code to check.
+         * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code.
+         */
+        function hasUnsafeIf(node) {
+            switch (node.type) {
+                case "IfStatement":
+                    if (!node.alternate) {
+                        return true;
+                    }
+                    return hasUnsafeIf(node.alternate);
+                case "ForStatement":
+                case "ForInStatement":
+                case "ForOfStatement":
+                case "LabeledStatement":
+                case "WithStatement":
+                case "WhileStatement":
+                    return hasUnsafeIf(node.body);
+                default:
+                    return false;
+            }
+        }
+
+        /**
+         * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
+         * The braces, which make the given block body, are necessary in either of the following situations:
+         *
+         * 1. The statement is a lexical declaration.
+         * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace:
+         *
+         *     if (a) {
+         *         if (b)
+         *             foo();
+         *     }
+         *     else
+         *         bar();
+         *
+         *     if (a)
+         *         while (b)
+         *             while (c) {
+         *                 while (d)
+         *                     if (e)
+         *                         while(f)
+         *                             foo();
+         *            }
+         *     else
+         *         bar();
+         * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements.
+         * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content)
+         * would change the semantics of the code or produce a syntax error.
+         */
+        function areBracesNecessary(node) {
+            const statement = node.body[0];
+
+            return isLexicalDeclaration(statement) ||
+                hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
+        }
+
         /**
          * Prepares to check the body of a node to see if it's a block statement.
          * @param {ASTNode} node The node to report if there's a problem.
@@ -242,30 +327,29 @@ module.exports = {
             const hasBlock = (body.type === "BlockStatement");
             let expected = null;
 
-            if (node.type === "IfStatement" && node.consequent === body && requiresBraceOfConsequent(node)) {
+            if (hasBlock && (body.body.length !== 1 || areBracesNecessary(body))) {
                 expected = true;
             } else if (multiOnly) {
-                if (hasBlock && body.body.length === 1 && !isLexicalDeclaration(body.body[0])) {
-                    expected = false;
-                }
+                expected = false;
             } else if (multiLine) {
                 if (!isCollapsedOneLiner(body)) {
                     expected = true;
                 }
+
+                // otherwise, the body is allowed to have braces or not to have braces
+
             } else if (multiOrNest) {
-                if (hasBlock && body.body.length === 1 && isOneLiner(body.body[0])) {
-                    const leadingComments = sourceCode.getCommentsBefore(body.body[0]);
-                    const isLexDef = isLexicalDeclaration(body.body[0]);
-
-                    if (isLexDef) {
-                        expected = true;
-                    } else {
-                        expected = leadingComments.length > 0;
-                    }
-                } else if (!isOneLiner(body)) {
-                    expected = true;
+                if (hasBlock) {
+                    const statement = body.body[0];
+                    const leadingCommentsInBlock = sourceCode.getCommentsBefore(statement);
+
+                    expected = !isOneLiner(statement) || leadingCommentsInBlock.length > 0;
+                } else {
+                    expected = !isOneLiner(body);
                 }
             } else {
+
+                // default "all"
                 expected = true;
             }
 

package/lib/rules/func-call-spacing.js

@@ -63,7 +63,8 @@ module.exports = {
         },
 
         messages: {
-            unexpected: "Unexpected newline between function name and paren.",
+            unexpectedWhitespace: "Unexpected whitespace between function name and paren.",
+            unexpectedNewline: "Unexpected newline between function name and paren.",
             missing: "Missing space between function name and paren."
         }
     },
@@ -116,7 +117,7 @@ module.exports = {
                 context.report({
                     node,
                     loc: leftToken.loc.start,
-                    messageId: "unexpected",
+                    messageId: "unexpectedWhitespace",
                     fix(fixer) {
 
                         /*
@@ -143,7 +144,7 @@ module.exports = {
                 context.report({
                     node,
                     loc: leftToken.loc.start,
-                    messageId: "unexpected",
+                    messageId: "unexpectedNewline",
                     fix(fixer) {
                         return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ");
                     }

package/lib/rules/func-names.js

@@ -119,8 +119,7 @@ module.exports = {
                 (parent.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.init === node) ||
                 (parent.type === "Property" && parent.value === node) ||
                 (parent.type === "AssignmentExpression" && parent.left.type === "Identifier" && parent.right === node) ||
-                (parent.type === "ExportDefaultDeclaration" && parent.declaration === node) ||
-                (parent.type === "AssignmentPattern" && parent.right === node);
+                (parent.type === "AssignmentPattern" && parent.left.type === "Identifier" && parent.right === node);
         }
 
         /**
@@ -151,33 +150,41 @@ module.exports = {
             });
         }
 
-        return {
-            "FunctionExpression:exit"(node) {
+        /**
+         * The listener for function nodes.
+         * @param {ASTNode} node function node
+         * @returns {void}
+         */
+        function handleFunction(node) {
 
-                // Skip recursive functions.
-                const nameVar = context.getDeclaredVariables(node)[0];
+            // Skip recursive functions.
+            const nameVar = context.getDeclaredVariables(node)[0];
 
-                if (isFunctionName(nameVar) && nameVar.references.length > 0) {
-                    return;
-                }
+            if (isFunctionName(nameVar) && nameVar.references.length > 0) {
+                return;
+            }
 
-                const hasName = Boolean(node.id && node.id.name);
-                const config = getConfigForNode(node);
-
-                if (config === "never") {
-                    if (hasName) {
-                        reportUnexpectedNamedFunction(node);
-                    }
-                } else if (config === "as-needed") {
-                    if (!hasName && !hasInferredName(node)) {
-                        reportUnexpectedUnnamedFunction(node);
-                    }
-                } else {
-                    if (!hasName && !isObjectOrClassMethod(node)) {
-                        reportUnexpectedUnnamedFunction(node);
-                    }
+            const hasName = Boolean(node.id && node.id.name);
+            const config = getConfigForNode(node);
+
+            if (config === "never") {
+                if (hasName && node.type !== "FunctionDeclaration") {
+                    reportUnexpectedNamedFunction(node);
+                }
+            } else if (config === "as-needed") {
+                if (!hasName && !hasInferredName(node)) {
+                    reportUnexpectedUnnamedFunction(node);
+                }
+            } else {
+                if (!hasName && !isObjectOrClassMethod(node)) {
+                    reportUnexpectedUnnamedFunction(node);
                 }
             }
+        }
+
+        return {
+            "FunctionExpression:exit": handleFunction,
+            "ExportDefaultDeclaration > FunctionDeclaration": handleFunction
         };
     }
 };

package/lib/rules/getter-return.js

@@ -25,17 +25,6 @@ function isReachable(segment) {
     return segment.reachable;
 }
 
-/**
- * Gets a readable location.
- *
- * - FunctionExpression -> the function name or `function` keyword.
- * @param {ASTNode} node A function node to get.
- * @returns {ASTNode|Token} The node or the token of a location.
- */
-function getId(node) {
-    return node.id || node;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -75,6 +64,7 @@ module.exports = {
     create(context) {
 
         const options = context.options[0] || { allowImplicit: false };
+        const sourceCode = context.getSourceCode();
 
         let funcInfo = {
             upper: null,
@@ -99,7 +89,7 @@ module.exports = {
             ) {
                 context.report({
                     node,
-                    loc: getId(node).loc.start,
+                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                     messageId: funcInfo.hasReturn ? "expectedAlways" : "expected",
                     data: {
                         name: astUtils.getFunctionNameWithKind(funcInfo.node)

package/lib/rules/global-require.js

@@ -48,6 +48,10 @@ function isShadowed(scope, node) {
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/global-require"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/handle-callback-err.js

@@ -11,6 +11,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/handle-callback-err"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/id-blacklist.js

@@ -6,6 +6,105 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether the given node represents assignment target in a normal assignment or destructuring.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is assignment target.
+ */
+function isAssignmentTarget(node) {
+    const parent = node.parent;
+
+    return (
+
+        // normal assignment
+        (
+            parent.type === "AssignmentExpression" &&
+            parent.left === node
+        ) ||
+
+        // destructuring
+        parent.type === "ArrayPattern" ||
+        parent.type === "RestElement" ||
+        (
+            parent.type === "Property" &&
+            parent.value === node &&
+            parent.parent.type === "ObjectPattern"
+        ) ||
+        (
+            parent.type === "AssignmentPattern" &&
+            parent.left === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
+ *
+ * Examples:
+ * import { a as b } from 'mod'; // node `a` is renamed import
+ * export { a as b } from 'mod'; // node `a` is renamed import
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a renamed import.
+ */
+function isRenamedImport(node) {
+    const parent = node.parent;
+
+    return (
+        (
+            parent.type === "ImportSpecifier" &&
+            parent.imported !== parent.local &&
+            parent.imported === node
+        ) ||
+        (
+            parent.type === "ExportSpecifier" &&
+            parent.parent.source && // re-export
+            parent.local !== parent.exported &&
+            parent.local === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
+ *
+ * Examples:
+ * const { a : b } = foo; // node `a` is renamed node.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
+ */
+function isRenamedInDestructuring(node) {
+    const parent = node.parent;
+
+    return (
+        (
+            !parent.computed &&
+            parent.type === "Property" &&
+            parent.parent.type === "ObjectPattern" &&
+            parent.value !== node &&
+            parent.key === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node represents shorthand definition of a property in an object literal.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a shorthand property definition.
+ */
+function isShorthandPropertyDefinition(node) {
+    const parent = node.parent;
+
+    return (
+        parent.type === "Property" &&
+        parent.parent.type === "ObjectExpression" &&
+        parent.shorthand
+    );
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -35,66 +134,64 @@ module.exports = {
 
     create(context) {
 
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        const blacklist = context.options;
+        const blacklist = new Set(context.options);
         const reportedNodes = new Set();
 
+        let globalScope;
 
         /**
-         * Checks if a string matches the provided pattern
-         * @param {string} name The string to check.
-         * @returns {boolean} if the string is a match
+         * Checks whether the given name is blacklisted.
+         * @param {string} name The name to check.
+         * @returns {boolean} `true` if the name is blacklisted.
          * @private
          */
-        function isInvalid(name) {
-            return blacklist.indexOf(name) !== -1;
+        function isBlacklisted(name) {
+            return blacklist.has(name);
         }
 
         /**
-         * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
-         *
-         * Examples:
-         * import { a as b } from 'mod'; // node `a` is renamed import
-         * export { a as b } from 'mod'; // node `a` is renamed import
+         * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+         * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
          * @param {ASTNode} node `Identifier` node to check.
-         * @returns {boolean} `true` if the node is a renamed import.
+         * @returns {boolean} `true` if the node is a reference to a global variable.
          */
-        function isRenamedImport(node) {
-            const parent = node.parent;
+        function isReferenceToGlobalVariable(node) {
+            const variable = globalScope.set.get(node.name);
 
-            return (
-                (
-                    parent.type === "ImportSpecifier" &&
-                    parent.imported !== parent.local &&
-                    parent.imported === node
-                ) ||
-                (
-                    parent.type === "ExportSpecifier" &&
-                    parent.parent.source && // re-export
-                    parent.local !== parent.exported &&
-                    parent.local === node
-                )
-            );
+            return variable && variable.defs.length === 0 &&
+                variable.references.some(ref => ref.identifier === node);
         }
 
         /**
-         * Verifies if we should report an error or not.
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} whether an error should be reported or not
+         * Determines whether the given node should be checked.
+         * @param {ASTNode} node `Identifier` node.
+         * @returns {boolean} `true` if the node should be checked.
          */
-        function shouldReport(node) {
+        function shouldCheck(node) {
             const parent = node.parent;
 
+            /*
+             * Member access has special rules for checking property names.
+             * Read access to a property with a blacklisted name is allowed, because it can be on an object that user has no control over.
+             * Write access isn't allowed, because it potentially creates a new property with a blacklisted name.
+             */
+            if (
+                parent.type === "MemberExpression" &&
+                parent.property === node &&
+                !parent.computed
+            ) {
+                return isAssignmentTarget(parent);
+            }
+
             return (
                 parent.type !== "CallExpression" &&
                 parent.type !== "NewExpression" &&
-                parent.parent.type !== "ObjectPattern" &&
                 !isRenamedImport(node) &&
-                isInvalid(node.name)
+                !isRenamedInDestructuring(node) &&
+                !(
+                    isReferenceToGlobalVariable(node) &&
+                    !isShorthandPropertyDefinition(node)
+                )
             );
         }
 
@@ -119,36 +216,15 @@ module.exports = {
 
         return {
 
-            Identifier(node) {
-
-                // MemberExpressions get special rules
-                if (node.parent.type === "MemberExpression") {
-                    const name = node.name,
-                        effectiveParent = node.parent.parent;
-
-                    // Always check object names
-                    if (node.parent.object.type === "Identifier" &&
-                        node.parent.object.name === name) {
-                        if (isInvalid(name)) {
-                            report(node);
-                        }
-
-                    // Report AssignmentExpressions only if they are the left side of the assignment
-                    } else if (effectiveParent.type === "AssignmentExpression" &&
-                        (effectiveParent.right.type !== "MemberExpression" ||
-                            effectiveParent.left.type === "MemberExpression" &&
-                            effectiveParent.left.property.name === name)) {
-                        if (isInvalid(name)) {
-                            report(node);
-                        }
-                    }
+            Program() {
+                globalScope = context.getScope();
+            },
 
-                } else if (shouldReport(node)) {
+            Identifier(node) {
+                if (isBlacklisted(node.name) && shouldCheck(node)) {
                     report(node);
                 }
             }
-
         };
-
     }
 };

package/lib/rules/id-length.js

@@ -63,6 +63,7 @@ module.exports = {
 
                 return obj;
             }, {});
+        const reportedNode = new Set();
 
         const SUPPORTED_EXPRESSIONS = {
             MemberExpression: properties && function(parent) {
@@ -82,8 +83,15 @@ module.exports = {
             VariableDeclarator(parent, node) {
                 return parent.id === node;
             },
-            Property: properties && function(parent, node) {
-                return parent.key === node;
+            Property(parent, node) {
+
+                if (parent.parent.type === "ObjectPattern") {
+                    return (
+                        parent.value !== parent.key && parent.value === node ||
+                        parent.value === parent.key && parent.key === node && properties
+                    );
+                }
+                return properties && !parent.computed && parent.key === node;
             },
             ImportDefaultSpecifier: true,
             RestElement: true,
@@ -92,7 +100,8 @@ module.exports = {
             ClassDeclaration: true,
             FunctionDeclaration: true,
             MethodDefinition: true,
-            CatchClause: true
+            CatchClause: true,
+            ArrayPattern: true
         };
 
         return {
@@ -109,7 +118,8 @@ module.exports = {
 
                 const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];
 
-                if (isValidExpression && (isValidExpression === true || isValidExpression(parent, node))) {
+                if (isValidExpression && !reportedNode.has(node) && (isValidExpression === true || isValidExpression(parent, node))) {
+                    reportedNode.add(node);
                     context.report({
                         node,
                         messageId: isShort ? "tooShort" : "tooLong",