eslint 10.4.1 → 10.5.0

package/README.md

@@ -45,7 +45,7 @@ ESLint is a tool for identifying and reporting on patterns found in ECMAScript/J
 
 ### Prerequisites
 
-To use ESLint, you must have [Node.js](https://nodejs.org/) (`^20.19.0`, `^22.13.0`, or `>=24`) installed and built with SSL support. (If you are using an official Node.js distribution, SSL is always built in.)
+To use ESLint, you must have [Node.js](https://nodejs.org/) (`^20.19.0`, `^22.13.0`, or `>=24`) installed and built with SSL and ICU support. (If you are using an official Node.js distribution, both SSL and ICU are always built in.)
 
 If you use ESLint's TypeScript type definitions, TypeScript 5.3 or later is required.
 

package/lib/rules/array-callback-return.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -30,21 +31,6 @@ function isTargetMethod(node) {
 	return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS);
 }
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Returns a human-legible description of an array method
  * @param {string} arrayMethodName A method name to fully qualify

package/lib/rules/consistent-return.js

@@ -10,26 +10,12 @@
 
 const astUtils = require("./utils/ast-utils");
 const { upperCaseFirst } = require("../shared/string-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
 /**
  * Checks whether a given node is a `constructor` method in an ES6 class
  * @param {ASTNode} node A node to check
@@ -100,7 +86,7 @@ module.exports = {
 			 */
 			if (
 				!funcInfo.hasReturnValue ||
-				areAllSegmentsUnreachable(funcInfo.currentSegments) ||
+				!isAnySegmentReachable(funcInfo.currentSegments) ||
 				astUtils.isES5Constructor(node) ||
 				isClassConstructor(node)
 			) {

package/lib/rules/getter-return.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -17,21 +18,6 @@ const astUtils = require("./utils/ast-utils");
 
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------

package/lib/rules/max-depth.js

@@ -54,6 +54,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		//--------------------------------------------------------------------------
 		// Helpers
 		//--------------------------------------------------------------------------
@@ -102,6 +104,7 @@ module.exports = {
 			if (len > maxDepth) {
 				context.report({
 					node,
+					loc: sourceCode.getFirstToken(node).loc,
 					messageId: "tooDeeply",
 					data: { depth: len, maxDepth },
 				});
@@ -117,6 +120,18 @@ module.exports = {
 			functionStack[functionStack.length - 1]--;
 		}
 
+		/**
+		 * Checks whether a node is an else-if statement.
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {boolean} Whether the node is an else-if statement
+		 */
+		function isElseIf(node) {
+			return (
+				node.parent.type === "IfStatement" &&
+				node.parent.alternate === node
+			);
+		}
+
 		//--------------------------------------------------------------------------
 		// Public API
 		//--------------------------------------------------------------------------
@@ -129,7 +144,7 @@ module.exports = {
 			StaticBlock: startFunction,
 
 			IfStatement(node) {
-				if (node.parent.type !== "IfStatement") {
+				if (!isElseIf(node)) {
 					pushBlock(node);
 				}
 			},
@@ -142,7 +157,11 @@ module.exports = {
 			ForInStatement: pushBlock,
 			ForOfStatement: pushBlock,
 
-			"IfStatement:exit": popBlock,
+			"IfStatement:exit"(node) {
+				if (!isElseIf(node)) {
+					popBlock();
+				}
+			},
 			"SwitchStatement:exit": popBlock,
 			"TryStatement:exit": popBlock,
 			"DoWhileStatement:exit": popBlock,

package/lib/rules/max-lines-per-function.js

@@ -222,6 +222,7 @@ module.exports = {
 
 				context.report({
 					node,
+					loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode),
 					messageId: "exceed",
 					data: { name, lineCount, maxLines },
 				});

package/lib/rules/max-nested-callbacks.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -53,6 +59,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		//--------------------------------------------------------------------------
 		// Constants
 		//--------------------------------------------------------------------------
@@ -90,17 +98,25 @@ module.exports = {
 			if (callbackStack.length > THRESHOLD) {
 				const opts = { num: callbackStack.length, max: THRESHOLD };
 
-				context.report({ node, messageId: "exceed", data: opts });
+				context.report({
+					node,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: "exceed",
+					data: opts,
+				});
 			}
 		}
 
 		/**
 		 * Pops the call stack.
+		 * @param {ASTNode} node The node to check.
 		 * @returns {void}
 		 * @private
 		 */
-		function popStack() {
-			callbackStack.pop();
+		function popStack(node) {
+			if (callbackStack.at(-1) === node) {
+				callbackStack.pop();
+			}
 		}
 
 		//--------------------------------------------------------------------------

package/lib/rules/max-statements.js

@@ -108,6 +108,7 @@ module.exports = {
 
 				context.report({
 					node,
+					loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
 					messageId: "exceed",
 					data: { name, count, max },
 				});

package/lib/rules/no-fallthrough.js

@@ -9,6 +9,7 @@
 //------------------------------------------------------------------------------
 
 const { directivesPattern } = require("../shared/directives");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -16,21 +17,6 @@ const { directivesPattern } = require("../shared/directives");
 
 const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
  * @param {string} comment The comment string to check.

package/lib/rules/no-unreachable-loop.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -17,21 +19,6 @@ const allLoopTypes = [
 	"ForOfStatement",
 ];
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Determines whether the given node is the first node in the code path to which a loop statement
  * 'loops' for the next iteration.

package/lib/rules/no-unreachable.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -23,21 +29,6 @@ function isInitialized(node) {
 	return Boolean(node.init);
 }
 
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
 /**
  * The class to distinguish consecutive unreachable statements.
  */
@@ -154,7 +145,7 @@ module.exports = {
 			if (
 				node &&
 				(node.type === "PropertyDefinition" ||
-					areAllSegmentsUnreachable(currentCodePathSegments))
+					!isAnySegmentReachable(currentCodePathSegments))
 			) {
 				// Store this statement to distinguish consecutive statements.
 				if (range.isEmpty) {

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

@@ -10,6 +10,7 @@
 
 const astUtils = require("./utils/ast-utils"),
 	FixTracker = require("./utils/fix-tracker");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -60,21 +61,6 @@ function isInFinally(node) {
 	return false;
 }
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------

package/lib/rules/no-with.js

@@ -28,9 +28,15 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		return {
 			WithStatement(node) {
-				context.report({ node, messageId: "unexpectedWith" });
+				context.report({
+					node,
+					loc: sourceCode.getFirstToken(node).loc,
+					messageId: "unexpectedWith",
+				});
 			},
 		};
 	},

package/lib/rules/utils/code-path-utils.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Code path related utilities.
+ */
+
+"use strict";
+
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} `true` if any segment is reachable; `false` otherwise.
+ */
+function isAnySegmentReachable(segments) {
+	for (const segment of segments) {
+		if (segment.reachable) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+module.exports = { isAnySegmentReachable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "10.4.1",
+  "version": "10.5.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -78,8 +78,15 @@
     "test:fuzz": "node Makefile.js fuzz",
     "test:performance": "node Makefile.js perf",
     "test:pnpm": "cd tests/pnpm && node check.js && pnpm install && pnpm exec tsc",
-    "test:types": "tsc -p tests/lib/types/tsconfig.json"
+    "test:types": "tsc -p tests/lib/types/tsconfig.json && npm run test:types --workspaces --if-present",
+    "test:types:5.3": "npx -p typescript@5.3 -y -- tsc -p tsconfig.types-legacy.json",
+    "test:types:5.x": "npx -p typescript@5.x -y -- tsc -p tsconfig.types.json",
+    "test:types:7.x": "npx -p @typescript/native-preview@latest -y -- tsgo -p tsconfig.types.json",
+    "test:types:all": "npm run test:types && npm run test:types:5.3 && npm run test:types:5.x && npm run test:types:7.x"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "gitHooks": {
     "pre-commit": "lint-staged"
   },
@@ -151,12 +158,12 @@
     "optionator": "^0.9.3"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.0",
+    "@arethetypeswrong/cli": "^0.18.3",
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "@cypress/webpack-preprocessor": "^6.0.2",
     "@eslint/eslintrc": "^3.3.5",
-    "@eslint/json": "^1.2.0",
+    "@eslint/json": "^2.0.0",
     "@types/esquery": "^1.5.4",
     "@types/node": "^22.13.14",
     "@typescript-eslint/parser": "^8.58.2",
@@ -228,10 +235,5 @@
   "license": "MIT",
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"
-  },
-  "overrides": {
-    "@arethetypeswrong/core": {
-      "fflate": "0.8.2"
-    }
   }
 }