eslint 8.19.0 → 8.20.0

package/README.md

@@ -45,21 +45,15 @@ ESLint is a tool for identifying and reporting on patterns found in ECMAScript/J
 
 Prerequisites: [Node.js](https://nodejs.org/) (`^12.22.0`, `^14.17.0`, or `>=16.0.0`) built with SSL support. (If you are using an official Node.js distribution, SSL is always built in.)
 
-You can install ESLint using npm:
+You can install and configure ESLint using this command:
 
-```sh
-npm install eslint --save-dev
-```
-
-You should then set up a configuration file:
-
-```sh
+```shell
 npm init @eslint/config
 ```
 
 After that, you can run ESLint on any file or directory like this:
 
-```sh
+```shell
 ./node_modules/.bin/eslint yourfile.js
 ```
 

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.
@@ -1788,13 +1812,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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.19.0",
+  "version": "8.20.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -102,9 +102,9 @@
     "eslint": "file:.",
     "eslint-config-eslint": "file:packages/eslint-config-eslint",
     "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-eslint-plugin": "^4.2.0",
+    "eslint-plugin-eslint-plugin": "^4.4.0",
     "eslint-plugin-internal-rules": "file:tools/internal-rules",
-    "eslint-plugin-jsdoc": "^37.0.0",
+    "eslint-plugin-jsdoc": "^38.1.6",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-unicorn": "^42.0.0",
     "eslint-release": "^3.2.0",
@@ -123,8 +123,8 @@
     "karma-webpack": "^5.0.0",
     "lint-staged": "^11.0.0",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.24.0",
-    "markdownlint-cli": "^0.30.0",
+    "markdownlint": "^0.25.1",
+    "markdownlint-cli": "^0.31.1",
     "marked": "^4.0.8",
     "memfs": "^3.0.1",
     "metascraper": "^5.25.7",