eslint 8.27.0 → 8.29.0

package/lib/eslint/eslint-helpers.js

@@ -26,6 +26,7 @@ const isPathInside = require("is-path-inside");
 
 const doFsWalk = util.promisify(fswalk.walk);
 const Minimatch = minimatch.Minimatch;
+const MINIMATCH_OPTIONS = { dot: true };
 
 //-----------------------------------------------------------------------------
 // Types
@@ -76,7 +77,7 @@ class UnmatchedSearchPatternsError extends Error {
     constructor({ basePath, unmatchedPatterns, patterns, rawPatterns }) {
         super(`No files matching '${rawPatterns}' in '${basePath}' were found.`);
         this.basePath = basePath;
-        this.patternsToCheck = unmatchedPatterns;
+        this.unmatchedPatterns = unmatchedPatterns;
         this.patterns = patterns;
         this.rawPatterns = rawPatterns;
     }
@@ -158,7 +159,7 @@ function globMatch({ basePath, pattern }) {
         ? normalizeToPosix(path.relative(basePath, pattern))
         : pattern;
 
-    const matcher = new Minimatch(patternToUse);
+    const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 
     const fsWalkSettings = {
 
@@ -257,7 +258,7 @@ async function globSearch({
 
         relativeToPatterns.set(patternToUse, patterns[i]);
 
-        return new minimatch.Minimatch(patternToUse);
+        return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
     });
 
     /*
@@ -337,49 +338,43 @@ async function globSearch({
 }
 
 /**
- * Checks to see if there are any ignored results for a given search. This
- * happens either when there are unmatched patterns during a search or if
- * a search returns no results.
+ * Throws an error for unmatched patterns. The error will only contain information about the first one.
+ * Checks to see if there are any ignored results for a given search.
  * @param {Object} options The options for this function.
  * @param {string} options.basePath The directory to search.
  * @param {Array<string>} options.patterns An array of glob patterns
  *      that were used in the original search.
  * @param {Array<string>} options.rawPatterns An array of glob patterns
  *      as the user inputted them. Used for errors.
- * @param {Array<string>} options.patternsToCheck An array of glob patterns
- *      to use for this check.
- * @returns {void}
- * @throws {NoFilesFoundError} If there is a pattern that doesn't match
- *      any files and `errorOnUnmatchedPattern` is true.
- * @throws {AllFilesIgnoredError} If there is a pattern that matches files
- *      when there are no ignores.
+ * @param {Array<string>} options.unmatchedPatterns A non-empty array of glob patterns
+ *      that were unmatched in the original search.
+ * @returns {void} Always throws an error.
+ * @throws {NoFilesFoundError} If the first unmatched pattern
+ *      doesn't match any files even when there are no ignores.
+ * @throws {AllFilesIgnoredError} If the first unmatched pattern
+ *      matches some files when there are no ignores.
  */
-async function checkForIgnoredResults({
+async function throwErrorForUnmatchedPatterns({
     basePath,
     patterns,
     rawPatterns,
-    patternsToCheck = patterns
+    unmatchedPatterns
 }) {
 
-    for (const pattern of patternsToCheck) {
+    const pattern = unmatchedPatterns[0];
+    const rawPattern = rawPatterns[patterns.indexOf(pattern)];
 
-        const patternHasMatch = await globMatch({
-            basePath,
-            pattern
-        });
+    const patternHasMatch = await globMatch({
+        basePath,
+        pattern
+    });
 
-        if (patternHasMatch) {
-            throw new AllFilesIgnoredError(
-                rawPatterns[patterns.indexOf(pattern)]
-            );
-        }
+    if (patternHasMatch) {
+        throw new AllFilesIgnoredError(rawPattern);
     }
 
     // if we get here there are truly no matches
-    throw new NoFilesFoundError(
-        rawPatterns[patterns.indexOf(patternsToCheck[0])],
-        true
-    );
+    throw new NoFilesFoundError(rawPattern, true);
 }
 
 /**
@@ -446,9 +441,9 @@ async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
 
         if (errorOnUnmatchedPattern) {
 
-            await checkForIgnoredResults({
+            await throwErrorForUnmatchedPatterns({
                 ...currentSearch,
-                patternsToCheck: error.patternsToCheck
+                unmatchedPatterns: error.unmatchedPatterns
             });
 
         }

package/lib/rules/for-direction.js

@@ -15,7 +15,7 @@ module.exports = {
         type: "problem",
 
         docs: {
-            description: "Enforce \"for\" loop update clause moving the counter in the right direction.",
+            description: "Enforce \"for\" loop update clause moving the counter in the right direction",
             recommended: true,
             url: "https://eslint.org/docs/rules/for-direction"
         },

package/lib/rules/key-spacing.js

@@ -334,6 +334,19 @@ module.exports = {
 
         const sourceCode = context.getSourceCode();
 
+        /**
+         * Determines if the given property is key-value property.
+         * @param {ASTNode} property Property node to check.
+         * @returns {boolean} Whether the property is a key-value property.
+         */
+        function isKeyValueProperty(property) {
+            return !(
+                (property.method ||
+                property.shorthand ||
+                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+            );
+        }
+
         /**
          * Checks whether a property is a member of the property group it follows.
          * @param {ASTNode} lastMember The last Property known to be in the group.
@@ -342,9 +355,9 @@ module.exports = {
          */
         function continuesPropertyGroup(lastMember, candidate) {
             const groupEndLine = lastMember.loc.start.line,
-                candidateStartLine = candidate.loc.start.line;
+                candidateValueStartLine = (isKeyValueProperty(candidate) ? candidate.value : candidate).loc.start.line;
 
-            if (candidateStartLine - groupEndLine <= 1) {
+            if (candidateValueStartLine - groupEndLine <= 1) {
                 return true;
             }
 
@@ -358,7 +371,7 @@ module.exports = {
             if (
                 leadingComments.length &&
                 leadingComments[0].loc.start.line - groupEndLine <= 1 &&
-                candidateStartLine - last(leadingComments).loc.end.line <= 1
+                candidateValueStartLine - last(leadingComments).loc.end.line <= 1
             ) {
                 for (let i = 1; i < leadingComments.length; i++) {
                     if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
@@ -371,19 +384,6 @@ module.exports = {
             return false;
         }
 
-        /**
-         * Determines if the given property is key-value property.
-         * @param {ASTNode} property Property node to check.
-         * @returns {boolean} Whether the property is a key-value property.
-         */
-        function isKeyValueProperty(property) {
-            return !(
-                (property.method ||
-                property.shorthand ||
-                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
-            );
-        }
-
         /**
          * Starting from the given a node (a property.key node here) looks forward
          * until it finds the last token before a colon punctuator and returns it.

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

@@ -52,7 +52,8 @@ module.exports = {
                                 enforceForArrowConditionals: { type: "boolean" },
                                 enforceForSequenceExpressions: { type: "boolean" },
                                 enforceForNewInMemberExpressions: { type: "boolean" },
-                                enforceForFunctionPrototypeMethods: { type: "boolean" }
+                                enforceForFunctionPrototypeMethods: { type: "boolean" },
+                                allowParensAfterCommentPattern: { type: "string" }
                             },
                             additionalProperties: false
                         }
@@ -86,6 +87,7 @@ module.exports = {
             context.options[1].enforceForNewInMemberExpressions === false;
         const IGNORE_FUNCTION_PROTOTYPE_METHODS = ALL_NODES && context.options[1] &&
             context.options[1].enforceForFunctionPrototypeMethods === false;
+        const ALLOW_PARENS_AFTER_COMMENT_PATTERN = ALL_NODES && context.options[1] && context.options[1].allowParensAfterCommentPattern;
 
         const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
         const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" });
@@ -402,6 +404,19 @@ module.exports = {
                 if (isIIFE(node) && !isParenthesised(node.callee)) {
                     return;
                 }
+
+                if (ALLOW_PARENS_AFTER_COMMENT_PATTERN) {
+                    const commentsBeforeLeftParenToken = sourceCode.getCommentsBefore(leftParenToken);
+                    const totalCommentsBeforeLeftParenTokenCount = commentsBeforeLeftParenToken.length;
+                    const ignorePattern = new RegExp(ALLOW_PARENS_AFTER_COMMENT_PATTERN, "u");
+
+                    if (
+                        totalCommentsBeforeLeftParenTokenCount > 0 &&
+                        ignorePattern.test(commentsBeforeLeftParenToken[totalCommentsBeforeLeftParenTokenCount - 1].value)
+                    ) {
+                        return;
+                    }
+                }
             }
 
             /**

package/lib/rules/no-implicit-coercion.js

@@ -71,6 +71,24 @@ function isMultiplyByOne(node) {
     );
 }
 
+/**
+ * Checks whether the given node logically represents multiplication by a fraction of `1`.
+ * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
+ * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
+ * @param {SourceCode} sourceCode The source code object.
+ * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
+ */
+function isMultiplyByFractionOfOne(node, sourceCode) {
+    return node.type === "BinaryExpression" &&
+        node.operator === "*" &&
+        (node.right.type === "Literal" && node.right.value === 1) &&
+        node.parent.type === "BinaryExpression" &&
+        node.parent.operator === "/" &&
+        node.parent.left === node &&
+        !astUtils.isParenthesised(sourceCode, node);
+}
+
 /**
  * Checks whether the result of a node is numeric or not
  * @param {ASTNode} node The node to test
@@ -290,7 +308,8 @@ module.exports = {
 
                 // 1 * foo
                 operatorAllowed = options.allow.includes("*");
-                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);
+                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
+                    getNonNumericOperand(node);
 
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;

package/lib/rules/no-invalid-regexp.js

@@ -59,6 +59,20 @@ module.exports = {
             }
         }
 
+        /**
+         * Reports error with the provided message.
+         * @param {ASTNode} node The node holding the invalid RegExp
+         * @param {string} message The message to report.
+         * @returns {void}
+         */
+        function report(node, message) {
+            context.report({
+                node,
+                messageId: "regexMessage",
+                data: { message }
+            });
+        }
+
         /**
          * Check if node is a string
          * @param {ASTNode} node node to evaluate
@@ -108,10 +122,13 @@ module.exports = {
 
         /**
          * Check syntax error in a given flags.
-         * @param {string} flags The RegExp flags to validate.
+         * @param {string|null} flags The RegExp flags to validate.
          * @returns {string|null} The syntax error.
          */
         function validateRegExpFlags(flags) {
+            if (!flags) {
+                return null;
+            }
             try {
                 validator.validateFlags(flags);
                 return null;
@@ -122,34 +139,39 @@ module.exports = {
 
         return {
             "CallExpression, NewExpression"(node) {
-                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp" || !isString(node.arguments[0])) {
+                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") {
                     return;
                 }
-                const pattern = node.arguments[0].value;
+
                 let flags = getFlags(node);
 
                 if (flags && allowedFlags) {
                     flags = flags.replace(allowedFlags, "");
                 }
 
-                const message =
-                    (
-                        flags && validateRegExpFlags(flags)
-                    ) ||
-                    (
+                let message = validateRegExpFlags(flags);
+
+                if (message) {
+                    report(node, message);
+                    return;
+                }
+
+                if (!isString(node.arguments[0])) {
+                    return;
+                }
+
+                const pattern = node.arguments[0].value;
+
+                message = (
 
-                        // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
-                        flags === null
-                            ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
-                            : validateRegExpPattern(pattern, flags.includes("u"))
-                    );
+                    // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
+                    flags === null
+                        ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
+                        : validateRegExpPattern(pattern, flags.includes("u"))
+                );
 
                 if (message) {
-                    context.report({
-                        node,
-                        messageId: "regexMessage",
-                        data: { message }
-                    });
+                    report(node, message);
                 }
             }
         };

package/lib/rules/no-magic-numbers.js

@@ -65,6 +65,10 @@ module.exports = {
                 ignoreDefaultValues: {
                     type: "boolean",
                     default: false
+                },
+                ignoreClassFieldInitialValues: {
+                    type: "boolean",
+                    default: false
                 }
             },
             additionalProperties: false
@@ -82,7 +86,8 @@ module.exports = {
             enforceConst = !!config.enforceConst,
             ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes,
-            ignoreDefaultValues = !!config.ignoreDefaultValues;
+            ignoreDefaultValues = !!config.ignoreDefaultValues,
+            ignoreClassFieldInitialValues = !!config.ignoreClassFieldInitialValues;
 
         const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
@@ -106,6 +111,17 @@ module.exports = {
             return parent.type === "AssignmentPattern" && parent.right === fullNumberNode;
         }
 
+        /**
+         * Returns whether the number is the initial value of a class field.
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the number is the initial value of a class field.
+         */
+        function isClassFieldInitialValue(fullNumberNode) {
+            const parent = fullNumberNode.parent;
+
+            return parent.type === "PropertyDefinition" && parent.value === fullNumberNode;
+        }
+
         /**
          * Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
          * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
@@ -194,6 +210,7 @@ module.exports = {
                 if (
                     isIgnoredValue(value) ||
                     (ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
+                    (ignoreClassFieldInitialValues && isClassFieldInitialValue(fullNumberNode)) ||
                     isParseIntRadix(fullNumberNode) ||
                     isJSXNumber(fullNumberNode) ||
                     (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))

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

@@ -16,7 +16,7 @@ const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 // Helpers
 //------------------------------------------------------------------------------
 
-const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
+const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
 
 /**
  * Returns the name of the node to report

package/lib/rules/prefer-named-capture-group.js

@@ -23,6 +23,61 @@ const regexpp = require("regexpp");
 
 const parser = new regexpp.RegExpParser();
 
+/**
+ * Creates fixer suggestions for the regex, if statically determinable.
+ * @param {number} groupStart Starting index of the regex group.
+ * @param {string} pattern The regular expression pattern to be checked.
+ * @param {string} rawText Source text of the regexNode.
+ * @param {ASTNode} regexNode AST node which contains the regular expression.
+ * @returns {Array<SuggestionResult>} Fixer suggestions for the regex, if statically determinable.
+ */
+function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
+    switch (regexNode.type) {
+        case "Literal":
+            if (typeof regexNode.value === "string" && rawText.includes("\\")) {
+                return null;
+            }
+            break;
+        case "TemplateLiteral":
+            if (regexNode.expressions.length || rawText.slice(1, -1) !== pattern) {
+                return null;
+            }
+            break;
+        default:
+            return null;
+    }
+
+    const start = regexNode.range[0] + groupStart + 2;
+
+    return [
+        {
+            fix(fixer) {
+                const existingTemps = pattern.match(/temp\d+/gu) || [];
+                const highestTempCount = existingTemps.reduce(
+                    (previous, next) =>
+                        Math.max(previous, Number(next.slice("temp".length))),
+                    0
+                );
+
+                return fixer.insertTextBeforeRange(
+                    [start, start],
+                    `?<temp${highestTempCount + 1}>`
+                );
+            },
+            messageId: "addGroupName"
+        },
+        {
+            fix(fixer) {
+                return fixer.insertTextBeforeRange(
+                    [start, start],
+                    "?:"
+                );
+            },
+            messageId: "addNonCapture"
+        }
+    ];
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -38,23 +93,29 @@ module.exports = {
             url: "https://eslint.org/docs/rules/prefer-named-capture-group"
         },
 
+        hasSuggestions: true,
+
         schema: [],
 
         messages: {
+            addGroupName: "Add name to capture group.",
+            addNonCapture: "Convert group to non-capturing.",
             required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
         }
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         /**
          * Function to check regular expression.
-         * @param {string} pattern The regular expression pattern to be check.
-         * @param {ASTNode} node AST node which contains regular expression.
+         * @param {string} pattern The regular expression pattern to be checked.
+         * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
+         * @param {ASTNode} regexNode AST node which contains the regular expression.
          * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
          * @returns {void}
          */
-        function checkRegex(pattern, node, uFlag) {
+        function checkRegex(pattern, node, regexNode, uFlag) {
             let ast;
 
             try {
@@ -68,12 +129,16 @@ module.exports = {
             regexpp.visitRegExpAST(ast, {
                 onCapturingGroupEnter(group) {
                     if (!group.name) {
+                        const rawText = sourceCode.getText(regexNode);
+                        const suggest = suggestIfPossible(group.start, pattern, rawText, regexNode);
+
                         context.report({
                             node,
                             messageId: "required",
                             data: {
                                 group: group.raw
-                            }
+                            },
+                            suggest
                         });
                     }
                 }
@@ -83,7 +148,7 @@ module.exports = {
         return {
             Literal(node) {
                 if (node.regex) {
-                    checkRegex(node.regex.pattern, node, node.regex.flags.includes("u"));
+                    checkRegex(node.regex.pattern, node, node, node.regex.flags.includes("u"));
                 }
             },
             Program() {
@@ -101,7 +166,7 @@ module.exports = {
                     const flags = getStringIfConstant(node.arguments[1]);
 
                     if (regex) {
-                        checkRegex(regex, node, flags && flags.includes("u"));
+                        checkRegex(regex, node, node.arguments[0], flags && flags.includes("u"));
                     }
                 }
             }

package/lib/rules/prefer-object-spread.js

@@ -247,7 +247,7 @@ module.exports = {
 
         docs: {
             description:
-                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.",
+                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead",
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-object-spread"
         },

package/lib/shared/runtime-info.js

@@ -97,7 +97,7 @@ function environment() {
      */
     function getNpmPackageVersion(pkg, { global = false } = {}) {
         const npmBinArgs = ["bin", "-g"];
-        const npmLsArgs = ["ls", "--depth=0", "--json", "eslint"];
+        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
 
         if (global) {
             npmLsArgs.push("-g");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.27.0",
+  "version": "8.29.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {