eslint 6.6.0 → 6.8.0

package/lib/rules/no-underscore-dangle.js

@@ -38,6 +38,10 @@ module.exports = {
                         type: "boolean",
                         default: false
                     },
+                    allowAfterThisConstructor: {
+                        type: "boolean",
+                        default: false
+                    },
                     enforceInMethodNames: {
                         type: "boolean",
                         default: false
@@ -54,6 +58,7 @@ module.exports = {
         const ALLOWED_VARIABLES = options.allow ? options.allow : [];
         const allowAfterThis = typeof options.allowAfterThis !== "undefined" ? options.allowAfterThis : false;
         const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
+        const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
         const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
 
         //-------------------------------------------------------------------------
@@ -72,7 +77,7 @@ module.exports = {
 
         /**
          * Check if identifier has a underscore at the end
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is present
          * @private
          */
@@ -84,7 +89,7 @@ module.exports = {
 
         /**
          * Check if identifier is a special case member expression
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is a special case
          * @private
          */
@@ -94,7 +99,7 @@ module.exports = {
 
         /**
          * Check if identifier is a special case variable expression
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is a special case
          * @private
          */
@@ -104,6 +109,18 @@ module.exports = {
             return identifier === "_";
         }
 
+        /**
+         * Check if a node is a member reference of this.constructor
+         * @param {ASTNode} node node to evaluate
+         * @returns {boolean} true if it is a reference on this.constructor
+         * @private
+         */
+        function isThisConstructorReference(node) {
+            return node.object.type === "MemberExpression" &&
+                node.object.property.name === "constructor" &&
+                node.object.object.type === "ThisExpression";
+        }
+
         /**
          * Check if function has a underscore at the end
          * @param {ASTNode} node node to evaluate
@@ -156,11 +173,13 @@ module.exports = {
         function checkForTrailingUnderscoreInMemberExpression(node) {
             const identifier = node.property.name,
                 isMemberOfThis = node.object.type === "ThisExpression",
-                isMemberOfSuper = node.object.type === "Super";
+                isMemberOfSuper = node.object.type === "Super",
+                isMemberOfThisConstructor = isThisConstructorReference(node);
 
             if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
                 !(isMemberOfThis && allowAfterThis) &&
                 !(isMemberOfSuper && allowAfterSuper) &&
+                !(isMemberOfThisConstructor && allowAfterThisConstructor) &&
                 !isSpecialCaseIdentifierForMemberExpression(identifier) && !isAllowed(identifier)) {
                 context.report({
                     node,

package/lib/rules/no-unexpected-multiline.js

@@ -74,6 +74,14 @@ module.exports = {
                 if (node.tag.loc.end.line === node.quasi.loc.start.line) {
                     return;
                 }
+
+                // handle generics type parameters on template tags
+                const tokenBefore = sourceCode.getTokenBefore(node.quasi);
+
+                if (tokenBefore.loc.end.line === node.quasi.loc.start.line) {
+                    return;
+                }
+
                 context.report({ node, loc: node.loc.start, messageId: "taggedTemplate" });
             },
 

package/lib/rules/no-unsafe-negation.js

@@ -54,7 +54,8 @@ module.exports = {
             description: "disallow negating the left operand of relational operators",
             category: "Possible Errors",
             recommended: true,
-            url: "https://eslint.org/docs/rules/no-unsafe-negation"
+            url: "https://eslint.org/docs/rules/no-unsafe-negation",
+            suggestion: true
         },
 
         schema: [
@@ -69,9 +70,13 @@ module.exports = {
                 additionalProperties: false
             }
         ],
+
         fixable: null,
+
         messages: {
-            unexpected: "Unexpected negating the left operand of '{{operator}}' operator."
+            unexpected: "Unexpected negating the left operand of '{{operator}}' operator.",
+            suggestNegatedExpression: "Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.",
+            suggestParenthesisedNegation: "Wrap negation in '()' to make the intention explicit. This preserves the current behavior."
         }
     },
 
@@ -82,10 +87,11 @@ module.exports = {
 
         return {
             BinaryExpression(node) {
-                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(node.operator);
+                const operator = node.operator;
+                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(operator);
 
                 if (
-                    (isInOrInstanceOfOperator(node.operator) || orderingRelationRuleApplies) &&
+                    (isInOrInstanceOfOperator(operator) || orderingRelationRuleApplies) &&
                     isNegation(node.left) &&
                     !astUtils.isParenthesised(sourceCode, node.left)
                 ) {
@@ -93,7 +99,26 @@ module.exports = {
                         node,
                         loc: node.left.loc,
                         messageId: "unexpected",
-                        data: { operator: node.operator }
+                        data: { operator },
+                        suggest: [
+                            {
+                                messageId: "suggestNegatedExpression",
+                                data: { operator },
+                                fix(fixer) {
+                                    const negationToken = sourceCode.getFirstToken(node.left);
+                                    const fixRange = [negationToken.range[1], node.range[1]];
+                                    const text = sourceCode.text.slice(fixRange[0], fixRange[1]);
+
+                                    return fixer.replaceTextRange(fixRange, `(${text})`);
+                                }
+                            },
+                            {
+                                messageId: "suggestParenthesisedNegation",
+                                fix(fixer) {
+                                    return fixer.replaceText(node.left, `(${sourceCode.getText(node.left)})`);
+                                }
+                            }
+                        ]
                     });
                 }
             }

package/lib/rules/no-useless-computed-key.js

@@ -8,6 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const lodash = require("lodash");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -21,57 +22,83 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "disallow unnecessary computed property keys in object literals",
+            description: "disallow unnecessary computed property keys in objects and classes",
             category: "ECMAScript 6",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-useless-computed-key"
         },
 
-        schema: [],
+        schema: [{
+            type: "object",
+            properties: {
+                enforceForClassMembers: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
         fixable: "code"
     },
     create(context) {
         const sourceCode = context.getSourceCode();
+        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;
+
+        /**
+         * Reports a given node if it violated this rule.
+         * @param {ASTNode} node The node to check.
+         * @returns {void}
+         */
+        function check(node) {
+            if (!node.computed) {
+                return;
+            }
 
-        return {
-            Property(node) {
-                if (!node.computed) {
-                    return;
-                }
-
-                const key = node.key,
-                    nodeType = typeof key.value;
+            const key = node.key,
+                nodeType = typeof key.value;
 
-                if (key.type === "Literal" && (nodeType === "string" || nodeType === "number") && key.value !== "__proto__") {
-                    context.report({
-                        node,
-                        message: MESSAGE_UNNECESSARY_COMPUTED,
-                        data: { property: sourceCode.getText(key) },
-                        fix(fixer) {
-                            const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
-                            const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
-                            const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
+            let allowedKey;
 
-                            if (tokensBetween.slice(0, -1).some((token, index) =>
-                                sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
+            if (node.type === "MethodDefinition") {
+                allowedKey = node.static ? "prototype" : "constructor";
+            } else {
+                allowedKey = "__proto__";
+            }
 
-                                // If there are comments between the brackets and the property name, don't do a fix.
-                                return null;
-                            }
+            if (key.type === "Literal" && (nodeType === "string" || nodeType === "number") && key.value !== allowedKey) {
+                context.report({
+                    node,
+                    message: MESSAGE_UNNECESSARY_COMPUTED,
+                    data: { property: sourceCode.getText(key) },
+                    fix(fixer) {
+                        const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
+                        const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
+                        const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
+
+                        if (tokensBetween.slice(0, -1).some((token, index) =>
+                            sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
+
+                            // If there are comments between the brackets and the property name, don't do a fix.
+                            return null;
+                        }
 
-                            const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);
+                        const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);
 
-                            // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
-                            const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));
+                        // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
+                        const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&
+                            !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));
 
-                            const replacementKey = (needsSpaceBeforeKey ? " " : "") + key.raw;
+                        const replacementKey = (needsSpaceBeforeKey ? " " : "") + key.raw;
 
-                            return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
-                        }
-                    });
-                }
+                        return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
+                    }
+                });
             }
+        }
+
+        return {
+            Property: check,
+            MethodDefinition: enforceForClassMembers ? check : lodash.noop
         };
     }
 };

package/lib/rules/no-useless-escape.js

@@ -85,7 +85,14 @@ module.exports = {
             description: "disallow unnecessary escape characters",
             category: "Best Practices",
             recommended: true,
-            url: "https://eslint.org/docs/rules/no-useless-escape"
+            url: "https://eslint.org/docs/rules/no-useless-escape",
+            suggestion: true
+        },
+
+        messages: {
+            unnecessaryEscape: "Unnecessary escape character: \\{{character}}.",
+            removeEscape: "Remove the `\\`. This maintains the current functionality.",
+            escapeBackslash: "Replace the `\\` with `\\\\` to include the actual backslash character."
         },
 
         schema: []
@@ -103,6 +110,8 @@ module.exports = {
          */
         function report(node, startOffset, character) {
             const start = sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset);
+            const rangeStart = sourceCode.getIndexFromLoc(node.loc.start) + startOffset;
+            const range = [rangeStart, rangeStart + 1];
 
             context.report({
                 node,
@@ -110,8 +119,22 @@ module.exports = {
                     start,
                     end: { line: start.line, column: start.column + 1 }
                 },
-                message: "Unnecessary escape character: \\{{character}}.",
-                data: { character }
+                messageId: "unnecessaryEscape",
+                data: { character },
+                suggest: [
+                    {
+                        messageId: "removeEscape",
+                        fix(fixer) {
+                            return fixer.removeRange(range);
+                        }
+                    },
+                    {
+                        messageId: "escapeBackslash",
+                        fix(fixer) {
+                            return fixer.insertTextBeforeRange(range, "\\");
+                        }
+                    }
+                ]
             });
         }
 

package/lib/rules/object-curly-spacing.js

@@ -74,16 +74,16 @@ module.exports = {
          * @returns {void}
          */
         function reportNoBeginningSpace(node, token) {
+            const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true });
+
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
                 message: "There should be no space after '{{token}}'.",
                 data: {
                     token: token.value
                 },
                 fix(fixer) {
-                    const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true });
-
                     return fixer.removeRange([token.range[1], nextToken.range[0]]);
                 }
             });
@@ -96,16 +96,16 @@ module.exports = {
          * @returns {void}
          */
         function reportNoEndingSpace(node, token) {
+            const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true });
+
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
                 message: "There should be no space before '{{token}}'.",
                 data: {
                     token: token.value
                 },
                 fix(fixer) {
-                    const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true });
-
                     return fixer.removeRange([previousToken.range[1], token.range[0]]);
                 }
             });
@@ -120,7 +120,7 @@ module.exports = {
         function reportRequiredBeginningSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 message: "A space is required after '{{token}}'.",
                 data: {
                     token: token.value
@@ -140,7 +140,7 @@ module.exports = {
         function reportRequiredEndingSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 message: "A space is required before '{{token}}'.",
                 data: {
                     token: token.value

package/lib/rules/operator-assignment.js

@@ -71,6 +71,9 @@ function same(a, b) {
              */
             return same(a.object, b.object) && same(a.property, b.property);
 
+        case "ThisExpression":
+            return true;
+
         default:
             return false;
     }
@@ -83,8 +86,14 @@ function same(a, b) {
  * @returns {boolean} `true` if the node can be fixed
  */
 function canBeFixed(node) {
-    return node.type === "Identifier" ||
-        node.type === "MemberExpression" && node.object.type === "Identifier" && (!node.computed || node.property.type === "Literal");
+    return (
+        node.type === "Identifier" ||
+        (
+            node.type === "MemberExpression" &&
+            (node.object.type === "Identifier" || node.object.type === "ThisExpression") &&
+            (!node.computed || node.property.type === "Literal")
+        )
+    );
 }
 
 module.exports = {

package/lib/rules/prefer-const.js

@@ -356,7 +356,9 @@ module.exports = {
         const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;
         const variables = [];
         let reportCount = 0;
-        let name = "";
+        let checkedId = null;
+        let checkedName = "";
+
 
         /**
          * Reports given identifier nodes if all of the nodes should be declared
@@ -387,25 +389,30 @@ module.exports = {
                         /*
                          * First we check the declaration type and then depending on
                          * if the type is a "VariableDeclarator" or its an "ObjectPattern"
-                         * we compare the name from the first identifier, if the names are different
-                         * we assign the new name and reset the count of reportCount and nodeCount in
+                         * we compare the name and id from the first identifier, if the names are different
+                         * we assign the new name, id and reset the count of reportCount and nodeCount in
                          * order to check each block for the number of reported errors and base our fix
                          * based on comparing nodes.length and nodesToReport.length.
                          */
 
                         if (firstDecParent.type === "VariableDeclarator") {
 
-                            if (firstDecParent.id.name !== name) {
-                                name = firstDecParent.id.name;
+                            if (firstDecParent.id.name !== checkedName) {
+                                checkedName = firstDecParent.id.name;
                                 reportCount = 0;
                             }
 
                             if (firstDecParent.id.type === "ObjectPattern") {
-                                if (firstDecParent.init.name !== name) {
-                                    name = firstDecParent.init.name;
+                                if (firstDecParent.init.name !== checkedName) {
+                                    checkedName = firstDecParent.init.name;
                                     reportCount = 0;
                                 }
                             }
+
+                            if (firstDecParent.id !== checkedId) {
+                                checkedId = firstDecParent.id;
+                                reportCount = 0;
+                            }
                         }
                     }
                 }

package/lib/rules/prefer-exponentiation-operator.js

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview Rule to disallow Math.pow in favor of the ** operator
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { CALL, ReferenceTracker } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({ type: "BinaryExpression", operator: "**" });
+
+/**
+ * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
+ * @param {ASTNode} base The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesBaseNeedParens(base) {
+    return (
+
+        // '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c
+        astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR ||
+
+        // An unary operator cannot be used immediately before an exponentiation expression
+        base.type === "UnaryExpression"
+    );
+}
+
+/**
+ * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.
+ * @param {ASTNode} exponent The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesExponentNeedParens(exponent) {
+
+    // '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c
+    return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;
+}
+
+/**
+ * Determines whether an exponentiation binary expression at the place of the given node would need parens.
+ * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.
+ * @param {SourceCode} sourceCode A SourceCode object.
+ * @returns {boolean} `true` if the expression needs to be parenthesised.
+ */
+function doesExponentiationExpressionNeedParens(node, sourceCode) {
+    const parent = node.parent;
+
+    const needsParens = (
+        parent.type === "ClassDeclaration" ||
+        (
+            parent.type.endsWith("Expression") &&
+            astUtils.getPrecedence(parent) >= PRECEDENCE_OF_EXPONENTIATION_EXPR &&
+            !(parent.type === "BinaryExpression" && parent.operator === "**" && parent.right === node) &&
+            !((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node)) &&
+            !(parent.type === "MemberExpression" && parent.computed && parent.property === node) &&
+            !(parent.type === "ArrayExpression")
+        )
+    );
+
+    return needsParens && !astUtils.isParenthesised(sourceCode, node);
+}
+
+/**
+ * Optionally parenthesizes given text.
+ * @param {string} text The text to parenthesize.
+ * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.
+ * @returns {string} parenthesised or unchanged text.
+ */
+function parenthesizeIfShould(text, shouldParenthesize) {
+    return shouldParenthesize ? `(${text})` : text;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow the use of `Math.pow` in favor of the `**` operator",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-exponentiation-operator"
+        },
+
+        schema: [],
+        fixable: "code",
+
+        messages: {
+            useExponentiation: "Use the '**' operator instead of 'Math.pow'."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Reports the given node.
+         * @param {ASTNode} node 'Math.pow()' node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({
+                node,
+                messageId: "useExponentiation",
+                fix(fixer) {
+                    if (
+                        node.arguments.length !== 2 ||
+                        node.arguments.some(arg => arg.type === "SpreadElement") ||
+                        sourceCode.getCommentsInside(node).length > 0
+                    ) {
+                        return null;
+                    }
+
+                    const base = node.arguments[0],
+                        exponent = node.arguments[1],
+                        baseText = sourceCode.getText(base),
+                        exponentText = sourceCode.getText(exponent),
+                        shouldParenthesizeBase = doesBaseNeedParens(base),
+                        shouldParenthesizeExponent = doesExponentNeedParens(exponent),
+                        shouldParenthesizeAll = doesExponentiationExpressionNeedParens(node, sourceCode);
+
+                    let prefix = "",
+                        suffix = "";
+
+                    if (!shouldParenthesizeAll) {
+                        if (!shouldParenthesizeBase) {
+                            const firstReplacementToken = sourceCode.getFirstToken(base),
+                                tokenBefore = sourceCode.getTokenBefore(node);
+
+                            if (
+                                tokenBefore &&
+                                tokenBefore.range[1] === node.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)
+                            ) {
+                                prefix = " "; // a+Math.pow(++b, c) -> a+ ++b**c
+                            }
+                        }
+                        if (!shouldParenthesizeExponent) {
+                            const lastReplacementToken = sourceCode.getLastToken(exponent),
+                                tokenAfter = sourceCode.getTokenAfter(node);
+
+                            if (
+                                tokenAfter &&
+                                node.range[1] === tokenAfter.range[0] &&
+                                !astUtils.canTokensBeAdjacent(lastReplacementToken, tokenAfter)
+                            ) {
+                                suffix = " "; // Math.pow(a, b)in c -> a**b in c
+                            }
+                        }
+                    }
+
+                    const baseReplacement = parenthesizeIfShould(baseText, shouldParenthesizeBase),
+                        exponentReplacement = parenthesizeIfShould(exponentText, shouldParenthesizeExponent),
+                        replacement = parenthesizeIfShould(`${baseReplacement}**${exponentReplacement}`, shouldParenthesizeAll);
+
+                    return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
+                }
+            });
+        }
+
+        return {
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const trackMap = {
+                    Math: {
+                        pow: { [CALL]: true }
+                    }
+                };
+
+                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
+                    report(node);
+                }
+            }
+        };
+    }
+};