eslint-linter-browserify 10.4.1 → 10.5.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.4.1";
+var version = "10.5.0";
 var require$$3$1 = {
 	version: version};
 
@@ -50101,6 +50101,36 @@ function requireArrayBracketSpacing () {
 	return arrayBracketSpacing;
 }
 
+/**
+ * @fileoverview Code path related utilities.
+ */
+
+var codePathUtils;
+var hasRequiredCodePathUtils;
+
+function requireCodePathUtils () {
+	if (hasRequiredCodePathUtils) return codePathUtils;
+	hasRequiredCodePathUtils = 1;
+
+	/**
+	 * 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;
+	}
+
+	codePathUtils = { isAnySegmentReachable };
+	return codePathUtils;
+}
+
 /**
  * @fileoverview Rule to enforce return statements in callbacks of array's methods
  * @author Toru Nagashima
@@ -50118,6 +50148,7 @@ function requireArrayCallbackReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -50138,21 +50169,6 @@ function requireArrayCallbackReturn () {
 		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
@@ -55364,26 +55380,12 @@ function requireConsistentReturn () {
 
 	const astUtils = requireAstUtils();
 	const { upperCaseFirst } = requireStringUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// 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
@@ -55454,7 +55456,7 @@ function requireConsistentReturn () {
 				 */
 				if (
 					!funcInfo.hasReturnValue ||
-					areAllSegmentsUnreachable(funcInfo.currentSegments) ||
+					!isAnySegmentReachable(funcInfo.currentSegments) ||
 					astUtils.isES5Constructor(node) ||
 					isClassConstructor(node)
 				) {
@@ -59846,6 +59848,7 @@ function requireGetterReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -59853,21 +59856,6 @@ function requireGetterReturn () {
 
 	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
 	//------------------------------------------------------------------------------
@@ -69861,6 +69849,8 @@ function requireMaxDepth () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Helpers
 			//--------------------------------------------------------------------------
@@ -69909,6 +69899,7 @@ function requireMaxDepth () {
 				if (len > maxDepth) {
 					context.report({
 						node,
+						loc: sourceCode.getFirstToken(node).loc,
 						messageId: "tooDeeply",
 						data: { depth: len, maxDepth },
 					});
@@ -69924,6 +69915,18 @@ function requireMaxDepth () {
 				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
 			//--------------------------------------------------------------------------
@@ -69936,7 +69939,7 @@ function requireMaxDepth () {
 				StaticBlock: startFunction,
 
 				IfStatement(node) {
-					if (node.parent.type !== "IfStatement") {
+					if (!isElseIf(node)) {
 						pushBlock(node);
 					}
 				},
@@ -69949,7 +69952,11 @@ function requireMaxDepth () {
 				ForInStatement: pushBlock,
 				ForOfStatement: pushBlock,
 
-				"IfStatement:exit": popBlock,
+				"IfStatement:exit"(node) {
+					if (!isElseIf(node)) {
+						popBlock();
+					}
+				},
 				"SwitchStatement:exit": popBlock,
 				"TryStatement:exit": popBlock,
 				"DoWhileStatement:exit": popBlock,
@@ -70906,6 +70913,7 @@ function requireMaxLinesPerFunction () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode),
 						messageId: "exceed",
 						data: { name, lineCount, maxLines },
 					});
@@ -70938,6 +70946,12 @@ function requireMaxNestedCallbacks () {
 	if (hasRequiredMaxNestedCallbacks) return maxNestedCallbacks;
 	hasRequiredMaxNestedCallbacks = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -70986,6 +71000,8 @@ function requireMaxNestedCallbacks () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Constants
 			//--------------------------------------------------------------------------
@@ -71023,17 +71039,25 @@ function requireMaxNestedCallbacks () {
 				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();
+				}
 			}
 
 			//--------------------------------------------------------------------------
@@ -71325,6 +71349,7 @@ function requireMaxStatements () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
 						messageId: "exceed",
 						data: { name, count, max },
 					});
@@ -85431,6 +85456,7 @@ function requireNoFallthrough () {
 	//------------------------------------------------------------------------------
 
 	const { directivesPattern } = requireDirectives();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -85438,21 +85464,6 @@ function requireNoFallthrough () {
 
 	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.
@@ -102039,6 +102050,12 @@ function requireNoUnreachable () {
 	if (hasRequiredNoUnreachable) return noUnreachable;
 	hasRequiredNoUnreachable = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102058,21 +102075,6 @@ function requireNoUnreachable () {
 		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.
 	 */
@@ -102189,7 +102191,7 @@ function requireNoUnreachable () {
 				if (
 					node &&
 					(node.type === "PropertyDefinition" ||
-						areAllSegmentsUnreachable(currentCodePathSegments))
+						!isAnySegmentReachable(currentCodePathSegments))
 				) {
 					// Store this statement to distinguish consecutive statements.
 					if (range.isEmpty) {
@@ -102348,6 +102350,8 @@ function requireNoUnreachableLoop () {
 	if (hasRequiredNoUnreachableLoop) return noUnreachableLoop;
 	hasRequiredNoUnreachableLoop = 1;
 
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102360,21 +102364,6 @@ function requireNoUnreachableLoop () {
 		"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.
@@ -108448,6 +108437,7 @@ function requireNoUselessReturn () {
 
 	const astUtils = requireAstUtils(),
 		FixTracker = requireFixTracker();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -108498,21 +108488,6 @@ function requireNoUselessReturn () {
 		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
 	//------------------------------------------------------------------------------
@@ -109739,9 +109714,15 @@ function requireNoWith () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			return {
 				WithStatement(node) {
-					context.report({ node, messageId: "unexpectedWith" });
+					context.report({
+						node,
+						loc: sourceCode.getFirstToken(node).loc,
+						messageId: "unexpectedWith",
+					});
 				},
 			};
 		},