eslint 9.0.0-beta.1 → 9.0.0-rc.0

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

@@ -146,7 +146,9 @@ module.exports = {
                     continue;
                 }
 
-                uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                if (segmentInfoMap.has(segment)) {
+                    uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                }
             }
 
             return uselessReturns;
@@ -182,6 +184,10 @@ module.exports = {
 
             const info = segmentInfoMap.get(segment);
 
+            if (!info) {
+                return;
+            }
+
             info.uselessReturns = info.uselessReturns.filter(node => {
                 if (scopeInfo.traversedTryBlockStatements && scopeInfo.traversedTryBlockStatements.length > 0) {
                     const returnInitialRange = node.range[0];
@@ -275,7 +281,6 @@ module.exports = {
              * NOTE: This event is notified for only reachable segments.
              */
             onCodePathSegmentStart(segment) {
-
                 scopeInfo.currentSegments.add(segment);
 
                 const info = {

package/lib/rules/utils/char-source.js

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Utility functions to locate the source text of each code unit in the value of a string literal or template token.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+/**
+ * Represents a code unit produced by the evaluation of a JavaScript common token like a string
+ * literal or template token.
+ */
+class CodeUnit {
+    constructor(start, source) {
+        this.start = start;
+        this.source = source;
+    }
+
+    get end() {
+        return this.start + this.length;
+    }
+
+    get length() {
+        return this.source.length;
+    }
+}
+
+/**
+ * An object used to keep track of the position in a source text where the next characters will be read.
+ */
+class TextReader {
+    constructor(source) {
+        this.source = source;
+        this.pos = 0;
+    }
+
+    /**
+     * Advances the reading position of the specified number of characters.
+     * @param {number} length Number of characters to advance.
+     * @returns {void}
+     */
+    advance(length) {
+        this.pos += length;
+    }
+
+    /**
+     * Reads characters from the source.
+     * @param {number} [offset=0] The offset where reading starts, relative to the current position.
+     * @param {number} [length=1] Number of characters to read.
+     * @returns {string} A substring of source characters.
+     */
+    read(offset = 0, length = 1) {
+        const start = offset + this.pos;
+
+        return this.source.slice(start, start + length);
+    }
+}
+
+const SIMPLE_ESCAPE_SEQUENCES =
+{ __proto__: null, b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v" };
+
+/**
+ * Reads a hex escape sequence.
+ * @param {TextReader} reader The reader should be positioned on the first hexadecimal digit.
+ * @param {number} length The number of hexadecimal digits.
+ * @returns {string} A code unit.
+ */
+function readHexSequence(reader, length) {
+    const str = reader.read(0, length);
+    const charCode = parseInt(str, 16);
+
+    reader.advance(length);
+    return String.fromCharCode(charCode);
+}
+
+/**
+ * Reads a Unicode escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the "u".
+ * @returns {string} A code unit.
+ */
+function readUnicodeSequence(reader) {
+    const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+
+    regExp.lastIndex = reader.pos;
+    const match = regExp.exec(reader.source);
+
+    if (match) {
+        const codePoint = parseInt(match.groups.hexDigits, 16);
+
+        reader.pos = regExp.lastIndex;
+        return String.fromCodePoint(codePoint);
+    }
+    return readHexSequence(reader, 4);
+}
+
+/**
+ * Reads an octal escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the first octal digit.
+ * @param {number} maxLength The maximum number of octal digits.
+ * @returns {string} A code unit.
+ */
+function readOctalSequence(reader, maxLength) {
+    const [octalStr] = reader.read(-1, maxLength).match(/^[0-7]+/u);
+
+    reader.advance(octalStr.length - 1);
+    const octal = parseInt(octalStr, 8);
+
+    return String.fromCharCode(octal);
+}
+
+/**
+ * Reads an escape sequence or line continuation.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {string} A string of zero, one or two code units.
+ */
+function readEscapeSequenceOrLineContinuation(reader) {
+    const char = reader.read(1);
+
+    reader.advance(2);
+    const unitChar = SIMPLE_ESCAPE_SEQUENCES[char];
+
+    if (unitChar) {
+        return unitChar;
+    }
+    switch (char) {
+        case "x":
+            return readHexSequence(reader, 2);
+        case "u":
+            return readUnicodeSequence(reader);
+        case "\r":
+            if (reader.read() === "\n") {
+                reader.advance(1);
+            }
+
+            // fallthrough
+        case "\n":
+        case "\u2028":
+        case "\u2029":
+            return "";
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+            return readOctalSequence(reader, 3);
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+            return readOctalSequence(reader, 2);
+        default:
+            return char;
+    }
+}
+
+/**
+ * Reads an escape sequence or line continuation and generates the respective `CodeUnit` elements.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {Generator<CodeUnit>} Zero, one or two `CodeUnit` elements.
+ */
+function *mapEscapeSequenceOrLineContinuation(reader) {
+    const start = reader.pos;
+    const str = readEscapeSequenceOrLineContinuation(reader);
+    const end = reader.pos;
+    const source = reader.source.slice(start, end);
+
+    switch (str.length) {
+        case 0:
+            break;
+        case 1:
+            yield new CodeUnit(start, source);
+            break;
+        default:
+            yield new CodeUnit(start, source);
+            yield new CodeUnit(start, source);
+            break;
+    }
+}
+
+/**
+ * Parses a string literal.
+ * @param {string} source The string literal to parse, including the delimiting quotes.
+ * @returns {CodeUnit[]} A list of code units produced by the string literal.
+ */
+function parseStringLiteral(source) {
+    const reader = new TextReader(source);
+    const quote = reader.read();
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === quote) {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            codeUnits.push(new CodeUnit(reader.pos, char));
+            reader.advance(1);
+        }
+    }
+    return codeUnits;
+}
+
+/**
+ * Parses a template token.
+ * @param {string} source The template token to parse, including the delimiting sequences `` ` ``, `${` and `}`.
+ * @returns {CodeUnit[]} A list of code units produced by the template token.
+ */
+function parseTemplateToken(source) {
+    const reader = new TextReader(source);
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === "`" || char === "$" && reader.read(1) === "{") {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            let unitSource;
+
+            if (char === "\r" && reader.read(1) === "\n") {
+                unitSource = "\r\n";
+            } else {
+                unitSource = char;
+            }
+            codeUnits.push(new CodeUnit(reader.pos, unitSource));
+            reader.advance(unitSource.length);
+        }
+    }
+    return codeUnits;
+}
+
+module.exports = { parseStringLiteral, parseTemplateToken };

package/lib/rules/utils/lazy-loading-rule-map.js

@@ -6,7 +6,7 @@
 
 const debug = require("debug")("eslint:rules");
 
-/** @typedef {import("./types").Rule} Rule */
+/** @typedef {import("../../shared/types").Rule} Rule */
 
 /**
  * The `Map` object that loads each rule when it's accessed.

package/lib/rules/utils/unicode/index.js

@@ -3,9 +3,14 @@
  */
 "use strict";
 
+const isCombiningCharacter = require("./is-combining-character");
+const isEmojiModifier = require("./is-emoji-modifier");
+const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol");
+const isSurrogatePair = require("./is-surrogate-pair");
+
 module.exports = {
-    isCombiningCharacter: require("./is-combining-character"),
-    isEmojiModifier: require("./is-emoji-modifier"),
-    isRegionalIndicatorSymbol: require("./is-regional-indicator-symbol"),
-    isSurrogatePair: require("./is-surrogate-pair")
+    isCombiningCharacter,
+    isEmojiModifier,
+    isRegionalIndicatorSymbol,
+    isSurrogatePair
 };

package/lib/shared/runtime-info.js

@@ -162,6 +162,7 @@ function version() {
 //------------------------------------------------------------------------------
 
 module.exports = {
+    __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
     environment,
     version
 };

package/lib/source-code/index.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const SourceCode = require("./source-code");
+
 module.exports = {
-    SourceCode: require("./source-code")
+    SourceCode
 };

package/lib/source-code/source-code.js

@@ -18,8 +18,12 @@ const
         directivesPattern
     } = require("../shared/directives"),
 
-    /* eslint-disable-next-line n/no-restricted-require -- Too messy to figure out right now. */
+    /* eslint-disable n/no-restricted-require -- Should eventually be moved into SourceCode. */
+    CodePathAnalyzer = require("../linter/code-path-analysis/code-path-analyzer"),
+    createEmitter = require("../linter/safe-emitter"),
     ConfigCommentParser = require("../linter/config-comment-parser"),
+    /* eslint-enable n/no-restricted-require -- Should eventually be moved into SourceCode. */
+
     eslintScope = require("eslint-scope");
 
 //------------------------------------------------------------------------------
@@ -34,6 +38,16 @@ const
 
 const commentParser = new ConfigCommentParser();
 
+const CODE_PATH_EVENTS = [
+    "onCodePathStart",
+    "onCodePathEnd",
+    "onCodePathSegmentStart",
+    "onCodePathSegmentEnd",
+    "onCodePathSegmentLoop",
+    "onUnreachableCodePathSegmentStart",
+    "onUnreachableCodePathSegmentEnd"
+];
+
 /**
  * Validates that the given AST has the required information.
  * @param {ASTNode} ast The Program node of the AST to check.
@@ -300,6 +314,65 @@ function markExportedVariables(globalScope, variables) {
 
 }
 
+const STEP_KIND = {
+    visit: 1,
+    call: 2
+};
+
+/**
+ * A class to represent a step in the traversal process.
+ */
+class TraversalStep {
+
+    /**
+     * The type of the step.
+     * @type {string}
+     */
+    type;
+
+    /**
+     * The kind of the step. Represents the same data as the `type` property
+     * but it's a number for performance.
+     * @type {number}
+     */
+    kind;
+
+    /**
+     * The target of the step.
+     * @type {ASTNode|string}
+     */
+    target;
+
+    /**
+     * The phase of the step.
+     * @type {number|undefined}
+     */
+    phase;
+
+    /**
+     * The arguments of the step.
+     * @type {Array<any>}
+     */
+    args;
+
+    /**
+     * Creates a new instance.
+     * @param {Object} options The options for the step.
+     * @param {string} options.type The type of the step.
+     * @param {ASTNode|string} options.target The target of the step.
+     * @param {number|undefined} [options.phase] The phase of the step.
+     * @param {Array<any>} options.args The arguments of the step.
+     * @returns {void}
+     */
+    constructor({ type, target, phase, args }) {
+        this.type = type;
+        this.kind = STEP_KIND[type];
+        this.target = target;
+        this.phase = phase;
+        this.args = args;
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -311,6 +384,12 @@ const caches = Symbol("caches");
  */
 class SourceCode extends TokenStore {
 
+    /**
+     * The cache of steps that were taken while traversing the source code.
+     * @type {Array<TraversalStep>}
+     */
+    #steps;
+
     /**
      * @param {string|Object} textOrConfig The source code text or config object.
      * @param {string} textOrConfig.text The source code text.
@@ -972,6 +1051,91 @@ class SourceCode extends TokenStore {
 
     }
 
+    /**
+     * Traverse the source code and return the steps that were taken.
+     * @returns {Array<TraversalStep>} The steps that were taken while traversing the source code.
+     */
+    traverse() {
+
+        // Because the AST doesn't mutate, we can cache the steps
+        if (this.#steps) {
+            return this.#steps;
+        }
+
+        const steps = this.#steps = [];
+
+        /*
+         * This logic works for any AST, not just ESTree. Because ESLint has allowed
+         * custom parsers to return any AST, we need to ensure that the traversal
+         * logic works for any AST.
+         */
+        const emitter = createEmitter();
+        let analyzer = {
+            enterNode(node) {
+                steps.push(new TraversalStep({
+                    type: "visit",
+                    target: node,
+                    phase: 1,
+                    args: [node, node.parent]
+                }));
+            },
+            leaveNode(node) {
+                steps.push(new TraversalStep({
+                    type: "visit",
+                    target: node,
+                    phase: 2,
+                    args: [node, node.parent]
+                }));
+            },
+            emitter
+        };
+
+        /*
+         * We do code path analysis for ESTree only. Code path analysis is not
+         * necessary for other ASTs, and it's also not possible to do for other
+         * ASTs because the necessary information is not available.
+         *
+         * Generally speaking, we can tell that the AST is an ESTree if it has a
+         * Program node at the top level. This is not a perfect heuristic, but it
+         * is good enough for now.
+         */
+        const isESTree = this.ast.type === "Program";
+
+        if (isESTree) {
+            analyzer = new CodePathAnalyzer(analyzer);
+
+            CODE_PATH_EVENTS.forEach(eventName => {
+                emitter.on(eventName, (...args) => {
+                    steps.push(new TraversalStep({
+                        type: "call",
+                        target: eventName,
+                        args
+                    }));
+                });
+            });
+        }
+
+        /*
+         * The actual AST traversal is done by the `Traverser` class. This class
+         * is responsible for walking the AST and calling the appropriate methods
+         * on the `analyzer` object, which is appropriate for the given AST.
+         */
+        Traverser.traverse(this.ast, {
+            enter(node, parent) {
+
+                // save the parent node on a property for backwards compatibility
+                node.parent = parent;
+
+                analyzer.enterNode(node);
+            },
+            leave(node) {
+                analyzer.leaveNode(node);
+            },
+            visitorKeys: this.visitorKeys
+        });
+
+        return steps;
+    }
 }
 
 module.exports = SourceCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-beta.1",
+  "version": "9.0.0-rc.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -23,6 +23,7 @@
     "lint:docs:rule-examples": "node Makefile.js checkRuleExamples",
     "lint:fix": "node Makefile.js lint -- fix",
     "lint:fix:docs:js": "node Makefile.js lintDocsJS -- fix",
+    "lint:unused": "knip",
     "release:generate:alpha": "node Makefile.js generatePrerelease -- alpha",
     "release:generate:beta": "node Makefile.js generatePrerelease -- beta",
     "release:generate:latest": "node Makefile.js generateRelease",
@@ -48,7 +49,7 @@
       "node tools/fetch-docs-links.js",
       "git add docs/src/_data/further_reading_links.json"
     ],
-    "docs/**/*.svg": "npx svgo -r --multipass"
+    "docs/**/*.svg": "npx -y svgo -r --multipass"
   },
   "files": [
     "LICENSE",
@@ -66,7 +67,7 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
     "@eslint/eslintrc": "^3.0.2",
-    "@eslint/js": "9.0.0-beta.1",
+    "@eslint/js": "9.0.0-rc.0",
     "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -75,7 +76,7 @@
     "cross-spawn": "^7.0.2",
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^8.0.0",
+    "eslint-scope": "^8.0.1",
     "eslint-visitor-keys": "^4.0.0",
     "espree": "^10.0.1",
     "esquery": "^1.4.2",
@@ -101,6 +102,8 @@
   "devDependencies": {
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
+    "@types/estree": "^1.0.5",
+    "@types/node": "^20.11.5",
     "@wdio/browser-runner": "^8.14.6",
     "@wdio/cli": "^8.14.6",
     "@wdio/concise-reporter": "^8.14.0",
@@ -131,6 +134,7 @@
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
+    "knip": "^5.0.1",
     "lint-staged": "^11.0.0",
     "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",
@@ -138,7 +142,6 @@
     "markdownlint": "^0.33.0",
     "markdownlint-cli": "^0.39.0",
     "marked": "^4.0.8",
-    "memfs": "^3.0.1",
     "metascraper": "^5.25.7",
     "metascraper-description": "^5.25.7",
     "metascraper-image": "^5.29.3",
@@ -157,8 +160,8 @@
     "semver": "^7.5.3",
     "shelljs": "^0.8.5",
     "sinon": "^11.0.0",
+    "typescript": "^5.3.3",
     "vite-plugin-commonjs": "^0.10.0",
-    "webdriverio": "^8.14.6",
     "webpack": "^5.23.0",
     "webpack-cli": "^4.5.0",
     "yorkie": "^2.0.0"

package/lib/cli-engine/xml-escape.js

@@ -1,34 +0,0 @@
-/**
- * @fileoverview XML character escaper
- * @author George Chung
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Returns the escaped value for a character
- * @param {string} s string to examine
- * @returns {string} severity level
- * @private
- */
-module.exports = function(s) {
-    return (`${s}`).replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, c => { // eslint-disable-line no-control-regex -- Converting controls to entities
-        switch (c) {
-            case "<":
-                return "&lt;";
-            case ">":
-                return "&gt;";
-            case "&":
-                return "&amp;";
-            case "\"":
-                return "&quot;";
-            case "'":
-                return "&apos;";
-            default:
-                return `&#${c.charCodeAt(0)};`;
-        }
-    });
-};

package/lib/shared/deprecation-warnings.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview Provide the function that emits deprecation warnings.
- * @author Toru Nagashima <http://github.com/mysticatea>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const path = require("path");
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-// Definitions for deprecation warnings.
-const deprecationWarningMessages = {
-    ESLINT_LEGACY_ECMAFEATURES:
-        "The 'ecmaFeatures' config file property is deprecated and has no effect."
-};
-
-const sourceFileErrorCache = new Set();
-
-/**
- * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted
- * for each unique file path, but repeated invocations with the same file path have no effect.
- * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.
- * @param {string} source The name of the configuration source to report the warning for.
- * @param {string} errorCode The warning message to show.
- * @returns {void}
- */
-function emitDeprecationWarning(source, errorCode) {
-    const cacheKey = JSON.stringify({ source, errorCode });
-
-    if (sourceFileErrorCache.has(cacheKey)) {
-        return;
-    }
-
-    sourceFileErrorCache.add(cacheKey);
-
-    const rel = path.relative(process.cwd(), source);
-    const message = deprecationWarningMessages[errorCode];
-
-    process.emitWarning(
-        `${message} (found in "${rel}")`,
-        "DeprecationWarning",
-        errorCode
-    );
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
-    emitDeprecationWarning
-};