eslint-linter-browserify 10.4.0 → 10.5.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.4.0";
+var version = "10.5.0";
 var require$$3$1 = {
 	version: version};
 
@@ -12737,11 +12737,12 @@ function requireCodePathState () {
 		}
 
 		/**
-		 * Makes a code path segment from the first throwable node to the `catch`
-		 * block or the `finally` block.
+		 * Makes a code path segment from the first throwable node in a `try` block to the `catch`
+		 * block or the `finally` block or from the first throwable node in a `catch` block
+		 * to the `finally` block.
 		 * @returns {void}
 		 */
-		makeFirstThrowablePathInTryBlock() {
+		makeFirstThrowablePathInTryOrCatchBlock() {
 			const forkContext = this.forkContext;
 
 			if (!forkContext.reachable) {
@@ -12750,10 +12751,13 @@ function requireCodePathState () {
 
 			const context = getThrowContext(this);
 
+			if (context === this || !context.thrownForkContext.empty) {
+				return;
+			}
+
 			if (
-				context === this ||
-				context.position !== "try" ||
-				!context.thrownForkContext.empty
+				context.position !== "try" &&
+				(context.position !== "catch" || !context.hasFinalizer)
 			) {
 				return;
 			}
@@ -14363,7 +14367,7 @@ function requireCodePathAnalyzer () {
 
 			case "Identifier":
 				if (isIdentifierReference(node)) {
-					state.makeFirstThrowablePathInTryBlock();
+					state.makeFirstThrowablePathInTryOrCatchBlock();
 					dontForward = true;
 				}
 				break;
@@ -14372,7 +14376,7 @@ function requireCodePathAnalyzer () {
 			case "ImportExpression":
 			case "MemberExpression":
 			case "NewExpression":
-				state.makeFirstThrowablePathInTryBlock();
+				state.makeFirstThrowablePathInTryOrCatchBlock();
 				break;
 
 			case "YieldExpression":
@@ -50097,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
@@ -50114,6 +50148,7 @@ function requireArrayCallbackReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -50134,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
@@ -55360,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
@@ -55450,7 +55456,7 @@ function requireConsistentReturn () {
 				 */
 				if (
 					!funcInfo.hasReturnValue ||
-					areAllSegmentsUnreachable(funcInfo.currentSegments) ||
+					!isAnySegmentReachable(funcInfo.currentSegments) ||
 					astUtils.isES5Constructor(node) ||
 					isClassConstructor(node)
 				) {
@@ -59842,6 +59848,7 @@ function requireGetterReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -59849,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
 	//------------------------------------------------------------------------------
@@ -69857,6 +69849,8 @@ function requireMaxDepth () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Helpers
 			//--------------------------------------------------------------------------
@@ -69905,6 +69899,7 @@ function requireMaxDepth () {
 				if (len > maxDepth) {
 					context.report({
 						node,
+						loc: sourceCode.getFirstToken(node).loc,
 						messageId: "tooDeeply",
 						data: { depth: len, maxDepth },
 					});
@@ -69920,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
 			//--------------------------------------------------------------------------
@@ -69932,7 +69939,7 @@ function requireMaxDepth () {
 				StaticBlock: startFunction,
 
 				IfStatement(node) {
-					if (node.parent.type !== "IfStatement") {
+					if (!isElseIf(node)) {
 						pushBlock(node);
 					}
 				},
@@ -69945,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,
@@ -70902,6 +70913,7 @@ function requireMaxLinesPerFunction () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode),
 						messageId: "exceed",
 						data: { name, lineCount, maxLines },
 					});
@@ -70934,6 +70946,12 @@ function requireMaxNestedCallbacks () {
 	if (hasRequiredMaxNestedCallbacks) return maxNestedCallbacks;
 	hasRequiredMaxNestedCallbacks = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -70982,6 +71000,8 @@ function requireMaxNestedCallbacks () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Constants
 			//--------------------------------------------------------------------------
@@ -71019,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();
+				}
 			}
 
 			//--------------------------------------------------------------------------
@@ -71321,6 +71349,7 @@ function requireMaxStatements () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
 						messageId: "exceed",
 						data: { name, count, max },
 					});
@@ -85427,6 +85456,7 @@ function requireNoFallthrough () {
 	//------------------------------------------------------------------------------
 
 	const { directivesPattern } = requireDirectives();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -85434,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.
@@ -102035,6 +102050,12 @@ function requireNoUnreachable () {
 	if (hasRequiredNoUnreachable) return noUnreachable;
 	hasRequiredNoUnreachable = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102054,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.
 	 */
@@ -102185,7 +102191,7 @@ function requireNoUnreachable () {
 				if (
 					node &&
 					(node.type === "PropertyDefinition" ||
-						areAllSegmentsUnreachable(currentCodePathSegments))
+						!isAnySegmentReachable(currentCodePathSegments))
 				) {
 					// Store this statement to distinguish consecutive statements.
 					if (range.isEmpty) {
@@ -102344,6 +102350,8 @@ function requireNoUnreachableLoop () {
 	if (hasRequiredNoUnreachableLoop) return noUnreachableLoop;
 	hasRequiredNoUnreachableLoop = 1;
 
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102356,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.
@@ -108444,6 +108437,7 @@ function requireNoUselessReturn () {
 
 	const astUtils = requireAstUtils(),
 		FixTracker = requireFixTracker();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -108494,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
 	//------------------------------------------------------------------------------
@@ -109735,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",
+					});
 				},
 			};
 		},
@@ -114285,6 +114270,24 @@ function requirePreferArrowCallback () {
 									return;
 								}
 
+								const functionToken = sourceCode.getFirstToken(
+									node,
+									node.async ? 1 : 0,
+								);
+								const leftParenToken = sourceCode.getTokenAfter(
+									functionToken,
+									astUtils.isOpeningParenToken,
+								);
+
+								if (node.async) {
+									if (
+										functionToken.loc.end.line <
+										leftParenToken.loc.start.line
+									) {
+										return;
+									}
+								}
+
 								// Remove `.bind(this)` if exists.
 								if (callbackInfo.isLexicalThis) {
 									const memberNode = node.parent;
@@ -114337,14 +114340,6 @@ function requirePreferArrowCallback () {
 								}
 
 								// Convert the function expression to an arrow function.
-								const functionToken = sourceCode.getFirstToken(
-									node,
-									node.async ? 1 : 0,
-								);
-								const leftParenToken = sourceCode.getTokenAfter(
-									functionToken,
-									astUtils.isOpeningParenToken,
-								);
 								const tokenBeforeBody = sourceCode.getTokenBefore(
 									node.body,
 								);