eslint 8.0.0-beta.0 → 8.0.0

package/lib/init/npm-utils.js

@@ -21,8 +21,8 @@ const fs = require("fs"),
 /**
  * Find the closest package.json file, starting at process.cwd (by default),
  * and working up to root.
- * @param   {string} [startDir=process.cwd()] Starting directory
- * @returns {string}                          Absolute path to closest package.json file
+ * @param {string} [startDir=process.cwd()] Starting directory
+ * @returns {string} Absolute path to closest package.json file
  */
 function findPackageJson(startDir) {
     let dir = path.resolve(startDir || process.cwd());
@@ -45,7 +45,7 @@ function findPackageJson(startDir) {
 
 /**
  * Install node modules synchronously and save to devDependencies in package.json
- * @param   {string|string[]} packages Node module or modules to install
+ * @param {string|string[]} packages Node module or modules to install
  * @returns {void}
  */
 function installSyncSaveDev(packages) {
@@ -86,12 +86,13 @@ function fetchPeerDependencies(packageName) {
 
 /**
  * Check whether node modules are include in a project's package.json.
- * @param   {string[]} packages           Array of node module names
- * @param   {Object}  opt                 Options Object
- * @param   {boolean} opt.dependencies    Set to true to check for direct dependencies
- * @param   {boolean} opt.devDependencies Set to true to check for development dependencies
- * @param   {boolean} opt.startdir        Directory to begin searching from
- * @returns {Object}                      An object whose keys are the module names
+ * @param {string[]} packages Array of node module names
+ * @param {Object} opt Options Object
+ * @param {boolean} opt.dependencies Set to true to check for direct dependencies
+ * @param {boolean} opt.devDependencies Set to true to check for development dependencies
+ * @param {boolean} opt.startdir Directory to begin searching from
+ * @throws {Error} If cannot find valid `package.json` file.
+ * @returns {Object} An object whose keys are the module names
  *                                        and values are booleans indicating installation.
  */
 function check(packages, opt) {
@@ -133,9 +134,9 @@ function check(packages, opt) {
  * package.json.
  *
  * Convenience wrapper around check().
- * @param   {string[]} packages  Array of node modules to check.
- * @param   {string}   rootDir   The directory containing a package.json
- * @returns {Object}             An object whose keys are the module names
+ * @param {string[]} packages Array of node modules to check.
+ * @param {string} rootDir The directory containing a package.json
+ * @returns {Object} An object whose keys are the module names
  *                               and values are booleans indicating installation.
  */
 function checkDeps(packages, rootDir) {
@@ -147,8 +148,8 @@ function checkDeps(packages, rootDir) {
  * package.json.
  *
  * Convenience wrapper around check().
- * @param   {string[]} packages  Array of node modules to check.
- * @returns {Object}             An object whose keys are the module names
+ * @param {string[]} packages Array of node modules to check.
+ * @returns {Object} An object whose keys are the module names
  *                               and values are booleans indicating installation.
  */
 function checkDevDeps(packages) {
@@ -157,7 +158,7 @@ function checkDevDeps(packages) {
 
 /**
  * Check whether package.json is found in current path.
- * @param   {string} [startDir] Starting directory
+ * @param {string} [startDir] Starting directory
  * @returns {boolean} Whether a package.json is found in current path.
  */
 function checkPackageJson(startDir) {

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

@@ -23,7 +23,7 @@ const { CLIEngine } = require("../cli-engine");
  * TODO1: Expose the API that enumerates target files.
  * TODO2: Extract the creation logic of `SourceCode` from `Linter` class.
  */
-const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line node/no-restricted-require
+const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line node/no-restricted-require -- Todo
 
 const debug = require("debug")("eslint:source-code-utils");
 
@@ -33,9 +33,10 @@ const debug = require("debug")("eslint:source-code-utils");
 
 /**
  * Get the SourceCode object for a single file
- * @param   {string}     filename The fully resolved filename to get SourceCode from.
- * @param   {Object}     engine  A CLIEngine.
- * @returns {Array}               Array of the SourceCode object representing the file
+ * @param {string} filename The fully resolved filename to get SourceCode from.
+ * @param {Object} engine A CLIEngine.
+ * @throws {Error} Upon fatal errors from execution.
+ * @returns {Array} Array of the SourceCode object representing the file
  *                                and fatal error message.
  */
 function getSourceCodeOfFile(filename, engine) {
@@ -97,7 +98,7 @@ function getSourceCodeOfFiles(patterns, options, callback) {
             sourceCodes[filename] = sourceCode;
         }
         if (callback) {
-            callback(filenames.length); // eslint-disable-line node/callback-return
+            callback(filenames.length); // eslint-disable-line node/callback-return -- End of function
         }
     });
 

package/lib/linter/apply-disable-directives.js

@@ -46,26 +46,95 @@ function groupByParentComment(directives) {
  * @returns {{ description, fix, position }[]} Details for later creation of output Problems.
  */
 function createIndividualDirectivesRemoval(directives, commentToken) {
-    const listOffset = /^\s*\S+\s+/u.exec(commentToken.value)[0].length;
+
+    /*
+     * `commentToken.value` starts right after `//` or `/*`.
+     * All calculated offsets will be relative to this index.
+     */
+    const commentValueStart = commentToken.range[0] + "//".length;
+
+    // Find where the list of rules starts. `\S+` matches with the directive name (e.g. `eslint-disable-line`)
+    const listStartOffset = /^\s*\S+\s+/u.exec(commentToken.value)[0].length;
+
+    /*
+     * Get the list text without any surrounding whitespace. In order to preserve the original
+     * formatting, we don't want to change that whitespace.
+     *
+     *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+     *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+     */
     const listText = commentToken.value
-        .slice(listOffset) // remove eslint-*
-        .split(/\s-{2,}\s/u)[0] // remove -- directive comment
-        .trimRight();
-    const listStart = commentToken.range[0] + 2 + listOffset;
+        .slice(listStartOffset) // remove directive name and all whitespace before the list
+        .split(/\s-{2,}\s/u)[0] // remove `-- comment`, if it exists
+        .trimRight(); // remove all whitespace after the list
+
+    /*
+     * We can assume that `listText` contains multiple elements.
+     * Otherwise, this function wouldn't be called - if there is
+     * only one rule in the list, then the whole comment must be removed.
+     */
 
     return directives.map(directive => {
         const { ruleId } = directive;
-        const match = new RegExp(String.raw`(?:^|,)\s*${escapeRegExp(ruleId)}\s*(?:$|,)`, "u").exec(listText);
-        const ruleOffset = match.index;
-        const ruleEndOffset = ruleOffset + match[0].length;
-        const ruleText = listText.slice(ruleOffset, ruleEndOffset);
+
+        const regex = new RegExp(String.raw`(?:^|\s*,\s*)${escapeRegExp(ruleId)}(?:\s*,\s*|$)`, "u");
+        const match = regex.exec(listText);
+        const matchedText = match[0];
+        const matchStartOffset = listStartOffset + match.index;
+        const matchEndOffset = matchStartOffset + matchedText.length;
+
+        const firstIndexOfComma = matchedText.indexOf(",");
+        const lastIndexOfComma = matchedText.lastIndexOf(",");
+
+        let removalStartOffset, removalEndOffset;
+
+        if (firstIndexOfComma !== lastIndexOfComma) {
+
+            /*
+             * Since there are two commas, this must one of the elements in the middle of the list.
+             * Matched range starts where the previous rule name ends, and ends where the next rule name starts.
+             *
+             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+             *                                    ^^^^^^^^^^^^^^
+             *
+             * We want to remove only the content between the two commas, and also one of the commas.
+             *
+             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+             *                                     ^^^^^^^^^^^
+             */
+            removalStartOffset = matchStartOffset + firstIndexOfComma;
+            removalEndOffset = matchStartOffset + lastIndexOfComma;
+
+        } else {
+
+            /*
+             * This is either the first element or the last element.
+             *
+             * If this is the first element, matched range starts where the first rule name starts
+             * and ends where the second rule name starts. This is exactly the range we want
+             * to remove so that the second rule name will start where the first one was starting
+             * and thus preserve the original formatting.
+             *
+             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+             *                            ^^^^^^^^^^^
+             *
+             * Similarly, if this is the last element, we've already matched the range we want to
+             * remove. The previous rule name will end where the last one was ending, relative
+             * to the content on the right side.
+             *
+             *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
+             *                                               ^^^^^^^^^^^^^
+             */
+            removalStartOffset = matchStartOffset;
+            removalEndOffset = matchEndOffset;
+        }
 
         return {
             description: `'${ruleId}'`,
             fix: {
                 range: [
-                    listStart + ruleOffset + (ruleText.startsWith(",") && ruleText.endsWith(",") ? 1 : 0),
-                    listStart + ruleEndOffset
+                    commentValueStart + removalStartOffset,
+                    commentValueStart + removalEndOffset
                 ],
                 text: ""
             },

package/lib/linter/code-path-analysis/code-path-analyzer.js

@@ -29,6 +29,18 @@ function isCaseNode(node) {
     return Boolean(node.test);
 }
 
+/**
+ * Checks if a given node appears as the value of a PropertyDefinition node.
+ * @param {ASTNode} node THe node to check.
+ * @returns {boolean} `true` if the node is a PropertyDefinition value,
+ *      false if not.
+ */
+function isPropertyDefinitionValue(node) {
+    const parent = node.parent;
+
+    return parent && parent.type === "PropertyDefinition" && parent.value === node;
+}
+
 /**
  * Checks whether the given logical operator is taken into account for the code
  * path analysis.
@@ -138,6 +150,7 @@ function isIdentifierReference(node) {
             return parent.id !== node;
 
         case "Property":
+        case "PropertyDefinition":
         case "MethodDefinition":
             return (
                 parent.key !== node ||
@@ -388,29 +401,64 @@ function processCodePathToEnter(analyzer, node) {
     let state = codePath && CodePath.getState(codePath);
     const parent = node.parent;
 
+    /**
+     * Creates a new code path and trigger the onCodePathStart event
+     * based on the currently selected node.
+     * @param {string} origin The reason the code path was started.
+     * @returns {void}
+     */
+    function startCodePath(origin) {
+        if (codePath) {
+
+            // Emits onCodePathSegmentStart events if updated.
+            forwardCurrentToHead(analyzer, node);
+            debug.dumpState(node, state, false);
+        }
+
+        // Create the code path of this scope.
+        codePath = analyzer.codePath = new CodePath({
+            id: analyzer.idGenerator.next(),
+            origin,
+            upper: codePath,
+            onLooped: analyzer.onLooped
+        });
+        state = CodePath.getState(codePath);
+
+        // Emits onCodePathStart events.
+        debug.dump(`onCodePathStart ${codePath.id}`);
+        analyzer.emitter.emit("onCodePathStart", codePath, node);
+    }
+
+    /*
+     * Special case: The right side of class field initializer is considered
+     * to be its own function, so we need to start a new code path in this
+     * case.
+     */
+    if (isPropertyDefinitionValue(node)) {
+        startCodePath("class-field-initializer");
+
+        /*
+         * Intentional fall through because `node` needs to also be
+         * processed by the code below. For example, if we have:
+         *
+         * class Foo {
+         *     a = () => {}
+         * }
+         *
+         * In this case, we also need start a second code path.
+         */
+
+    }
+
     switch (node.type) {
         case "Program":
+            startCodePath("program");
+            break;
+
         case "FunctionDeclaration":
         case "FunctionExpression":
         case "ArrowFunctionExpression":
-            if (codePath) {
-
-                // Emits onCodePathSegmentStart events if updated.
-                forwardCurrentToHead(analyzer, node);
-                debug.dumpState(node, state, false);
-            }
-
-            // Create the code path of this scope.
-            codePath = analyzer.codePath = new CodePath(
-                analyzer.idGenerator.next(),
-                codePath,
-                analyzer.onLooped
-            );
-            state = CodePath.getState(codePath);
-
-            // Emits onCodePathStart events.
-            debug.dump(`onCodePathStart ${codePath.id}`);
-            analyzer.emitter.emit("onCodePathStart", codePath, node);
+            startCodePath("function");
             break;
 
         case "ChainExpression":
@@ -503,6 +551,7 @@ function processCodePathToEnter(analyzer, node) {
  * @returns {void}
  */
 function processCodePathToExit(analyzer, node) {
+
     const codePath = analyzer.codePath;
     const state = CodePath.getState(codePath);
     let dontForward = false;
@@ -627,28 +676,38 @@ function processCodePathToExit(analyzer, node) {
  * @returns {void}
  */
 function postprocess(analyzer, node) {
+
+    /**
+     * Ends the code path for the current node.
+     * @returns {void}
+     */
+    function endCodePath() {
+        let codePath = analyzer.codePath;
+
+        // Mark the current path as the final node.
+        CodePath.getState(codePath).makeFinal();
+
+        // Emits onCodePathSegmentEnd event of the current segments.
+        leaveFromCurrentSegment(analyzer, node);
+
+        // Emits onCodePathEnd event of this code path.
+        debug.dump(`onCodePathEnd ${codePath.id}`);
+        analyzer.emitter.emit("onCodePathEnd", codePath, node);
+        debug.dumpDot(codePath);
+
+        codePath = analyzer.codePath = analyzer.codePath.upper;
+        if (codePath) {
+            debug.dumpState(node, CodePath.getState(codePath), true);
+        }
+
+    }
+
     switch (node.type) {
         case "Program":
         case "FunctionDeclaration":
         case "FunctionExpression":
         case "ArrowFunctionExpression": {
-            let codePath = analyzer.codePath;
-
-            // Mark the current path as the final node.
-            CodePath.getState(codePath).makeFinal();
-
-            // Emits onCodePathSegmentEnd event of the current segments.
-            leaveFromCurrentSegment(analyzer, node);
-
-            // Emits onCodePathEnd event of this code path.
-            debug.dump(`onCodePathEnd ${codePath.id}`);
-            analyzer.emitter.emit("onCodePathEnd", codePath, node);
-            debug.dumpDot(codePath);
-
-            codePath = analyzer.codePath = analyzer.codePath.upper;
-            if (codePath) {
-                debug.dumpState(node, CodePath.getState(codePath), true);
-            }
+            endCodePath();
             break;
         }
 
@@ -662,6 +721,27 @@ function postprocess(analyzer, node) {
         default:
             break;
     }
+
+    /*
+     * Special case: The right side of class field initializer is considered
+     * to be its own function, so we need to end a code path in this
+     * case.
+     *
+     * We need to check after the other checks in order to close the
+     * code paths in the correct order for code like this:
+     *
+     *
+     * class Foo {
+     *     a = () => {}
+     * }
+     *
+     * In this case, The ArrowFunctionExpression code path is closed first
+     * and then we need to close the code path for the PropertyDefinition
+     * value.
+     */
+    if (isPropertyDefinitionValue(node)) {
+        endCodePath();
+    }
 }
 
 //------------------------------------------------------------------------------
@@ -674,7 +754,6 @@ function postprocess(analyzer, node) {
  */
 class CodePathAnalyzer {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {EventGenerator} eventGenerator An event generator to wrap.
      */

package/lib/linter/code-path-analysis/code-path-segment.js

@@ -33,7 +33,6 @@ function isReachable(segment) {
  */
 class CodePathSegment {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {string} id An identifier.
      * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.

package/lib/linter/code-path-analysis/code-path-state.js

@@ -219,7 +219,6 @@ function finalizeTestSegmentsOfFor(context, choiceContext, head) {
  */
 class CodePathState {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {IdGenerator} idGenerator An id generator to generate id for code
      *   path segments.
@@ -360,6 +359,7 @@ class CodePathState {
 
     /**
      * Pops the last choice context and finalizes it.
+     * @throws {Error} (Unreachable.)
      * @returns {ChoiceContext} The popped context.
      */
     popChoiceContext() {
@@ -450,6 +450,7 @@ class CodePathState {
     /**
      * Makes a code path segment of the right-hand operand of a logical
      * expression.
+     * @throws {Error} (Unreachable.)
      * @returns {void}
      */
     makeLogicalRight() {
@@ -965,6 +966,7 @@ class CodePathState {
      *   `WhileStatement`, `DoWhileStatement`, `ForStatement`, `ForInStatement`,
      *   and `ForStatement`.
      * @param {string|null} label A label of the node which was triggered.
+     * @throws {Error} (Unreachable - unknown type.)
      * @returns {void}
      */
     pushLoopContext(type, label) {
@@ -1036,6 +1038,7 @@ class CodePathState {
 
     /**
      * Pops the last context of a loop statement and finalizes it.
+     * @throws {Error} (Unreachable - unknown type.)
      * @returns {void}
      */
     popLoopContext() {

package/lib/linter/code-path-analysis/code-path.js

@@ -21,13 +21,15 @@ const IdGenerator = require("./id-generator");
  */
 class CodePath {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
-     * @param {string} id An identifier.
-     * @param {CodePath|null} upper The code path of the upper function scope.
-     * @param {Function} onLooped A callback function to notify looping.
+     * Creates a new instance.
+     * @param {Object} options Options for the function (see below).
+     * @param {string} options.id An identifier.
+     * @param {string} options.origin The type of code path origin.
+     * @param {CodePath|null} options.upper The code path of the upper function scope.
+     * @param {Function} options.onLooped A callback function to notify looping.
      */
-    constructor(id, upper, onLooped) {
+    constructor({ id, origin, upper, onLooped }) {
 
         /**
          * The identifier of this code path.
@@ -36,6 +38,13 @@ class CodePath {
          */
         this.id = id;
 
+        /**
+         * The reason that this code path was started. May be "program",
+         * "function", or "class-field-initializer".
+         * @type {string}
+         */
+        this.origin = origin;
+
         /**
          * The code path of the upper function scope.
          * @type {CodePath|null}

package/lib/linter/code-path-analysis/debug-helpers.js

@@ -21,7 +21,7 @@ const debug = require("debug")("eslint:code-path");
  * @returns {string} Id of the segment.
  */
 /* istanbul ignore next */
-function getId(segment) { // eslint-disable-line jsdoc/require-jsdoc
+function getId(segment) { // eslint-disable-line jsdoc/require-jsdoc -- Ignoring
     return segment.id + (segment.reachable ? "" : "!");
 }
 
@@ -115,7 +115,7 @@ module.exports = {
         const traceMap = Object.create(null);
         const arrows = this.makeDotArrows(codePath, traceMap);
 
-        for (const id in traceMap) { // eslint-disable-line guard-for-in
+        for (const id in traceMap) { // eslint-disable-line guard-for-in -- Want ability to traverse prototype
             const segment = traceMap[id];
 
             text += `${id}[`;

package/lib/linter/code-path-analysis/fork-context.js

@@ -97,7 +97,6 @@ function mergeExtraSegments(context, segments) {
  */
 class ForkContext {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {IdGenerator} idGenerator An identifier generator for segments.
      * @param {ForkContext|null} upper An upper fork context.

package/lib/linter/code-path-analysis/id-generator.js

@@ -18,7 +18,6 @@
  */
 class IdGenerator {
 
-    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {string} prefix Optional. A prefix of generated ids.
      */

package/lib/linter/config-comment-parser.js

@@ -3,7 +3,7 @@
  * @author Nicholas C. Zakas
  */
 
-/* eslint-disable class-methods-use-this*/
+/* eslint class-methods-use-this: off -- Methods desired on instance */
 "use strict";
 
 //------------------------------------------------------------------------------