eslint 7.0.0-alpha.2 → 7.1.0

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

@@ -11,6 +11,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         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,88 +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);
         }
 
         /**
-         * 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.
+         * Determines whether the given node should be checked.
+         * @param {ASTNode} node `Identifier` node.
+         * @returns {boolean} `true` if the node should be checked.
          */
-        function isRenamedInDestructuring(node) {
+        function shouldCheck(node) {
             const parent = node.parent;
 
-            return (
-                (
-                    !parent.computed &&
-                    parent.type === "Property" &&
-                    parent.parent.type === "ObjectPattern" &&
-                    parent.value !== node &&
-                    parent.key === 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
-         */
-        function shouldReport(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" &&
                 !isRenamedImport(node) &&
                 !isRenamedInDestructuring(node) &&
-                isInvalid(node.name)
+                !(
+                    isReferenceToGlobalVariable(node) &&
+                    !isShorthandPropertyDefinition(node)
+                )
             );
         }
 
@@ -141,54 +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);
-                        }
-
-                    // Report the last identifier in an ObjectPattern destructuring.
-                    } else if (
-                        (
-                            effectiveParent.type === "Property" &&
-                            effectiveParent.value === node.parent &&
-                            effectiveParent.parent.type === "ObjectPattern"
-                        ) ||
-                        effectiveParent.type === "RestElement" ||
-                        effectiveParent.type === "ArrayPattern" ||
-                        (
-                            effectiveParent.type === "AssignmentPattern" &&
-                            effectiveParent.left === node.parent
-                        )
-                    ) {
-                        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/index.js

@@ -148,6 +148,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-lone-blocks": () => require("./no-lone-blocks"),
     "no-lonely-if": () => require("./no-lonely-if"),
     "no-loop-func": () => require("./no-loop-func"),
+    "no-loss-of-precision": () => require("./no-loss-of-precision"),
     "no-magic-numbers": () => require("./no-magic-numbers"),
     "no-misleading-character-class": () => require("./no-misleading-character-class"),
     "no-mixed-operators": () => require("./no-mixed-operators"),

package/lib/rules/key-spacing.js

@@ -45,7 +45,7 @@ function isSingleLine(node) {
 /**
  * Checks whether the properties on a single line.
  * @param {ASTNode[]} properties List of Property AST nodes.
- * @returns {boolean} True if all properies is on a single line.
+ * @returns {boolean} True if all properties is on a single line.
  */
 function isSingleLineProperties(properties) {
     const [firstProp] = properties,

package/lib/rules/linebreak-style.js

@@ -86,8 +86,14 @@ module.exports = {
                     context.report({
                         node,
                         loc: {
-                            line: i,
-                            column: sourceCode.lines[i - 1].length
+                            start: {
+                                line: i,
+                                column: sourceCode.lines[i - 1].length
+                            },
+                            end: {
+                                line: i + 1,
+                                column: 0
+                            }
                         },
                         messageId: expectedLF ? "expectedLF" : "expectedCRLF",
                         fix: createFix(range, expectedLFChars)

package/lib/rules/max-lines-per-function.js

@@ -134,7 +134,7 @@ module.exports = {
          * @returns {boolean} True if it's an IIFE
          */
         function isIIFE(node) {
-            return node.type === "FunctionExpression" && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
+            return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
         }
 
         /**

package/lib/rules/new-cap.js

@@ -235,7 +235,7 @@ module.exports = {
                 callee = callee.property;
             }
 
-            context.report({ node, loc: callee.loc.start, messageId });
+            context.report({ node, loc: callee.loc, messageId });
         }
 
         //--------------------------------------------------------------------------

package/lib/rules/newline-per-chained-call.js

@@ -90,16 +90,19 @@ module.exports = {
                 }
 
                 if (depth > ignoreChainWithDepth && astUtils.isTokenOnSameLine(callee.object, callee.property)) {
+                    const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils.isNotClosingParenToken);
+
                     context.report({
                         node: callee.property,
-                        loc: callee.property.loc.start,
+                        loc: {
+                            start: firstTokenAfterObject.loc.start,
+                            end: callee.loc.end
+                        },
                         messageId: "expected",
                         data: {
                             callee: getPropertyText(callee)
                         },
                         fix(fixer) {
-                            const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils.isNotClosingParenToken);
-
                             return fixer.insertTextBefore(firstTokenAfterObject, "\n");
                         }
                     });

package/lib/rules/no-alert.js

@@ -8,7 +8,10 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
+const {
+    getStaticPropertyName: getPropertyName,
+    getVariableByName
+} = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -61,7 +64,7 @@ function isGlobalThisReferenceOrGlobalWindow(scope, node) {
     if (scope.type === "global" && node.type === "ThisExpression") {
         return true;
     }
-    if (node.name === "window") {
+    if (node.name === "window" || (node.name === "globalThis" && getVariableByName(scope, "globalThis"))) {
         return !isShadowed(scope, node);
     }
 
@@ -119,7 +122,6 @@ module.exports = {
                         });
                     }
                 }
-
             }
         };
 

package/lib/rules/no-buffer-constructor.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         type: "problem",
 
         docs: {

package/lib/rules/no-empty-function.js

@@ -23,7 +23,9 @@ const ALLOW_OPTIONS = Object.freeze([
     "generatorMethods",
     "getters",
     "setters",
-    "constructors"
+    "constructors",
+    "asyncFunctions",
+    "asyncMethods"
 ]);
 
 /**
@@ -149,7 +151,7 @@ module.exports = {
             ) {
                 context.report({
                     node,
-                    loc: node.body.loc.start,
+                    loc: node.body.loc,
                     messageId: "unexpected",
                     data: { name }
                 });

package/lib/rules/no-eval.js

@@ -17,7 +17,8 @@ const astUtils = require("./utils/ast-utils");
 
 const candidatesOfGlobalObject = Object.freeze([
     "global",
-    "window"
+    "window",
+    "globalThis"
 ]);
 
 /**

package/lib/rules/no-extra-bind.js

@@ -64,7 +64,7 @@ module.exports = {
             context.report({
                 node: node.parent.parent,
                 messageId: "unexpected",
-                loc: node.parent.property.loc.start,
+                loc: node.parent.property.loc,
                 fix(fixer) {
                     if (node.parent.parent.arguments.length && !isSideEffectFree(node.parent.parent.arguments[0])) {
                         return null;

package/lib/rules/no-extra-boolean-cast.js

@@ -10,6 +10,9 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const eslintUtils = require("eslint-utils");
+
+const precedence = astUtils.getPrecedence;
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -126,6 +129,60 @@ module.exports = {
             return Boolean(sourceCode.getCommentsInside(node).length);
         }
 
+        /**
+         * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} `true` if the node is parenthesized.
+         * @private
+         */
+        function isParenthesized(node) {
+            return eslintUtils.isParenthesized(1, node, sourceCode);
+        }
+
+        /**
+         * Determines whether the given node needs to be parenthesized when replacing the previous node.
+         * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
+         * of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
+         * For example, if the parent is `ConditionalExpression`, `previousNode` must be its `test` child.
+         * @param {ASTNode} previousNode Previous node.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} `true` if the node needs to be parenthesized.
+         */
+        function needsParens(previousNode, node) {
+            if (isParenthesized(previousNode)) {
+
+                // parentheses around the previous node will stay, so there is no need for an additional pair
+                return false;
+            }
+
+            // parent of the previous node will become parent of the replacement node
+            const parent = previousNode.parent;
+
+            switch (parent.type) {
+                case "CallExpression":
+                case "NewExpression":
+                    return node.type === "SequenceExpression";
+                case "IfStatement":
+                case "DoWhileStatement":
+                case "WhileStatement":
+                case "ForStatement":
+                    return false;
+                case "ConditionalExpression":
+                    return precedence(node) <= precedence(parent);
+                case "UnaryExpression":
+                    return precedence(node) < precedence(parent);
+                case "LogicalExpression":
+                    if (previousNode === parent.left) {
+                        return precedence(node) < precedence(parent);
+                    }
+                    return precedence(node) <= precedence(parent);
+
+                /* istanbul ignore next */
+                default:
+                    throw new Error(`Unexpected parent type: ${parent.type}`);
+            }
+        }
+
         return {
             UnaryExpression(node) {
                 const parent = node.parent;
@@ -143,32 +200,34 @@ module.exports = {
                     context.report({
                         node: parent,
                         messageId: "unexpectedNegation",
-                        fix: fixer => {
+                        fix(fixer) {
                             if (hasCommentsInside(parent)) {
                                 return null;
                             }
 
+                            if (needsParens(parent, node.argument)) {
+                                return fixer.replaceText(parent, `(${sourceCode.getText(node.argument)})`);
+                            }
+
                             let prefix = "";
                             const tokenBefore = sourceCode.getTokenBefore(parent);
                             const firstReplacementToken = sourceCode.getFirstToken(node.argument);
 
-                            if (tokenBefore && tokenBefore.range[1] === parent.range[0] &&
-                                    !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)) {
+                            if (
+                                tokenBefore &&
+                                tokenBefore.range[1] === parent.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)
+                            ) {
                                 prefix = " ";
                             }
 
-                            if (astUtils.getPrecedence(node.argument) < astUtils.getPrecedence(parent.parent)) {
-                                return fixer.replaceText(parent, `(${sourceCode.getText(node.argument)})`);
-                            }
-
                             return fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));
                         }
                     });
                 }
             },
-            CallExpression(node) {
-                const parent = node.parent;
 
+            CallExpression(node) {
                 if (node.callee.type !== "Identifier" || node.callee.name !== "Boolean") {
                     return;
                 }
@@ -177,11 +236,15 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "unexpectedCall",
-                        fix: fixer => {
-                            if (!node.arguments.length) {
+                        fix(fixer) {
+                            const parent = node.parent;
+
+                            if (node.arguments.length === 0) {
                                 if (parent.type === "UnaryExpression" && parent.operator === "!") {
 
-                                    // !Boolean() -> true
+                                    /*
+                                     * !Boolean() -> true
+                                     */
 
                                     if (hasCommentsInside(parent)) {
                                         return null;
@@ -191,32 +254,48 @@ module.exports = {
                                     let prefix = "";
                                     const tokenBefore = sourceCode.getTokenBefore(parent);
 
-                                    if (tokenBefore && tokenBefore.range[1] === parent.range[0] &&
-                                            !astUtils.canTokensBeAdjacent(tokenBefore, replacement)) {
+                                    if (
+                                        tokenBefore &&
+                                        tokenBefore.range[1] === parent.range[0] &&
+                                        !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
+                                    ) {
                                         prefix = " ";
                                     }
 
                                     return fixer.replaceText(parent, prefix + replacement);
                                 }
 
-                                // Boolean() -> false
+                                /*
+                                 * Boolean() -> false
+                                 */
+
                                 if (hasCommentsInside(node)) {
                                     return null;
                                 }
+
                                 return fixer.replaceText(node, "false");
                             }
 
-                            if (node.arguments.length > 1 || node.arguments[0].type === "SpreadElement" ||
-                                    hasCommentsInside(node)) {
-                                return null;
-                            }
+                            if (node.arguments.length === 1) {
+                                const argument = node.arguments[0];
+
+                                if (argument.type === "SpreadElement" || hasCommentsInside(node)) {
+                                    return null;
+                                }
+
+                                /*
+                                 * Boolean(expression) -> expression
+                                 */
 
-                            const argument = node.arguments[0];
+                                if (needsParens(node, argument)) {
+                                    return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
+                                }
 
-                            if (astUtils.getPrecedence(argument) < astUtils.getPrecedence(node.parent)) {
-                                return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
+                                return fixer.replaceText(node, sourceCode.getText(argument));
                             }
-                            return fixer.replaceText(node, sourceCode.getText(argument));
+
+                            // two or more arguments
+                            return null;
                         }
                     });
                 }