eslint 6.3.0 → 6.6.0

package/lib/rules/no-mixed-operators.js

@@ -40,8 +40,7 @@ const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
 
 /**
  * Normalizes options.
- *
- * @param {Object|undefined} options - A options object to normalize.
+ * @param {Object|undefined} options A options object to normalize.
  * @returns {Object} Normalized option object.
  */
 function normalizeOptions(options = {}) {
@@ -57,10 +56,9 @@ function normalizeOptions(options = {}) {
 
 /**
  * Checks whether any group which includes both given operator exists or not.
- *
- * @param {Array.<string[]>} groups - A list of groups to check.
- * @param {string} left - An operator.
- * @param {string} right - Another operator.
+ * @param {Array.<string[]>} groups A list of groups to check.
+ * @param {string} left An operator.
+ * @param {string} right Another operator.
  * @returns {boolean} `true` if such group existed.
  */
 function includesBothInAGroup(groups, left, right) {
@@ -69,8 +67,7 @@ function includesBothInAGroup(groups, left, right) {
 
 /**
  * Checks whether the given node is a conditional expression and returns the test node else the left node.
- *
- * @param {ASTNode} node - A node which can be a BinaryExpression or a LogicalExpression node.
+ * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
  * This parent node can be BinaryExpression, LogicalExpression
  *      , or a ConditionalExpression node
  * @returns {ASTNode} node the appropriate node(left or test).
@@ -124,8 +121,7 @@ module.exports = {
 
         /**
          * Checks whether a given node should be ignored by options or not.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {boolean} `true` if the node should be ignored.
@@ -146,8 +142,7 @@ module.exports = {
         /**
          * Checks whether the operator of a given node is mixed with parent
          * node's operator or not.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {boolean} `true` if the node was mixed.
@@ -163,8 +158,7 @@ module.exports = {
         /**
          * Checks whether the operator of a given node is mixed with a
          * conditional expression.
-         *
-         * @param {ASTNode} node - A node to check. This is a conditional
+         * @param {ASTNode} node A node to check. This is a conditional
          *      expression node
          * @returns {boolean} `true` if the node was mixed.
          */
@@ -174,8 +168,7 @@ module.exports = {
 
         /**
          * Gets the operator token of a given node.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node.
          * @returns {Token} The operator token of the node.
          */
@@ -186,8 +179,7 @@ module.exports = {
         /**
          * Reports both the operator of a given node and the operator of the
          * parent node.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {void}
@@ -205,13 +197,13 @@ module.exports = {
 
             context.report({
                 node: left,
-                loc: getOperatorToken(left).loc.start,
+                loc: getOperatorToken(left).loc,
                 message,
                 data
             });
             context.report({
                 node: right,
-                loc: getOperatorToken(right).loc.start,
+                loc: getOperatorToken(right).loc,
                 message,
                 data
             });
@@ -220,8 +212,7 @@ module.exports = {
         /**
          * Checks between the operator of this node and the operator of the
          * parent node.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function check(node) {

package/lib/rules/no-mixed-requires.js

@@ -58,7 +58,6 @@ module.exports = {
 
         /**
          * Returns the list of built-in modules.
-         *
          * @returns {string[]} An array of built-in Node.js modules.
          */
         function getBuiltinModules() {

package/lib/rules/no-multi-spaces.js

@@ -121,7 +121,7 @@ module.exports = {
 
                     context.report({
                         node: rightToken,
-                        loc: rightToken.loc.start,
+                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },
                         message: "Multiple spaces found before '{{displayValue}}'.",
                         data: { displayValue },
                         fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")

package/lib/rules/no-native-reassign.js

@@ -46,9 +46,9 @@ module.exports = {
 
         /**
          * Reports write references.
-         * @param {Reference} reference - A reference to check.
-         * @param {int} index - The index of the reference in the references.
-         * @param {Reference[]} references - The array that the reference belongs to.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
          * @returns {void}
          */
         function checkReference(reference, index, references) {
@@ -73,7 +73,7 @@ module.exports = {
 
         /**
          * Reports write references if a given variable is read-only builtin.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {

package/lib/rules/no-obj-calls.js

@@ -5,6 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { CALL, ReferenceTracker } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -20,23 +32,31 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-obj-calls"
         },
 
-        schema: []
+        schema: [],
+
+        messages: {
+            unexpectedCall: "'{{name}}' is not a function."
+        }
     },
 
     create(context) {
 
         return {
-            CallExpression(node) {
-
-                if (node.callee.type === "Identifier") {
-                    const name = node.callee.name;
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const traceMap = {};
+
+                for (const global of nonCallableGlobals) {
+                    traceMap[global] = {
+                        [CALL]: true
+                    };
+                }
 
-                    if (name === "Math" || name === "JSON" || name === "Reflect") {
-                        context.report({ node, message: "'{{name}}' is not a function.", data: { name } });
-                    }
+                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
+                    context.report({ node, messageId: "unexpectedCall", data: { name: node.callee.name } });
                 }
             }
         };
-
     }
 };

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

@@ -20,7 +20,11 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-octal-escape"
         },
 
-        schema: []
+        schema: [],
+
+        messages: {
+            octalEscapeSequence: "Don't use octal: '\\{{sequence}}'. Use '\\u....' instead."
+        }
     },
 
     create(context) {
@@ -32,15 +36,17 @@ module.exports = {
                     return;
                 }
 
-                const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/u);
+                // \0 represents a valid NULL character if it isn't followed by a digit.
+                const match = node.raw.match(
+                    /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|[1-7])/u
+                );
 
                 if (match) {
-                    const octalDigit = match[2];
-
-                    // \0 is actually not considered an octal
-                    if (match[2] !== "0" || typeof match[3] !== "undefined") {
-                        context.report({ node, message: "Don't use octal: '\\{{octalDigit}}'. Use '\\u....' instead.", data: { octalDigit } });
-                    }
+                    context.report({
+                        node,
+                        messageId: "octalEscapeSequence",
+                        data: { sequence: match[1] }
+                    });
                 }
             }
 

package/lib/rules/no-param-reassign.js

@@ -45,6 +45,13 @@ module.exports = {
                                     type: "string"
                                 },
                                 uniqueItems: true
+                            },
+                            ignorePropertyModificationsForRegex: {
+                                type: "array",
+                                items: {
+                                    type: "string"
+                                },
+                                uniqueItems: true
                             }
                         },
                         additionalProperties: false
@@ -57,10 +64,11 @@ module.exports = {
     create(context) {
         const props = context.options[0] && context.options[0].props;
         const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];
+        const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];
 
         /**
          * Checks whether or not the reference modifies properties of its variable.
-         * @param {Reference} reference - A reference to check.
+         * @param {Reference} reference A reference to check.
          * @returns {boolean} Whether or not the reference modifies properties of its variable.
          */
         function isModifyingProp(reference) {
@@ -136,11 +144,24 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Tests that an identifier name matches any of the ignored property assignments.
+         * First we test strings in ignoredPropertyAssignmentsFor.
+         * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
+         * @param {string} identifierName A string that describes the name of an identifier to
+         * ignore property assignments for.
+         * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
+         */
+        function isIgnoredPropertyAssignment(identifierName) {
+            return ignoredPropertyAssignmentsFor.includes(identifierName) ||
+                ignoredPropertyAssignmentsForRegex.some(ignored => new RegExp(ignored, "u").test(identifierName));
+        }
+
         /**
          * Reports a reference if is non initializer and writable.
-         * @param {Reference} reference - A reference to check.
-         * @param {int} index - The index of the reference in the references.
-         * @param {Reference[]} references - The array that the reference belongs to.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
          * @returns {void}
          */
         function checkReference(reference, index, references) {
@@ -157,7 +178,7 @@ module.exports = {
             ) {
                 if (reference.isWrite()) {
                     context.report({ node: identifier, message: "Assignment to function parameter '{{name}}'.", data: { name: identifier.name } });
-                } else if (props && isModifyingProp(reference) && ignoredPropertyAssignmentsFor.indexOf(identifier.name) === -1) {
+                } else if (props && isModifyingProp(reference) && !isIgnoredPropertyAssignment(identifier.name)) {
                     context.report({ node: identifier, message: "Assignment to property of function parameter '{{name}}'.", data: { name: identifier.name } });
                 }
             }
@@ -165,7 +186,7 @@ module.exports = {
 
         /**
          * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {
@@ -176,7 +197,7 @@ module.exports = {
 
         /**
          * Checks parameters of a given function node.
-         * @param {ASTNode} node - A function node to check.
+         * @param {ASTNode} node A function node to check.
          * @returns {void}
          */
         function checkForFunction(node) {

package/lib/rules/no-redeclare.js

@@ -86,7 +86,7 @@ module.exports = {
 
         /**
          * Find variables in a given scope and flag redeclared ones.
-         * @param {Scope} scope - An eslint-scope scope object.
+         * @param {Scope} scope An eslint-scope scope object.
          * @returns {void}
          * @private
          */

package/lib/rules/no-regex-spaces.js

@@ -5,7 +5,29 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("./utils/ast-utils");
+const regexpp = require("regexpp");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const regExpParser = new regexpp.RegExpParser();
+const DOUBLE_SPACE = / {2}/u;
+
+/**
+ * Check if node is a string
+ * @param {ASTNode} node node to evaluate
+ * @returns {boolean} True if its a string
+ * @private
+ */
+function isString(node) {
+    return node && node.type === "Literal" && typeof node.value === "string";
+}
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -27,40 +49,69 @@ module.exports = {
     },
 
     create(context) {
-        const sourceCode = context.getSourceCode();
 
         /**
-         * Validate regular expressions
-         * @param {ASTNode} node node to validate
-         * @param {string} value regular expression to validate
-         * @param {number} valueStart The start location of the regex/string literal. It will always be the case that
-         * `sourceCode.getText().slice(valueStart, valueStart + value.length) === value`
+         * Validate regular expression
+         * @param {ASTNode} nodeToReport Node to report.
+         * @param {string} pattern Regular expression pattern to validate.
+         * @param {string} rawPattern Raw representation of the pattern in the source code.
+         * @param {number} rawPatternStartRange Start range of the pattern in the source code.
+         * @param {string} flags Regular expression flags.
          * @returns {void}
          * @private
          */
-        function checkRegex(node, value, valueStart) {
-            const multipleSpacesRegex = /( {2,})( [+*{?]|[^+*{?]|$)/u,
-                regexResults = multipleSpacesRegex.exec(value);
+        function checkRegex(nodeToReport, pattern, rawPattern, rawPatternStartRange, flags) {
 
-            if (regexResults !== null) {
-                const count = regexResults[1].length;
+            // Skip if there are no consecutive spaces in the source code, to avoid reporting e.g., RegExp(' \ ').
+            if (!DOUBLE_SPACE.test(rawPattern)) {
+                return;
+            }
 
-                context.report({
-                    node,
-                    message: "Spaces are hard to count. Use {{{count}}}.",
-                    data: { count },
-                    fix(fixer) {
-                        return fixer.replaceTextRange(
-                            [valueStart + regexResults.index, valueStart + regexResults.index + count],
-                            ` {${count}}`
-                        );
-                    }
-                });
-
-                /*
-                 * TODO: (platinumazure) Fix message to use rule message
-                 * substitution when api.report is fixed in lib/eslint.js.
-                 */
+            const characterClassNodes = [];
+            let regExpAST;
+
+            try {
+                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
+            } catch (e) {
+
+                // Ignore regular expressions with syntax errors
+                return;
+            }
+
+            regexpp.visitRegExpAST(regExpAST, {
+                onCharacterClassEnter(ccNode) {
+                    characterClassNodes.push(ccNode);
+                }
+            });
+
+            const spacesPattern = /( {2,})(?: [+*{?]|[^+*{?]|$)/gu;
+            let match;
+
+            while ((match = spacesPattern.exec(pattern))) {
+                const { 1: { length }, index } = match;
+
+                // Report only consecutive spaces that are not in character classes.
+                if (
+                    characterClassNodes.every(({ start, end }) => index < start || end <= index)
+                ) {
+                    context.report({
+                        node: nodeToReport,
+                        message: "Spaces are hard to count. Use {{{length}}}.",
+                        data: { length },
+                        fix(fixer) {
+                            if (pattern !== rawPattern) {
+                                return null;
+                            }
+                            return fixer.replaceTextRange(
+                                [rawPatternStartRange + index, rawPatternStartRange + index + length],
+                                ` {${length}}`
+                            );
+                        }
+                    });
+
+                    // Report only the first occurence of consecutive spaces
+                    return;
+                }
             }
         }
 
@@ -71,25 +122,22 @@ module.exports = {
          * @private
          */
         function checkLiteral(node) {
-            const token = sourceCode.getFirstToken(node),
-                nodeType = token.type,
-                nodeValue = token.value;
+            if (node.regex) {
+                const pattern = node.regex.pattern;
+                const rawPattern = node.raw.slice(1, node.raw.lastIndexOf("/"));
+                const rawPatternStartRange = node.range[0] + 1;
+                const flags = node.regex.flags;
 
-            if (nodeType === "RegularExpression") {
-                checkRegex(node, nodeValue, token.range[0]);
+                checkRegex(
+                    node,
+                    pattern,
+                    rawPattern,
+                    rawPatternStartRange,
+                    flags
+                );
             }
         }
 
-        /**
-         * Check if node is a string
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if its a string
-         * @private
-         */
-        function isString(node) {
-            return node && node.type === "Literal" && typeof node.value === "string";
-        }
-
         /**
          * Validate strings passed to the RegExp constructor
          * @param {ASTNode} node node to validate
@@ -100,9 +148,22 @@ module.exports = {
             const scope = context.getScope();
             const regExpVar = astUtils.getVariableByName(scope, "RegExp");
             const shadowed = regExpVar && regExpVar.defs.length > 0;
+            const patternNode = node.arguments[0];
+            const flagsNode = node.arguments[1];
 
-            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0]) && !shadowed) {
-                checkRegex(node, node.arguments[0].value, node.arguments[0].range[0] + 1);
+            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(patternNode) && !shadowed) {
+                const pattern = patternNode.value;
+                const rawPattern = patternNode.raw.slice(1, -1);
+                const rawPatternStartRange = patternNode.range[0] + 1;
+                const flags = isString(flagsNode) ? flagsNode.value : "";
+
+                checkRegex(
+                    node,
+                    pattern,
+                    rawPattern,
+                    rawPatternStartRange,
+                    flags
+                );
             }
         }
 
@@ -111,6 +172,5 @@ module.exports = {
             CallExpression: checkFunction,
             NewExpression: checkFunction
         };
-
     }
 };

package/lib/rules/no-restricted-imports.js

@@ -116,7 +116,7 @@ module.exports = {
 
         /**
          * Checks to see if "*" is being used to import everything.
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether everything is imported or not
          */
         function isEverythingImported(importNames) {
@@ -145,7 +145,7 @@ module.exports = {
 
         /**
          * Report a restricted path specifically for patterns.
-         * @param {node} node - representing the restricted path reference
+         * @param {node} node representing the restricted path reference
          * @returns {void}
          * @private
          */
@@ -163,8 +163,8 @@ module.exports = {
 
         /**
          * Report a restricted path specifically when using the '*' import.
-         * @param {string} importSource - path of the import
-         * @param {node} node - representing the restricted path reference
+         * @param {string} importSource path of the import
+         * @param {node} node representing the restricted path reference
          * @returns {void}
          * @private
          */
@@ -185,8 +185,8 @@ module.exports = {
 
         /**
          * Check if the given importSource is restricted because '*' is being imported.
-         * @param {string} importSource - path of the import
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {string} importSource path of the import
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether the path is restricted
          * @private
          */
@@ -198,8 +198,8 @@ module.exports = {
 
         /**
          * Check if the given importNames are restricted given a list of restrictedImportNames.
-         * @param {Set.<string>} importNames - Set of import names that are being imported
-         * @param {string[]} restrictedImportNames - array of import names that are restricted for this import
+         * @param {Set.<string>} importNames Set of import names that are being imported
+         * @param {string[]} restrictedImportNames array of import names that are restricted for this import
          * @returns {boolean} whether the objectName is restricted
          * @private
          */
@@ -211,8 +211,8 @@ module.exports = {
 
         /**
          * Check if the given importSource is a restricted path.
-         * @param {string} importSource - path of the import
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {string} importSource path of the import
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether the variable is a restricted path or not
          * @private
          */
@@ -232,7 +232,7 @@ module.exports = {
 
         /**
          * Check if the given importSource is restricted by a pattern.
-         * @param {string} importSource - path of the import
+         * @param {string} importSource path of the import
          * @returns {boolean} whether the variable is a restricted pattern or not
          * @private
          */