eslint 8.19.0 → 8.22.0

package/lib/eslint/index.js

@@ -1,7 +1,9 @@
 "use strict";
 
 const { ESLint } = require("./eslint");
+const { FlatESLint } = require("./flat-eslint");
 
 module.exports = {
-    ESLint
+    ESLint,
+    FlatESLint
 };

package/lib/linter/linter.js

@@ -1510,7 +1510,31 @@ class Linter {
             options.filterCodeBlock ||
             (blockFilename => blockFilename.endsWith(".js"));
         const originalExtname = path.extname(filename);
-        const messageLists = preprocess(text, filenameToExpose).map((block, i) => {
+
+        let blocks;
+
+        try {
+            blocks = preprocess(text, filenameToExpose);
+        } catch (ex) {
+
+            // If the message includes a leading line number, strip it:
+            const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
+
+            debug("%s\n%s", message, ex.stack);
+
+            return [
+                {
+                    ruleId: null,
+                    fatal: true,
+                    severity: 2,
+                    message,
+                    line: ex.lineNumber,
+                    column: ex.column
+                }
+            ];
+        }
+
+        const messageLists = blocks.map((block, i) => {
             debug("A code block was found: %o", block.filename || "(unnamed)");
 
             // Keep the legacy behavior.
@@ -1584,6 +1608,11 @@ class Linter {
             ...languageOptions.globals
         };
 
+        // double check that there is a parser to avoid mysterious error messages
+        if (!languageOptions.parser) {
+            throw new TypeError(`No parser specified for ${options.filename}`);
+        }
+
         // Espree expects this information to be passed in
         if (isEspree(languageOptions.parser)) {
             const parserOptions = languageOptions.parserOptions;
@@ -1746,12 +1775,24 @@ class Linter {
         debug("With flat config: %s", options.filename);
 
         // we need a filename to match configs against
-        const filename = options.filename || "<input>";
+        const filename = options.filename || "__placeholder__.js";
 
         // Store the config array in order to get plugin envs and rules later.
         internalSlotsMap.get(this).lastConfigArray = configArray;
         const config = configArray.getConfig(filename);
 
+        if (!config) {
+            return [
+                {
+                    ruleId: null,
+                    severity: 1,
+                    message: `No matching configuration found for ${filename}.`,
+                    line: 0,
+                    column: 0
+                }
+            ];
+        }
+
         // Verify.
         if (config.processor) {
             debug("Apply the processor: %o", config.processor);
@@ -1788,13 +1829,36 @@ class Linter {
         const physicalFilename = options.physicalFilename || filenameToExpose;
         const text = ensureText(textOrSourceCode);
         const preprocess = options.preprocess || (rawText => [rawText]);
-
         const postprocess = options.postprocess || (messagesList => messagesList.flat());
         const filterCodeBlock =
             options.filterCodeBlock ||
             (blockFilename => blockFilename.endsWith(".js"));
         const originalExtname = path.extname(filename);
-        const messageLists = preprocess(text, filenameToExpose).map((block, i) => {
+
+        let blocks;
+
+        try {
+            blocks = preprocess(text, filenameToExpose);
+        } catch (ex) {
+
+            // If the message includes a leading line number, strip it:
+            const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
+
+            debug("%s\n%s", message, ex.stack);
+
+            return [
+                {
+                    ruleId: null,
+                    fatal: true,
+                    severity: 2,
+                    message,
+                    line: ex.lineNumber,
+                    column: ex.column
+                }
+            ];
+        }
+
+        const messageLists = blocks.map((block, i) => {
             debug("A code block was found: %o", block.filename || "(unnamed)");
 
             // Keep the legacy behavior.

package/lib/rule-tester/flat-rule-tester.js

@@ -480,51 +480,54 @@ class FlatRuleTester {
             ].concat(scenarioErrors).join("\n"));
         }
 
-        const baseConfig = {
-            plugins: {
-
-                // copy root plugin over
-                "@": {
-
-                    /*
-                     * Parsers are wrapped to detect more errors, so this needs
-                     * to be a new object for each call to run(), otherwise the
-                     * parsers will be wrapped multiple times.
-                     */
-                    parsers: {
-                        ...defaultConfig[0].plugins["@"].parsers
-                    },
+        const baseConfig = [
+            {
+                plugins: {
 
-                    /*
-                     * The rules key on the default plugin is a proxy to lazy-load
-                     * just the rules that are needed. So, don't create a new object
-                     * here, just use the default one to keep that performance
-                     * enhancement.
-                     */
-                    rules: defaultConfig[0].plugins["@"].rules
-                },
-                "rule-to-test": {
-                    rules: {
-                        [ruleName]: Object.assign({}, rule, {
+                    // copy root plugin over
+                    "@": {
+
+                        /*
+                         * Parsers are wrapped to detect more errors, so this needs
+                         * to be a new object for each call to run(), otherwise the
+                         * parsers will be wrapped multiple times.
+                         */
+                        parsers: {
+                            ...defaultConfig[0].plugins["@"].parsers
+                        },
+
+                        /*
+                         * The rules key on the default plugin is a proxy to lazy-load
+                         * just the rules that are needed. So, don't create a new object
+                         * here, just use the default one to keep that performance
+                         * enhancement.
+                         */
+                        rules: defaultConfig[0].plugins["@"].rules
+                    },
+                    "rule-to-test": {
+                        rules: {
+                            [ruleName]: Object.assign({}, rule, {
 
-                            // Create a wrapper rule that freezes the `context` properties.
-                            create(context) {
-                                freezeDeeply(context.options);
-                                freezeDeeply(context.settings);
-                                freezeDeeply(context.parserOptions);
+                                // Create a wrapper rule that freezes the `context` properties.
+                                create(context) {
+                                    freezeDeeply(context.options);
+                                    freezeDeeply(context.settings);
+                                    freezeDeeply(context.parserOptions);
 
-                                // freezeDeeply(context.languageOptions);
+                                    // freezeDeeply(context.languageOptions);
 
-                                return (typeof rule === "function" ? rule : rule.create)(context);
-                            }
-                        })
+                                    return (typeof rule === "function" ? rule : rule.create)(context);
+                                }
+                            })
+                        }
                     }
+                },
+                languageOptions: {
+                    ...defaultConfig[0].languageOptions
                 }
             },
-            languageOptions: {
-                ...defaultConfig[0].languageOptions
-            }
-        };
+            ...defaultConfig.slice(1)
+        ];
 
         /**
          * Run the rule for the given item

package/lib/rule-tester/rule-tester.js

@@ -305,6 +305,36 @@ function getCommentsDeprecation() {
     );
 }
 
+/**
+ * Emit a deprecation warning if function-style format is being used.
+ * @param {string} ruleName Name of the rule.
+ * @returns {void}
+ */
+function emitLegacyRuleAPIWarning(ruleName) {
+    if (!emitLegacyRuleAPIWarning[`warned-${ruleName}`]) {
+        emitLegacyRuleAPIWarning[`warned-${ruleName}`] = true;
+        process.emitWarning(
+            `"${ruleName}" rule is using the deprecated function-style format and will stop working in ESLint v9. Please use object-style format: https://eslint.org/docs/developer-guide/working-with-rules`,
+            "DeprecationWarning"
+        );
+    }
+}
+
+/**
+ * Emit a deprecation warning if rule has options but is missing the "meta.schema" property
+ * @param {string} ruleName Name of the rule.
+ * @returns {void}
+ */
+function emitMissingSchemaWarning(ruleName) {
+    if (!emitMissingSchemaWarning[`warned-${ruleName}`]) {
+        emitMissingSchemaWarning[`warned-${ruleName}`] = true;
+        process.emitWarning(
+            `"${ruleName}" rule has options but is missing the "meta.schema" property and will stop working in ESLint v9. Please add a schema: https://eslint.org/docs/developer-guide/working-with-rules#options-schemas`,
+            "DeprecationWarning"
+        );
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -521,6 +551,9 @@ class RuleTester {
             ].concat(scenarioErrors).join("\n"));
         }
 
+        if (typeof rule === "function") {
+            emitLegacyRuleAPIWarning(ruleName);
+        }
 
         linter.defineRule(ruleName, Object.assign({}, rule, {
 
@@ -578,6 +611,15 @@ class RuleTester {
 
             if (hasOwnProperty(item, "options")) {
                 assert(Array.isArray(item.options), "options must be an array");
+                if (
+                    item.options.length > 0 &&
+                    typeof rule === "object" &&
+                    (
+                        !rule.meta || (rule.meta && (typeof rule.meta.schema === "undefined" || rule.meta.schema === null))
+                    )
+                ) {
+                    emitMissingSchemaWarning(ruleName);
+                }
                 config.rules[ruleName] = [1].concat(item.options);
             } else {
                 config.rules[ruleName] = 1;

package/lib/rules/comma-spacing.js

@@ -103,38 +103,6 @@ module.exports = {
             });
         }
 
-        /**
-         * Validates the spacing around a comma token.
-         * @param {Object} tokens The tokens to be validated.
-         * @param {Token} tokens.comma The token representing the comma.
-         * @param {Token} [tokens.left] The last token before the comma.
-         * @param {Token} [tokens.right] The first token after the comma.
-         * @param {Token|ASTNode} reportItem The item to use when reporting an error.
-         * @returns {void}
-         * @private
-         */
-        function validateCommaItemSpacing(tokens, reportItem) {
-            if (tokens.left && astUtils.isTokenOnSameLine(tokens.left, tokens.comma) &&
-                    (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))
-            ) {
-                report(reportItem, "before", tokens.left);
-            }
-
-            if (tokens.right && astUtils.isClosingParenToken(tokens.right)) {
-                return;
-            }
-
-            if (tokens.right && !options.after && tokens.right.type === "Line") {
-                return;
-            }
-
-            if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
-                    (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
-            ) {
-                report(reportItem, "after", tokens.right);
-            }
-        }
-
         /**
          * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
          * @param {ASTNode} node An ArrayExpression or ArrayPattern node.
@@ -172,18 +140,44 @@ module.exports = {
                         return;
                     }
 
-                    if (token && token.type === "JSXText") {
-                        return;
-                    }
-
                     const previousToken = tokensAndComments[i - 1];
                     const nextToken = tokensAndComments[i + 1];
 
-                    validateCommaItemSpacing({
-                        comma: token,
-                        left: astUtils.isCommaToken(previousToken) || commaTokensToIgnore.includes(token) ? null : previousToken,
-                        right: astUtils.isCommaToken(nextToken) ? null : nextToken
-                    }, token);
+                    if (
+                        previousToken &&
+                        !astUtils.isCommaToken(previousToken) && // ignore spacing between two commas
+
+                        /*
+                         * `commaTokensToIgnore` are ending commas of `null` elements (array holes/elisions).
+                         * In addition to spacing between two commas, this can also ignore:
+                         *
+                         *   - Spacing after `[` (controlled by array-bracket-spacing)
+                         *       Example: [ , ]
+                         *                 ^
+                         *   - Spacing after a comment (for backwards compatibility, this was possibly unintentional)
+                         *       Example: [a, /* * / ,]
+                         *                          ^
+                         */
+                        !commaTokensToIgnore.includes(token) &&
+
+                        astUtils.isTokenOnSameLine(previousToken, token) &&
+                        options.before !== sourceCode.isSpaceBetweenTokens(previousToken, token)
+                    ) {
+                        report(token, "before", previousToken);
+                    }
+
+                    if (
+                        nextToken &&
+                        !astUtils.isCommaToken(nextToken) && // ignore spacing between two commas
+                        !astUtils.isClosingParenToken(nextToken) && // controlled by space-in-parens
+                        !astUtils.isClosingBracketToken(nextToken) && // controlled by array-bracket-spacing
+                        !astUtils.isClosingBraceToken(nextToken) && // controlled by object-curly-spacing
+                        !(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
+                        astUtils.isTokenOnSameLine(token, nextToken) &&
+                        options.after !== sourceCode.isSpaceBetweenTokens(token, nextToken)
+                    ) {
+                        report(token, "after", nextToken);
+                    }
                 });
             },
             ArrayExpression: addNullElementsToIgnoreList,

package/lib/rules/key-spacing.js

@@ -9,6 +9,9 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const GraphemeSplitter = require("grapheme-splitter");
+
+const splitter = new GraphemeSplitter();
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -508,7 +511,7 @@ module.exports = {
             const startToken = sourceCode.getFirstToken(property);
             const endToken = getLastTokenBeforeColon(property.key);
 
-            return endToken.range[1] - startToken.range[0];
+            return splitter.countGraphemes(sourceCode.getText().slice(startToken.range[0], endToken.range[1]));
         }
 
         /**

package/lib/rules/lines-around-comment.js

@@ -231,9 +231,15 @@ module.exports = {
             const parent = getParentNodeOfToken(token);
 
             if (parent && isParentNodeType(parent, nodeType)) {
-                const parentStartNodeOrToken = parent.type === "StaticBlock"
-                    ? sourceCode.getFirstToken(parent, { skip: 1 }) // opening brace of the static block
-                    : parent;
+                let parentStartNodeOrToken = parent;
+
+                if (parent.type === "StaticBlock") {
+                    parentStartNodeOrToken = sourceCode.getFirstToken(parent, { skip: 1 }); // opening brace of the static block
+                } else if (parent.type === "SwitchStatement") {
+                    parentStartNodeOrToken = sourceCode.getTokenAfter(parent.discriminant, {
+                        filter: astUtils.isOpeningBraceToken
+                    }); // opening brace of the switch statement
+                }
 
                 return token.loc.start.line - parentStartNodeOrToken.loc.start.line === 1;
             }
@@ -264,7 +270,8 @@ module.exports = {
                 isCommentAtParentStart(token, "ClassBody") ||
                 isCommentAtParentStart(token, "BlockStatement") ||
                 isCommentAtParentStart(token, "StaticBlock") ||
-                isCommentAtParentStart(token, "SwitchCase")
+                isCommentAtParentStart(token, "SwitchCase") ||
+                isCommentAtParentStart(token, "SwitchStatement")
             );
         }
 

package/lib/rules/no-warning-comments.js

@@ -64,59 +64,45 @@ module.exports = {
          */
         function convertToRegExp(term) {
             const escaped = escapeRegExp(term);
-            const wordBoundary = "\\b";
-            const eitherOrWordBoundary = `|${wordBoundary}`;
-            let prefix;
 
             /*
-             * If the term ends in a word character (a-z0-9_), ensure a word
-             * boundary at the end, so that substrings do not get falsely
-             * matched. eg "todo" in a string such as "mastodon".
-             * If the term ends in a non-word character, then \b won't match on
-             * the boundary to the next non-word character, which would likely
-             * be a space. For example `/\bFIX!\b/.test('FIX! blah') === false`.
-             * In these cases, use no bounding match. Same applies for the
-             * prefix, handled below.
+             * When matching at the start, ignore leading whitespace, and
+             * there's no need to worry about word boundaries.
+             *
+             * These expressions for the prefix and suffix are designed as follows:
+             * ^   handles any terms at the beginning of a comment.
+             *     e.g. terms ["TODO"] matches `//TODO something`
+             * $   handles any terms at the end of a comment
+             *     e.g. terms ["TODO"] matches `// something TODO`
+             * \s* handles optional leading spaces (for "start" location only)
+             *     e.g. terms ["TODO"] matches `//    TODO something`
+             * \b  handles terms preceded/followed by word boundary
+             *     e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX`
+             *          terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix`
              */
-            const suffix = /\w$/u.test(term) ? "\\b" : "";
+            const wordBoundary = "\\b";
 
-            if (location === "start") {
+            let prefix = "";
 
-                /*
-                 * When matching at the start, ignore leading whitespace, and
-                 * there's no need to worry about word boundaries.
-                 */
+            if (location === "start") {
                 prefix = "^\\s*";
             } else if (/^\w/u.test(term)) {
                 prefix = wordBoundary;
-            } else {
-                prefix = "";
             }
 
-            if (location === "start") {
-
-                /*
-                 * For location "start" the regex should be
-                 * ^\s*TERM\b.  This checks the word boundary
-                 * at the beginning of the comment.
-                 */
-                return new RegExp(prefix + escaped + suffix, "iu");
-            }
+            const suffix = /\w$/u.test(term) ? wordBoundary : "";
+            const flags = "iu"; // Case-insensitive with Unicode case folding.
 
             /*
-             * For location "anywhere" the regex should be
-             * \bTERM\b|\bTERM\b, this checks the entire comment
-             * for the term.
+             * For location "start", the typical regex is:
+             *   /^\s*ESCAPED_TERM\b/iu.
+             *
+             * For location "anywhere" the typical regex is
+             *   /\bESCAPED_TERM\b/iu
+             *
+             * If it starts or ends with non-word character, the prefix and suffix empty, respectively.
              */
-            return new RegExp(
-                prefix +
-                    escaped +
-                    suffix +
-                    eitherOrWordBoundary +
-                    term +
-                    wordBoundary,
-                "iu"
-            );
+            return new RegExp(`${prefix}${escaped}${suffix}`, flags);
         }
 
         const warningRegExps = warningTerms.map(convertToRegExp);

package/lib/rules/object-shorthand.js

@@ -78,6 +78,9 @@ module.exports = {
                                 ignoreConstructors: {
                                     type: "boolean"
                                 },
+                                methodsIgnorePattern: {
+                                    type: "string"
+                                },
                                 avoidQuotes: {
                                     type: "boolean"
                                 },
@@ -115,6 +118,9 @@ module.exports = {
 
         const PARAMS = context.options[1] || {};
         const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors;
+        const METHODS_IGNORE_PATTERN = PARAMS.methodsIgnorePattern
+            ? new RegExp(PARAMS.methodsIgnorePattern, "u")
+            : null;
         const AVOID_QUOTES = PARAMS.avoidQuotes;
         const AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows;
         const sourceCode = context.getSourceCode();
@@ -457,6 +463,15 @@ module.exports = {
                     if (IGNORE_CONSTRUCTORS && node.key.type === "Identifier" && isConstructor(node.key.name)) {
                         return;
                     }
+
+                    if (METHODS_IGNORE_PATTERN) {
+                        const propertyName = astUtils.getStaticPropertyName(node);
+
+                        if (propertyName !== null && METHODS_IGNORE_PATTERN.test(propertyName)) {
+                            return;
+                        }
+                    }
+
                     if (AVOID_QUOTES && isStringLiteral(node.key)) {
                         return;
                     }

package/lib/rules/sort-keys.js

@@ -105,6 +105,10 @@ module.exports = {
                         type: "integer",
                         minimum: 2,
                         default: 2
+                    },
+                    allowLineSeparatedGroups: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -124,17 +128,21 @@ module.exports = {
         const insensitive = options && options.caseSensitive === false;
         const natural = options && options.natural;
         const minKeys = options && options.minKeys;
+        const allowLineSeparatedGroups = options && options.allowLineSeparatedGroups || false;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natural ? "N" : "")
         ];
 
         // The stack to save the previous property's name for each object literals.
         let stack = null;
+        const sourceCode = context.getSourceCode();
 
         return {
             ObjectExpression(node) {
                 stack = {
                     upper: stack,
+                    prevNode: null,
+                    prevBlankLine: false,
                     prevName: null,
                     numKeys: node.properties.length
                 };
@@ -159,10 +167,45 @@ module.exports = {
                 const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);
 
+                // Get tokens between current node and previous node
+                const tokens = stack.prevNode && sourceCode
+                    .getTokensBetween(stack.prevNode, node, { includeComments: true });
+
+                let isBlankLineBetweenNodes = stack.prevBlankLine;
+
+                if (tokens) {
+
+                    // check blank line between tokens
+                    tokens.forEach((token, index) => {
+                        const previousToken = tokens[index - 1];
+
+                        if (previousToken && (token.loc.start.line - previousToken.loc.end.line > 1)) {
+                            isBlankLineBetweenNodes = true;
+                        }
+                    });
+
+                    // check blank line between the current node and the last token
+                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens[tokens.length - 1].loc.end.line > 1)) {
+                        isBlankLineBetweenNodes = true;
+                    }
+
+                    // check blank line between the first token and the previous node
+                    if (!isBlankLineBetweenNodes && (tokens[0].loc.start.line - stack.prevNode.loc.end.line > 1)) {
+                        isBlankLineBetweenNodes = true;
+                    }
+                }
+
+                stack.prevNode = node;
+
                 if (thisName !== null) {
                     stack.prevName = thisName;
                 }
 
+                if (allowLineSeparatedGroups && isBlankLineBetweenNodes) {
+                    stack.prevBlankLine = thisName === null;
+                    return;
+                }
+
                 if (prevName === null || thisName === null || numKeys < minKeys) {
                     return;
                 }

package/lib/unsupported-api.js

@@ -12,6 +12,8 @@
 //-----------------------------------------------------------------------------
 
 const { FileEnumerator } = require("./cli-engine/file-enumerator");
+const { FlatESLint } = require("./eslint/flat-eslint");
+const FlatRuleTester = require("./rule-tester/flat-rule-tester");
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -19,5 +21,7 @@ const { FileEnumerator } = require("./cli-engine/file-enumerator");
 
 module.exports = {
     builtinRules: require("./rules"),
+    FlatESLint,
+    FlatRuleTester,
     FileEnumerator
 };