eslint 8.38.0 → 8.40.0

package/lib/rules/template-tag-spacing.js

@@ -17,7 +17,7 @@ module.exports = {
         docs: {
             description: "Require or disallow spacing between template tags and their literals",
             recommended: false,
-            url: "https://eslint.org/docs/rules/template-tag-spacing"
+            url: "https://eslint.org/docs/latest/rules/template-tag-spacing"
         },
 
         fixable: "whitespace",
@@ -33,7 +33,7 @@ module.exports = {
 
     create(context) {
         const never = context.options[0] !== "always";
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
 
         /**
          * Check if a space is present between a template tag and its literal

package/lib/rules/unicode-bom.js

@@ -16,7 +16,7 @@ module.exports = {
         docs: {
             description: "Require or disallow Unicode byte order mark (BOM)",
             recommended: false,
-            url: "https://eslint.org/docs/rules/unicode-bom"
+            url: "https://eslint.org/docs/latest/rules/unicode-bom"
         },
 
         fixable: "whitespace",
@@ -42,7 +42,7 @@ module.exports = {
 
             Program: function checkUnicodeBOM(node) {
 
-                const sourceCode = context.getSourceCode(),
+                const sourceCode = context.sourceCode,
                     location = { column: 0, line: 1 },
                     requireBOM = context.options[0] || "never";
 

package/lib/rules/use-isnan.js

@@ -39,7 +39,7 @@ module.exports = {
         docs: {
             description: "Require calls to `isNaN()` when checking for `NaN`",
             recommended: true,
-            url: "https://eslint.org/docs/rules/use-isnan"
+            url: "https://eslint.org/docs/latest/rules/use-isnan"
         },
 
         schema: [

package/lib/rules/valid-jsdoc.js

@@ -23,7 +23,7 @@ module.exports = {
         docs: {
             description: "Enforce valid JSDoc comments",
             recommended: false,
-            url: "https://eslint.org/docs/rules/valid-jsdoc"
+            url: "https://eslint.org/docs/latest/rules/valid-jsdoc"
         },
 
         schema: [
@@ -96,7 +96,7 @@ module.exports = {
 
         const options = context.options[0] || {},
             prefer = options.prefer || {},
-            sourceCode = context.getSourceCode(),
+            sourceCode = context.sourceCode,
 
             // these both default to true, so you have to explicitly make them false
             requireReturn = options.requireReturn !== false,

package/lib/rules/valid-typeof.js

@@ -16,7 +16,7 @@ module.exports = {
         docs: {
             description: "Enforce comparing `typeof` expressions against valid strings",
             recommended: true,
-            url: "https://eslint.org/docs/rules/valid-typeof"
+            url: "https://eslint.org/docs/latest/rules/valid-typeof"
         },
 
         hasSuggestions: true,
@@ -44,7 +44,7 @@ module.exports = {
 
         const VALID_TYPES = new Set(["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"]),
             OPERATORS = new Set(["==", "===", "!=", "!=="]);
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;
 
         let globalScope;
@@ -83,7 +83,7 @@ module.exports = {
 
             UnaryExpression(node) {
                 if (isTypeofExpression(node)) {
-                    const parent = sourceCode.getAncestors(node).pop();
+                    const { parent } = node;
 
                     if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
                         const sibling = parent.left === node ? parent.right : parent.left;

package/lib/rules/vars-on-top.js

@@ -17,7 +17,7 @@ module.exports = {
         docs: {
             description: "Require `var` declarations be placed at the top of their containing scope",
             recommended: false,
-            url: "https://eslint.org/docs/rules/vars-on-top"
+            url: "https://eslint.org/docs/latest/rules/vars-on-top"
         },
 
         schema: [],

package/lib/rules/wrap-iife.js

@@ -45,7 +45,7 @@ module.exports = {
         docs: {
             description: "Require parentheses around immediate `function` invocations",
             recommended: false,
-            url: "https://eslint.org/docs/rules/wrap-iife"
+            url: "https://eslint.org/docs/latest/rules/wrap-iife"
         },
 
         schema: [
@@ -77,7 +77,7 @@ module.exports = {
         const style = context.options[0] || "outside";
         const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;
 
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
 
         /**
          * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()

package/lib/rules/wrap-regex.js

@@ -17,7 +17,7 @@ module.exports = {
         docs: {
             description: "Require parenthesis around regex literals",
             recommended: false,
-            url: "https://eslint.org/docs/rules/wrap-regex"
+            url: "https://eslint.org/docs/latest/rules/wrap-regex"
         },
 
         schema: [],
@@ -29,7 +29,7 @@ module.exports = {
     },
 
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
 
         return {
 
@@ -40,10 +40,9 @@ module.exports = {
                 if (nodeType === "RegularExpression") {
                     const beforeToken = sourceCode.getTokenBefore(node);
                     const afterToken = sourceCode.getTokenAfter(node);
-                    const ancestors = sourceCode.getAncestors(node);
-                    const grandparent = ancestors[ancestors.length - 1];
+                    const { parent } = node;
 
-                    if (grandparent.type === "MemberExpression" && grandparent.object === node &&
+                    if (parent.type === "MemberExpression" && parent.object === node &&
                         !(beforeToken && beforeToken.value === "(" && afterToken && afterToken.value === ")")) {
                         context.report({
                             node,

package/lib/rules/yield-star-spacing.js

@@ -17,7 +17,7 @@ module.exports = {
         docs: {
             description: "Require or disallow spacing around the `*` in `yield*` expressions",
             recommended: false,
-            url: "https://eslint.org/docs/rules/yield-star-spacing"
+            url: "https://eslint.org/docs/latest/rules/yield-star-spacing"
         },
 
         fixable: "whitespace",
@@ -48,7 +48,7 @@ module.exports = {
     },
 
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
 
         const mode = (function(option) {
             if (!option || typeof option === "string") {

package/lib/rules/yoda.js

@@ -123,7 +123,7 @@ module.exports = {
         docs: {
             description: 'Require or disallow "Yoda" conditions',
             recommended: false,
-            url: "https://eslint.org/docs/rules/yoda"
+            url: "https://eslint.org/docs/latest/rules/yoda"
         },
 
         schema: [
@@ -162,7 +162,7 @@ module.exports = {
         const onlyEquality =
             context.options[1] && context.options[1].onlyEquality;
 
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
 
         /**
          * Determines whether node represents a range test.
@@ -343,7 +343,7 @@ module.exports = {
                     ) &&
                     !(!isEqualityOperator(node.operator) && onlyEquality) &&
                     isComparisonOperator(node.operator) &&
-                    !(exceptRange && isRangeTest(sourceCode.getAncestors(node).pop()))
+                    !(exceptRange && isRangeTest(node.parent))
                 ) {
                     context.report({
                         node,

package/lib/shared/string-utils.js

@@ -5,6 +5,26 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const GraphemeSplitter = require("grapheme-splitter");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+// eslint-disable-next-line no-control-regex -- intentionally including control characters
+const ASCII_REGEX = /^[\u0000-\u007f]*$/u;
+
+/** @type {GraphemeSplitter | undefined} */
+let splitter;
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
 /**
  * Converts the first letter of a string to uppercase.
  * @param {string} string The string to operate on
@@ -17,6 +37,24 @@ function upperCaseFirst(string) {
     return string[0].toUpperCase() + string.slice(1);
 }
 
+/**
+ * Counts graphemes in a given string.
+ * @param {string} value A string to count graphemes.
+ * @returns {number} The number of graphemes in `value`.
+ */
+function getGraphemeCount(value) {
+    if (ASCII_REGEX.test(value)) {
+        return value.length;
+    }
+
+    if (!splitter) {
+        splitter = new GraphemeSplitter();
+    }
+
+    return splitter.countGraphemes(value);
+}
+
 module.exports = {
-    upperCaseFirst
+    upperCaseFirst,
+    getGraphemeCount
 };

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

@@ -646,12 +646,12 @@ class SourceCode extends TokenStore {
     }
 
     /**
-     * Gets all of the declared variables in the scope associated
-     * with `node`. This is a convenience method that passes through
+     * Get the variables that `node` defines.
+     * This is a convenience method that passes through
      * to the same method on the `scopeManager`.
-     * @param {ASTNode} node The node from which to retrieve the scope to check.
+     * @param {ASTNode} node The node for which the variables are obtained.
      * @returns {Array<Variable>} An array of variable nodes representing
-     *      the declared variables in the scope associated with `node`.
+     *      the variables that `node` defines.
      */
     getDeclaredVariables(node) {
         return this.scopeManager.getDeclaredVariables(node);
@@ -681,6 +681,49 @@ class SourceCode extends TokenStore {
     }
     /* eslint-enable class-methods-use-this -- node is owned by SourceCode */
 
+    /**
+     * Marks a variable as used in the current scope
+     * @param {string} name The name of the variable to mark as used.
+     * @param {ASTNode} [refNode] The closest node to the variable reference.
+     * @returns {boolean} True if the variable was found and marked as used, false if not.
+     */
+    markVariableAsUsed(name, refNode = this.ast) {
+
+        const currentScope = this.getScope(refNode);
+        let initialScope = currentScope;
+
+        /*
+         * When we are in an ESM or CommonJS module, we need to start searching
+         * from the top-level scope, not the global scope. For ESM the top-level
+         * scope is the module scope; for CommonJS the top-level scope is the
+         * outer function scope.
+         *
+         * Without this check, we might miss a variable declared with `var` at
+         * the top-level because it won't exist in the global scope.
+         */
+        if (
+            currentScope.type === "global" &&
+            currentScope.childScopes.length > 0 &&
+
+            // top-level scopes refer to a `Program` node
+            currentScope.childScopes[0].block === this.ast
+        ) {
+            initialScope = currentScope.childScopes[0];
+        }
+
+        for (let scope = initialScope; scope; scope = scope.upper) {
+            const variable = scope.variables.find(scopeVar => scopeVar.name === name);
+
+            if (variable) {
+                variable.eslintUsed = true;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
 }
 
 module.exports = SourceCode;

package/lib/source-code/token-store/utils.js

@@ -4,20 +4,6 @@
  */
 "use strict";
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets `token.range[0]` from the given token.
- * @param {Node|Token|Comment} token The token to get.
- * @returns {number} The start location.
- * @private
- */
-function getStartLocation(token) {
-    return token.range[0];
-}
-
 //------------------------------------------------------------------------------
 // Exports
 //------------------------------------------------------------------------------
@@ -30,9 +16,28 @@ function getStartLocation(token) {
  * @returns {number} The found index or `tokens.length`.
  */
 exports.search = function search(tokens, location) {
-    const index = tokens.findIndex(el => location <= getStartLocation(el));
+    for (let minIndex = 0, maxIndex = tokens.length - 1; minIndex <= maxIndex;) {
 
-    return index === -1 ? tokens.length : index;
+        /*
+         * Calculate the index in the middle between minIndex and maxIndex.
+         * `| 0` is used to round a fractional value down to the nearest integer: this is similar to
+         * using `Math.trunc()` or `Math.floor()`, but performance tests have shown this method to
+         * be faster.
+         */
+        const index = (minIndex + maxIndex) / 2 | 0;
+        const token = tokens[index];
+        const tokenStartLocation = token.range[0];
+
+        if (location <= tokenStartLocation) {
+            if (index === minIndex) {
+                return index;
+            }
+            maxIndex = index;
+        } else {
+            minIndex = index + 1;
+        }
+    }
+    return tokens.length;
 };
 
 /**

package/messages/invalid-rule-options.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const { stringifyValueForError } = require("./shared");
+
+module.exports = function({ ruleId, value }) {
+    return `
+Configuration for rule "${ruleId}" is invalid. Each rule must have a severity ("off", 0, "warn", 1, "error", or 2) and may be followed by additional options for the rule.
+
+You passed '${stringifyValueForError(value, 4)}', which doesn't contain a valid severity.
+
+If you're attempting to configure rule options, perhaps you meant:
+
+    "${ruleId}": ["error", ${stringifyValueForError(value, 8)}]
+
+See https://eslint.org/docs/latest/use/configure/rules#using-configuration-files for configuring rules.
+`.trimStart();
+};

package/messages/invalid-rule-severity.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const { stringifyValueForError } = require("./shared");
+
+module.exports = function({ ruleId, value }) {
+    return `
+Configuration for rule "${ruleId}" is invalid. Expected severity of "off", 0, "warn", 1, "error", or 2.
+
+You passed '${stringifyValueForError(value, 4)}'.
+
+See https://eslint.org/docs/latest/use/configure/rules#using-configuration-files for configuring rules.
+`.trimStart();
+};

package/messages/shared.js

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Shared utilities for error messages.
+ * @author Josh Goldberg
+ */
+
+"use strict";
+
+/**
+ * Converts a value to a string that may be printed in errors.
+ * @param {any} value The invalid value.
+ * @param {number} indentation How many spaces to indent
+ * @returns {string} The value, stringified.
+ */
+function stringifyValueForError(value, indentation) {
+    return value ? JSON.stringify(value, null, 4).replace(/\n/gu, `\n${" ".repeat(indentation)}`) : `${value}`;
+}
+
+module.exports = { stringifyValueForError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.38.0",
+  "version": "8.40.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -62,8 +62,8 @@
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.4.0",
-    "@eslint/eslintrc": "^2.0.2",
-    "@eslint/js": "8.38.0",
+    "@eslint/eslintrc": "^2.0.3",
+    "@eslint/js": "8.40.0",
     "@humanwhocodes/config-array": "^0.11.8",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -73,9 +73,9 @@
     "debug": "^4.3.2",
     "doctrine": "^3.0.0",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^7.1.1",
-    "eslint-visitor-keys": "^3.4.0",
-    "espree": "^9.5.1",
+    "eslint-scope": "^7.2.0",
+    "eslint-visitor-keys": "^3.4.1",
+    "espree": "^9.5.2",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",