eslint 9.39.1 → 10.0.0-alpha.1

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

@@ -8,8 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { isCommentToken } = require("@eslint-community/eslint-utils"),
-	TokenStore = require("./token-store"),
+const TokenStore = require("./token-store"),
 	astUtils = require("../../../shared/ast-utils"),
 	Traverser = require("../../../shared/traverser"),
 	globals = require("../../../../conf/globals"),
@@ -20,8 +19,7 @@ const { isCommentToken } = require("@eslint-community/eslint-utils"),
 		VisitNodeStep,
 		CallMethodStep,
 		Directive,
-	} = require("@eslint/plugin-kit"),
-	eslintScope = require("eslint-scope");
+	} = require("@eslint/plugin-kit");
 
 //------------------------------------------------------------------------------
 // Type Definitions
@@ -29,6 +27,7 @@ const { isCommentToken } = require("@eslint-community/eslint-utils"),
 
 /** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").ScopeManager} ScopeManager */
 /** @typedef {import("@eslint/core").SourceCode} ISourceCode */
 /** @typedef {import("@eslint/core").Directive} IDirective */
 /** @typedef {import("@eslint/core").TraversalStep} ITraversalStep */
@@ -90,21 +89,6 @@ function getGlobalsForEcmaVersion(ecmaVersion) {
 	}
 }
 
-/**
- * Check to see if its a ES6 export declaration.
- * @param {ASTNode} astNode An AST node.
- * @returns {boolean} whether the given node represents an export declaration.
- * @private
- */
-function looksLikeExport(astNode) {
-	return (
-		astNode.type === "ExportDefaultDeclaration" ||
-		astNode.type === "ExportNamedDeclaration" ||
-		astNode.type === "ExportAllDeclaration" ||
-		astNode.type === "ExportSpecifier"
-	);
-}
-
 /**
  * Merges two sorted lists into a larger sorted list in O(n) time.
  * @param {Token[]} tokens The list of tokens.
@@ -179,56 +163,6 @@ function nodesOrTokensOverlap(first, second) {
 	);
 }
 
-/**
- * Determines if two nodes or tokens have at least one whitespace character
- * between them. Order does not matter. Returns false if the given nodes or
- * tokens overlap.
- * @param {SourceCode} sourceCode The source code object.
- * @param {ASTNode|Token} first The first node or token to check between.
- * @param {ASTNode|Token} second The second node or token to check between.
- * @param {boolean} checkInsideOfJSXText If `true` is present, check inside of JSXText tokens for backward compatibility.
- * @returns {boolean} True if there is a whitespace character between
- * any of the tokens found between the two given nodes or tokens.
- * @public
- */
-function isSpaceBetween(sourceCode, first, second, checkInsideOfJSXText) {
-	if (nodesOrTokensOverlap(first, second)) {
-		return false;
-	}
-
-	const [startingNodeOrToken, endingNodeOrToken] =
-		first.range[1] <= second.range[0] ? [first, second] : [second, first];
-	const firstToken =
-		sourceCode.getLastToken(startingNodeOrToken) || startingNodeOrToken;
-	const finalToken =
-		sourceCode.getFirstToken(endingNodeOrToken) || endingNodeOrToken;
-	let currentToken = firstToken;
-
-	while (currentToken !== finalToken) {
-		const nextToken = sourceCode.getTokenAfter(currentToken, {
-			includeComments: true,
-		});
-
-		if (
-			currentToken.range[1] !== nextToken.range[0] ||
-			/*
-			 * For backward compatibility, check spaces in JSXText.
-			 * https://github.com/eslint/eslint/issues/12614
-			 */
-			(checkInsideOfJSXText &&
-				nextToken !== finalToken &&
-				nextToken.type === "JSXText" &&
-				/\s/u.test(nextToken.value))
-		) {
-			return true;
-		}
-
-		currentToken = nextToken;
-	}
-
-	return false;
-}
-
 /**
  * Performs binary search to find the line number containing a given character index.
  * Returns the lower bound - the index of the first element greater than the target.
@@ -264,103 +198,37 @@ function findLineNumberBinarySearch(lineStartIndices, target) {
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
  * scope.
- * @param {Scope} globalScope The global scope.
+ * @param {ScopeManager} scopeManager Scope manager.
  * @param {Object|undefined} configGlobals The globals declared in configuration
  * @param {Object|undefined} inlineGlobals The globals declared in the source code
  * @returns {void}
  */
 function addDeclaredGlobals(
-	globalScope,
-	configGlobals = {},
-	inlineGlobals = {},
+	scopeManager,
+	configGlobals = Object.create(null),
+	inlineGlobals = Object.create(null),
 ) {
-	// Define configured global variables.
-	for (const id of new Set([
-		...Object.keys(configGlobals),
-		...Object.keys(inlineGlobals),
-	])) {
-		/*
-		 * `normalizeConfigGlobal` will throw an error if a configured global value is invalid. However, these errors would
-		 * typically be caught when validating a config anyway (validity for inline global comments is checked separately).
-		 */
-		const configValue =
-			configGlobals[id] === void 0
-				? void 0
-				: normalizeConfigGlobal(configGlobals[id]);
-		const commentValue = inlineGlobals[id] && inlineGlobals[id].value;
-		const value = commentValue || configValue;
-		const sourceComments = inlineGlobals[id] && inlineGlobals[id].comments;
-
-		if (value === "off") {
-			continue;
-		}
-
-		let variable = globalScope.set.get(id);
+	const finalGlobals = { __proto__: null, ...configGlobals };
 
-		if (!variable) {
-			variable = new eslintScope.Variable(id, globalScope);
-
-			globalScope.variables.push(variable);
-			globalScope.set.set(id, variable);
-		}
-
-		variable.eslintImplicitGlobalSetting = configValue;
-		variable.eslintExplicitGlobal = sourceComments !== void 0;
-		variable.eslintExplicitGlobalComments = sourceComments;
-		variable.writeable = value === "writable";
+	for (const [name, data] of Object.entries(inlineGlobals)) {
+		finalGlobals[name] = data.value;
 	}
 
-	/*
-	 * "through" contains all references which definitions cannot be found.
-	 * Since we augment the global scope using configuration, we need to update
-	 * references and remove the ones that were added by configuration.
-	 */
-	globalScope.through = globalScope.through.filter(reference => {
-		const name = reference.identifier.name;
-		const variable = globalScope.set.get(name);
-
-		if (variable) {
-			/*
-			 * Links the variable and the reference.
-			 * And this reference is removed from `Scope#through`.
-			 */
-			reference.resolved = variable;
-			variable.references.push(reference);
+	const names = Object.keys(finalGlobals).filter(
+		name => finalGlobals[name] !== "off",
+	);
 
-			return false;
-		}
+	scopeManager.addGlobals(names);
 
-		return true;
-	});
+	const globalScope = scopeManager.scopes[0];
 
-	/*
-	 * "implicit" contains information about implicit global variables (those created
-	 * implicitly by assigning values to undeclared variables in non-strict code).
-	 * Since we augment the global scope using configuration, we need to remove
-	 * the ones that were added by configuration, as they are either built-in
-	 * or declared elsewhere, therefore not implicit.
-	 * Since the "implicit" property was not documented, first we'll check if it exists
-	 * because it's possible that not all custom scope managers create this property.
-	 * If it exists, we assume it has properties `variables` and `set`. Property
-	 * `left` is considered optional (for example, typescript-eslint's scope manage
-	 * has this property named `leftToBeResolved`).
-	 */
-	const { implicit } = globalScope;
-	if (typeof implicit === "object" && implicit !== null) {
-		implicit.variables = implicit.variables.filter(variable => {
-			const name = variable.name;
-			if (globalScope.set.has(name)) {
-				implicit.set.delete(name);
-				return false;
-			}
-			return true;
-		});
+	for (const name of names) {
+		const variable = globalScope.set.get(name);
 
-		if (implicit.left) {
-			implicit.left = implicit.left.filter(
-				reference => !globalScope.set.has(reference.identifier.name),
-			);
-		}
+		variable.eslintImplicitGlobalSetting = configGlobals[name];
+		variable.eslintExplicitGlobal = !!inlineGlobals[name];
+		variable.eslintExplicitGlobalComments = inlineGlobals[name]?.comments;
+		variable.writeable = finalGlobals[name] === "writable";
 	}
 }
 
@@ -595,87 +463,6 @@ class SourceCode extends TokenStore {
 		return this.ast.comments;
 	}
 
-	/**
-	 * Retrieves the JSDoc comment for a given node.
-	 * @param {ASTNode} node The AST node to get the comment for.
-	 * @returns {Token|null} The Block comment token containing the JSDoc comment
-	 *      for the given node or null if not found.
-	 * @public
-	 * @deprecated
-	 */
-	getJSDocComment(node) {
-		/**
-		 * Checks for the presence of a JSDoc comment for the given node and returns it.
-		 * @param {ASTNode} astNode The AST node to get the comment for.
-		 * @returns {Token|null} The Block comment token containing the JSDoc comment
-		 *      for the given node or null if not found.
-		 * @private
-		 */
-		const findJSDocComment = astNode => {
-			const tokenBefore = this.getTokenBefore(astNode, {
-				includeComments: true,
-			});
-
-			if (
-				tokenBefore &&
-				isCommentToken(tokenBefore) &&
-				tokenBefore.type === "Block" &&
-				tokenBefore.value.charAt(0) === "*" &&
-				astNode.loc.start.line - tokenBefore.loc.end.line <= 1
-			) {
-				return tokenBefore;
-			}
-
-			return null;
-		};
-		let parent = node.parent;
-
-		switch (node.type) {
-			case "ClassDeclaration":
-			case "FunctionDeclaration":
-				return findJSDocComment(
-					looksLikeExport(parent) ? parent : node,
-				);
-
-			case "ClassExpression":
-				return findJSDocComment(parent.parent);
-
-			case "ArrowFunctionExpression":
-			case "FunctionExpression":
-				if (
-					parent.type !== "CallExpression" &&
-					parent.type !== "NewExpression"
-				) {
-					while (
-						!this.getCommentsBefore(parent).length &&
-						!/Function/u.test(parent.type) &&
-						parent.type !== "MethodDefinition" &&
-						parent.type !== "Property"
-					) {
-						parent = parent.parent;
-
-						if (!parent) {
-							break;
-						}
-					}
-
-					if (
-						parent &&
-						parent.type !== "FunctionDeclaration" &&
-						parent.type !== "Program"
-					) {
-						return findJSDocComment(parent);
-					}
-				}
-
-				return findJSDocComment(node);
-
-			// falls through
-			default:
-				return null;
-		}
-	}
-
 	/**
 	 * Gets the deepest node containing a range index.
 	 * @param {number} index Range index of the desired node.
@@ -715,24 +502,33 @@ class SourceCode extends TokenStore {
 	 * @public
 	 */
 	isSpaceBetween(first, second) {
-		return isSpaceBetween(this, first, second, false);
-	}
+		if (nodesOrTokensOverlap(first, second)) {
+			return false;
+		}
 
-	/**
-	 * Determines if two nodes or tokens have at least one whitespace character
-	 * between them. Order does not matter. Returns false if the given nodes or
-	 * tokens overlap.
-	 * For backward compatibility, this method returns true if there are
-	 * `JSXText` tokens that contain whitespaces between the two.
-	 * @param {ASTNode|Token} first The first node or token to check between.
-	 * @param {ASTNode|Token} second The second node or token to check between.
-	 * @returns {boolean} True if there is a whitespace character between
-	 * any of the tokens found between the two given nodes or tokens.
-	 * @deprecated in favor of isSpaceBetween().
-	 * @public
-	 */
-	isSpaceBetweenTokens(first, second) {
-		return isSpaceBetween(this, first, second, true);
+		const [startingNodeOrToken, endingNodeOrToken] =
+			first.range[1] <= second.range[0]
+				? [first, second]
+				: [second, first];
+		const firstToken =
+			this.getLastToken(startingNodeOrToken) || startingNodeOrToken;
+		const finalToken =
+			this.getFirstToken(endingNodeOrToken) || endingNodeOrToken;
+		let currentToken = firstToken;
+
+		while (currentToken !== finalToken) {
+			const nextToken = this.getTokenAfter(currentToken, {
+				includeComments: true,
+			});
+
+			if (currentToken.range[1] !== nextToken.range[0]) {
+				return true;
+			}
+
+			currentToken = nextToken;
+		}
+
+		return false;
 	}
 
 	/**
@@ -1162,6 +958,15 @@ class SourceCode extends TokenStore {
 				: void 0,
 			languageOptions.globals,
 		);
+
+		/*
+		 * `normalizeConfigGlobal` will throw an error if a configured global value is invalid. However, these errors would
+		 * typically be caught when validating a config anyway (validity for inline global comments is checked separately).
+		 */
+		for (const [name, value] of Object.entries(configGlobals)) {
+			configGlobals[name] = normalizeConfigGlobal(value);
+		}
+
 		const varsCache = this[caches].get("vars");
 
 		varsCache.set("configGlobals", configGlobals);
@@ -1243,6 +1048,15 @@ class SourceCode extends TokenStore {
 
 					break;
 				}
+				case "eslint-env": {
+					problems.push({
+						ruleId: null,
+						loc: comment.loc,
+						message:
+							"/* eslint-env */ comments are no longer supported.",
+					});
+					break;
+				}
 
 				// no default
 			}
@@ -1273,7 +1087,7 @@ class SourceCode extends TokenStore {
 		const exportedVariables = varsCache.get("exportedVariables");
 		const globalScope = this.scopeManager.scopes[0];
 
-		addDeclaredGlobals(globalScope, configGlobals, inlineGlobals);
+		addDeclaredGlobals(this.scopeManager, configGlobals, inlineGlobals);
 
 		if (exportedVariables) {
 			markExportedVariables(globalScope, exportedVariables);

package/lib/languages/js/source-code/token-store/index.js

@@ -444,32 +444,6 @@ module.exports = class TokenStore {
 		).getOneToken();
 	}
 
-	/**
-	 * Gets the token that precedes a given node or token in the token stream.
-	 * This is defined for backward compatibility. Use `includeComments` option instead.
-	 * TODO: We have a plan to remove this in a future major version.
-	 * @param {ASTNode|Token|Comment} node The AST node or token.
-	 * @param {number} [skip=0] A number of tokens to skip.
-	 * @returns {Token|null} An object representing the token.
-	 * @deprecated
-	 */
-	getTokenOrCommentBefore(node, skip) {
-		return this.getTokenBefore(node, { includeComments: true, skip });
-	}
-
-	/**
-	 * Gets the token that follows a given node or token in the token stream.
-	 * This is defined for backward compatibility. Use `includeComments` option instead.
-	 * TODO: We have a plan to remove this in a future major version.
-	 * @param {ASTNode|Token|Comment} node The AST node or token.
-	 * @param {number} [skip=0] A number of tokens to skip.
-	 * @returns {Token|null} An object representing the token.
-	 * @deprecated
-	 */
-	getTokenOrCommentAfter(node, skip) {
-		return this.getTokenAfter(node, { includeComments: true, skip });
-	}
-
 	//--------------------------------------------------------------------------
 	// Gets multiple tokens.
 	//--------------------------------------------------------------------------

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

@@ -5,7 +5,7 @@
 "use strict";
 
 //------------------------------------------------------------------------------
-// Exports
+// Helpers
 //------------------------------------------------------------------------------
 
 /**
@@ -15,7 +15,7 @@
  * @param {number} location The location to search.
  * @returns {number} The found index or `tokens.length`.
  */
-exports.search = function search(tokens, location) {
+function search(tokens, location) {
 	for (
 		let minIndex = 0, maxIndex = tokens.length - 1;
 		minIndex <= maxIndex;
@@ -41,7 +41,7 @@ exports.search = function search(tokens, location) {
 		}
 	}
 	return tokens.length;
-};
+}
 
 /**
  * Gets the index of the `startLoc` in `tokens`.
@@ -51,7 +51,10 @@ exports.search = function search(tokens, location) {
  * @param {number} startLoc The location to get an index.
  * @returns {number} The index.
  */
-exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
+function getFirstIndex(tokens, indexMap, startLoc) {
+	if (startLoc === -1) {
+		return 0;
+	}
 	if (startLoc in indexMap) {
 		return indexMap[startLoc];
 	}
@@ -73,9 +76,13 @@ exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
 		}
 		return index + 1;
 	}
-	return 0;
-};
 
+	// Program node that doesn't start/end with a token or comment
+	if (startLoc === 0) {
+		return 0;
+	}
+	return tokens.length;
+}
 /**
  * Gets the index of the `endLoc` in `tokens`.
  * The information of end locations are recorded at `endLoc - 1` in `indexMap`, so this checks about `endLoc - 1` as well.
@@ -84,7 +91,10 @@ exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
  * @param {number} endLoc The location to get an index.
  * @returns {number} The index.
  */
-exports.getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {
+function getLastIndex(tokens, indexMap, endLoc) {
+	if (endLoc === -1) {
+		return tokens.length - 1;
+	}
 	if (endLoc in indexMap) {
 		return indexMap[endLoc] - 1;
 	}
@@ -106,5 +116,16 @@ exports.getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {
 		}
 		return index;
 	}
+
+	// Program node that doesn't start/end with a token or comment
+	if (endLoc === 0) {
+		return -1;
+	}
 	return tokens.length - 1;
-};
+}
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+module.exports = { search, getFirstIndex, getLastIndex };

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

@@ -428,7 +428,6 @@ function applyDirectives(options) {
 						: column,
 				severity:
 					options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
-				nodeType: null,
 				...(options.disableFixes ? {} : { fix }),
 			};
 		},

package/lib/linter/file-context.js

@@ -33,20 +33,6 @@ class FileContext {
 	 */
 	sourceCode;
 
-	/**
-	 * The parser options for the file being linted.
-	 * @type {Record<string, unknown>}
-	 * @deprecated Use `languageOptions` instead.
-	 */
-	parserOptions;
-
-	/**
-	 * The path to the parser used to parse this file.
-	 * @type {string}
-	 * @deprecated No longer supported.
-	 */
-	parserPath;
-
 	/**
 	 * The language options used when parsing this file.
 	 * @type {Record<string, unknown>}
@@ -66,8 +52,6 @@ class FileContext {
 	 * @param {string} config.filename The filename of the file being linted.
 	 * @param {string} config.physicalFilename The physical filename of the file being linted.
 	 * @param {SourceCode} config.sourceCode The source code of the file being linted.
-	 * @param {Record<string, unknown>} config.parserOptions The parser options for the file being linted.
-	 * @param {string} config.parserPath The path to the parser used to parse this file.
 	 * @param {Record<string, unknown>} config.languageOptions The language options used when parsing this file.
 	 * @param {Record<string, unknown>} config.settings The settings for the file being linted.
 	 */
@@ -76,8 +60,6 @@ class FileContext {
 		filename,
 		physicalFilename,
 		sourceCode,
-		parserOptions,
-		parserPath,
 		languageOptions,
 		settings,
 	}) {
@@ -85,50 +67,12 @@ class FileContext {
 		this.filename = filename;
 		this.physicalFilename = physicalFilename;
 		this.sourceCode = sourceCode;
-		this.parserOptions = parserOptions;
-		this.parserPath = parserPath;
 		this.languageOptions = languageOptions;
 		this.settings = settings;
 
 		Object.freeze(this);
 	}
 
-	/**
-	 * Gets the current working directory.
-	 * @returns {string} The current working directory.
-	 * @deprecated Use `cwd` instead.
-	 */
-	getCwd() {
-		return this.cwd;
-	}
-
-	/**
-	 * Gets the filename of the file being linted.
-	 * @returns {string} The filename of the file being linted.
-	 * @deprecated Use `filename` instead.
-	 */
-	getFilename() {
-		return this.filename;
-	}
-
-	/**
-	 * Gets the physical filename of the file being linted.
-	 * @returns {string} The physical filename of the file being linted.
-	 * @deprecated Use `physicalFilename` instead.
-	 */
-	getPhysicalFilename() {
-		return this.physicalFilename;
-	}
-
-	/**
-	 * Gets the source code of the file being linted.
-	 * @returns {SourceCode} The source code of the file being linted.
-	 * @deprecated Use `sourceCode` instead.
-	 */
-	getSourceCode() {
-		return this.sourceCode;
-	}
-
 	/**
 	 * Creates a new object with the current object as the prototype and
 	 * the specified properties as its own properties.

package/lib/linter/file-report.js

@@ -124,7 +124,6 @@ function createLintingProblem(options, severity, language) {
 			language,
 		),
 		severity,
-		nodeType: null,
 	};
 }
 
@@ -340,7 +339,6 @@ function mapSuggestions(descriptor, sourceCode, messages) {
  * @param {Object} options Information about the problem
  * @param {string} options.ruleId Rule ID
  * @param {(0|1|2)} options.severity Rule severity
- * @param {(ASTNode|null)} options.node Node
  * @param {string} options.message Error message
  * @param {string} [options.messageId] The error message ID.
  * @param {{start: SourceLocation, end: (SourceLocation|null)}} options.loc Start and end location
@@ -362,7 +360,6 @@ function createProblem(options) {
 		message: options.message,
 		line: options.loc.start.line + lineOffset,
 		column: options.loc.start.column + columnOffset,
-		nodeType: (options.node && options.node.type) || null,
 	};
 
 	/*
@@ -548,7 +545,6 @@ class FileReport {
 			createProblem({
 				ruleId,
 				severity,
-				node: descriptor.node,
 				message: interpolate(computedMessage, descriptor.data),
 				messageId: descriptor.messageId,
 				loc: descriptor.loc