eslint 7.0.0-alpha.1 → 7.0.0

package/lib/rules/indent-legacy.js

@@ -696,20 +696,6 @@ module.exports = {
             return startLine === endLine;
         }
 
-        /**
-         * Check to see if the first element inside an array is an object and on the same line as the node
-         * If the node is not an array then it will return false.
-         * @param {ASTNode} node node to check
-         * @returns {boolean} success/failure
-         */
-        function isFirstArrayElementOnSameLine(node) {
-            if (node.type === "ArrayExpression" && node.elements[0]) {
-                return node.elements[0].loc.start.line === node.loc.start.line && node.elements[0].type === "ObjectExpression";
-            }
-            return false;
-
-        }
-
         /**
          * Check indent for array block content or object block content
          * @param {ASTNode} node node to examine
@@ -776,8 +762,6 @@ module.exports = {
                             nodeIndent += indentSize;
                         }
                     }
-                } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && parent.type !== "MemberExpression" && parent.type !== "ExpressionStatement" && parent.type !== "AssignmentExpression" && parent.type !== "Property") {
-                    nodeIndent += indentSize;
                 }
 
                 checkFirstNodeLineIndent(node, nodeIndent);

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/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: ["node/no-deprecated-api"],
+
         type: "problem",
 
         docs: {

package/lib/rules/no-dupe-else-if.js

@@ -53,7 +53,7 @@ module.exports = {
         docs: {
             description: "disallow duplicate conditions in if-else-if chains",
             category: "Possible Errors",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/rules/no-dupe-else-if"
         },
 

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"
 ]);
 
 /**
@@ -158,7 +159,7 @@ module.exports = {
 
             context.report({
                 node: reportNode,
-                loc: locationNode.loc.start,
+                loc: locationNode.loc,
                 messageId: "unexpected"
             });
         }

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
@@ -26,7 +29,16 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-extra-boolean-cast"
         },
 
-        schema: [],
+        schema: [{
+            type: "object",
+            properties: {
+                enforceForLogicalOperands: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
         fixable: "code",
 
         messages: {
@@ -47,23 +59,67 @@ module.exports = {
             "ForStatement"
         ];
 
+        /**
+         * Check if a node is a Boolean function or constructor.
+         * @param {ASTNode} node the node
+         * @returns {boolean} If the node is Boolean function or constructor
+         */
+        function isBooleanFunctionOrConstructorCall(node) {
+
+            // Boolean(<bool>) and new Boolean(<bool>)
+            return (node.type === "CallExpression" || node.type === "NewExpression") &&
+                    node.callee.type === "Identifier" &&
+                        node.callee.name === "Boolean";
+        }
+
+        /**
+         * Checks whether the node is a logical expression and that the option is enabled
+         * @param {ASTNode} node the node
+         * @returns {boolean} if the node is a logical expression and option is enabled
+         */
+        function isLogicalContext(node) {
+            return node.type === "LogicalExpression" &&
+            (node.operator === "||" || node.operator === "&&") &&
+            (context.options.length && context.options[0].enforceForLogicalOperands === true);
+
+        }
+
+
         /**
          * Check if a node is in a context where its value would be coerced to a boolean at runtime.
          * @param {ASTNode} node The node
-         * @param {ASTNode} parent Its parent
          * @returns {boolean} If it is in a boolean context
          */
-        function isInBooleanContext(node, parent) {
+        function isInBooleanContext(node) {
             return (
-                (BOOLEAN_NODE_TYPES.indexOf(parent.type) !== -1 &&
-                    node === parent.test) ||
+                (isBooleanFunctionOrConstructorCall(node.parent) &&
+                node === node.parent.arguments[0]) ||
+
+                (BOOLEAN_NODE_TYPES.indexOf(node.parent.type) !== -1 &&
+                    node === node.parent.test) ||
 
                 // !<bool>
-                (parent.type === "UnaryExpression" &&
-                    parent.operator === "!")
+                (node.parent.type === "UnaryExpression" &&
+                    node.parent.operator === "!")
             );
         }
 
+        /**
+         * Checks whether the node is a context that should report an error
+         * Acts recursively if it is in a logical context
+         * @param {ASTNode} node the node
+         * @returns {boolean} If the node is in one of the flagged contexts
+         */
+        function isInFlaggedContext(node) {
+            return isInBooleanContext(node) ||
+            (isLogicalContext(node.parent) &&
+
+            // For nested logical statements
+            isInFlaggedContext(node.parent)
+            );
+        }
+
+
         /**
          * Check if a node has comments inside.
          * @param {ASTNode} node The node to check.
@@ -73,40 +129,95 @@ 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 ancestors = context.getAncestors(),
-                    parent = ancestors.pop(),
-                    grandparent = ancestors.pop();
+                const parent = node.parent;
+
 
                 // Exit early if it's guaranteed not to match
                 if (node.operator !== "!" ||
-                        parent.type !== "UnaryExpression" ||
-                        parent.operator !== "!") {
+                          parent.type !== "UnaryExpression" ||
+                          parent.operator !== "!") {
                     return;
                 }
 
-                if (isInBooleanContext(parent, grandparent) ||
 
-                    // Boolean(<bool>) and new Boolean(<bool>)
-                    ((grandparent.type === "CallExpression" || grandparent.type === "NewExpression") &&
-                        grandparent.callee.type === "Identifier" &&
-                        grandparent.callee.name === "Boolean")
-                ) {
+                if (isInFlaggedContext(parent)) {
                     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 = " ";
                             }
 
@@ -115,22 +226,25 @@ module.exports = {
                     });
                 }
             },
-            CallExpression(node) {
-                const parent = node.parent;
 
+            CallExpression(node) {
                 if (node.callee.type !== "Identifier" || node.callee.name !== "Boolean") {
                     return;
                 }
 
-                if (isInBooleanContext(node, parent)) {
+                if (isInFlaggedContext(node)) {
                     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;
@@ -140,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];
 
-                            const argument = node.arguments[0];
+                                if (argument.type === "SpreadElement" || hasCommentsInside(node)) {
+                                    return null;
+                                }
+
+                                /*
+                                 * Boolean(expression) -> expression
+                                 */
 
-                            if (astUtils.getPrecedence(argument) < astUtils.getPrecedence(node.parent)) {
-                                return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
+                                if (needsParens(node, argument)) {
+                                    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;
                         }
                     });
                 }

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

@@ -307,13 +307,13 @@ module.exports = {
          */
         function requiresLeadingSpace(node) {
             const leftParenToken = sourceCode.getTokenBefore(node);
-            const tokenBeforeLeftParen = sourceCode.getTokenBefore(node, 1);
-            const firstToken = sourceCode.getFirstToken(node);
+            const tokenBeforeLeftParen = sourceCode.getTokenBefore(leftParenToken, { includeComments: true });
+            const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParenToken, { includeComments: true });
 
             return tokenBeforeLeftParen &&
                 tokenBeforeLeftParen.range[1] === leftParenToken.range[0] &&
-                leftParenToken.range[1] === firstToken.range[0] &&
-                !astUtils.canTokensBeAdjacent(tokenBeforeLeftParen, firstToken);
+                leftParenToken.range[1] === tokenAfterLeftParen.range[0] &&
+                !astUtils.canTokensBeAdjacent(tokenBeforeLeftParen, tokenAfterLeftParen);
         }
 
         /**
@@ -560,7 +560,11 @@ module.exports = {
                 tokensToIgnore.add(secondToken);
             }
 
-            if (hasExcessParens(node)) {
+            const hasExtraParens = node.parent.type === "ExportDefaultDeclaration"
+                ? hasExcessParensWithPrecedence(node, PRECEDENCE_OF_ASSIGNMENT_EXPR)
+                : hasExcessParens(node);
+
+            if (hasExtraParens) {
                 report(node);
             }
         }