@alexlit/lint-kit 164.15.0 → 165.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unreachable-loop.js

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview Rule to disallow loops with a body that allows only one iteration
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const allLoopTypes = [
+	"WhileStatement",
+	"DoWhileStatement",
+	"ForStatement",
+	"ForInStatement",
+	"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.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a looping target.
+ */
+function isLoopingTarget(node) {
+	const parent = node.parent;
+
+	if (parent) {
+		switch (parent.type) {
+			case "WhileStatement":
+				return node === parent.test;
+			case "DoWhileStatement":
+				return node === parent.body;
+			case "ForStatement":
+				return node === (parent.update || parent.test || parent.body);
+			case "ForInStatement":
+			case "ForOfStatement":
+				return node === parent.left;
+
+			// no default
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Creates an array with elements from the first given array that are not included in the second given array.
+ * @param {Array} arrA The array to compare from.
+ * @param {Array} arrB The array to compare against.
+ * @returns {Array} a new array that represents `arrA \ arrB`.
+ */
+function getDifference(arrA, arrB) {
+	return arrA.filter(a => !arrB.includes(a));
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [{ ignore: [] }],
+
+		docs: {
+			description:
+				"Disallow loops with a body that allows only one iteration",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-unreachable-loop",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignore: {
+						type: "array",
+						items: {
+							enum: allLoopTypes,
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			invalid: "Invalid loop. Its body allows only one iteration.",
+		},
+	},
+
+	create(context) {
+		const [{ ignore: ignoredLoopTypes }] = context.options;
+		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
+			loopSelector = loopTypesToCheck.join(","),
+			loopsByTargetSegments = new Map(),
+			loopsToReport = new Set();
+
+		const codePathSegments = [];
+		let currentCodePathSegments = new Set();
+
+		return {
+			onCodePathStart() {
+				codePathSegments.push(currentCodePathSegments);
+				currentCodePathSegments = new Set();
+			},
+
+			onCodePathEnd() {
+				currentCodePathSegments = codePathSegments.pop();
+			},
+
+			onUnreachableCodePathSegmentStart(segment) {
+				currentCodePathSegments.add(segment);
+			},
+
+			onUnreachableCodePathSegmentEnd(segment) {
+				currentCodePathSegments.delete(segment);
+			},
+
+			onCodePathSegmentEnd(segment) {
+				currentCodePathSegments.delete(segment);
+			},
+
+			onCodePathSegmentStart(segment, node) {
+				currentCodePathSegments.add(segment);
+
+				if (isLoopingTarget(node)) {
+					const loop = node.parent;
+
+					loopsByTargetSegments.set(segment, loop);
+				}
+			},
+
+			onCodePathSegmentLoop(_, toSegment, node) {
+				const loop = loopsByTargetSegments.get(toSegment);
+
+				/**
+				 * The second iteration is reachable, meaning that the loop is valid by the logic of this rule,
+				 * only if there is at least one loop event with the appropriate target (which has been already
+				 * determined in the `loopsByTargetSegments` map), raised from either:
+				 *
+				 * - the end of the loop's body (in which case `node === loop`)
+				 * - a `continue` statement
+				 *
+				 * This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes.
+				 */
+				if (node === loop || node.type === "ContinueStatement") {
+					// Removes loop if it exists in the set. Otherwise, `Set#delete` has no effect and doesn't throw.
+					loopsToReport.delete(loop);
+				}
+			},
+
+			[loopSelector](node) {
+				/**
+				 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
+				 * For unreachable segments, the code path analysis does not raise events required for this implementation.
+				 */
+				if (isAnySegmentReachable(currentCodePathSegments)) {
+					loopsToReport.add(node);
+				}
+			},
+
+			"Program:exit"() {
+				loopsToReport.forEach(node =>
+					context.report({ node, messageId: "invalid" }),
+				);
+			},
+		};
+	},
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unreachable.js

@@ -0,0 +1,300 @@
+/**
+ * @fileoverview Checks for unreachable code due to return, throws, break, and continue.
+ * @author Joel Feenstra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * @typedef {Object} ConstructorInfo
+ * @property {ConstructorInfo | null} upper Info about the constructor that encloses this constructor.
+ * @property {boolean} hasSuperCall The flag about having `super()` expressions.
+ */
+
+/**
+ * Checks whether or not a given variable declarator has the initializer.
+ * @param {ASTNode} node A VariableDeclarator node to check.
+ * @returns {boolean} `true` if the node has the initializer.
+ */
+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.
+ */
+class ConsecutiveRange {
+	constructor(sourceCode) {
+		this.sourceCode = sourceCode;
+		this.startNode = null;
+		this.endNode = null;
+	}
+
+	/**
+	 * The location object of this range.
+	 * @type {Object}
+	 */
+	get location() {
+		return {
+			start: this.startNode.loc.start,
+			end: this.endNode.loc.end,
+		};
+	}
+
+	/**
+	 * `true` if this range is empty.
+	 * @type {boolean}
+	 */
+	get isEmpty() {
+		return !(this.startNode && this.endNode);
+	}
+
+	/**
+	 * Checks whether the given node is inside of this range.
+	 * @param {ASTNode|Token} node The node to check.
+	 * @returns {boolean} `true` if the node is inside of this range.
+	 */
+	contains(node) {
+		return (
+			node.range[0] >= this.startNode.range[0] &&
+			node.range[1] <= this.endNode.range[1]
+		);
+	}
+
+	/**
+	 * Checks whether the given node is consecutive to this range.
+	 * @param {ASTNode} node The node to check.
+	 * @returns {boolean} `true` if the node is consecutive to this range.
+	 */
+	isConsecutive(node) {
+		return this.contains(this.sourceCode.getTokenBefore(node));
+	}
+
+	/**
+	 * Merges the given node to this range.
+	 * @param {ASTNode} node The node to merge.
+	 * @returns {void}
+	 */
+	merge(node) {
+		this.endNode = node;
+	}
+
+	/**
+	 * Resets this range by the given node or null.
+	 * @param {ASTNode|null} node The node to reset, or null.
+	 * @returns {void}
+	 */
+	reset(node) {
+		this.startNode = this.endNode = node;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-unreachable",
+		},
+
+		schema: [],
+
+		messages: {
+			unreachableCode: "Unreachable code.",
+		},
+	},
+
+	create(context) {
+		/** @type {ConstructorInfo | null} */
+		let constructorInfo = null;
+
+		/** @type {ConsecutiveRange} */
+		const range = new ConsecutiveRange(context.sourceCode);
+
+		/** @type {Array<Set<CodePathSegment>>} */
+		const codePathSegments = [];
+
+		/** @type {Set<CodePathSegment>} */
+		let currentCodePathSegments = new Set();
+
+		/**
+		 * Reports a given node if it's unreachable.
+		 * @param {ASTNode} node A statement node to report.
+		 * @returns {void}
+		 */
+		function reportIfUnreachable(node) {
+			let nextNode = null;
+
+			if (
+				node &&
+				(node.type === "PropertyDefinition" ||
+					areAllSegmentsUnreachable(currentCodePathSegments))
+			) {
+				// Store this statement to distinguish consecutive statements.
+				if (range.isEmpty) {
+					range.reset(node);
+					return;
+				}
+
+				// Skip if this statement is inside of the current range.
+				if (range.contains(node)) {
+					return;
+				}
+
+				// Merge if this statement is consecutive to the current range.
+				if (range.isConsecutive(node)) {
+					range.merge(node);
+					return;
+				}
+
+				nextNode = node;
+			}
+
+			/*
+			 * Report the current range since this statement is reachable or is
+			 * not consecutive to the current range.
+			 */
+			if (!range.isEmpty) {
+				context.report({
+					messageId: "unreachableCode",
+					loc: range.location,
+					node: range.startNode,
+				});
+			}
+
+			// Update the current range.
+			range.reset(nextNode);
+		}
+
+		return {
+			// Manages the current code path.
+			onCodePathStart() {
+				codePathSegments.push(currentCodePathSegments);
+				currentCodePathSegments = new Set();
+			},
+
+			onCodePathEnd() {
+				currentCodePathSegments = codePathSegments.pop();
+			},
+
+			onUnreachableCodePathSegmentStart(segment) {
+				currentCodePathSegments.add(segment);
+			},
+
+			onUnreachableCodePathSegmentEnd(segment) {
+				currentCodePathSegments.delete(segment);
+			},
+
+			onCodePathSegmentEnd(segment) {
+				currentCodePathSegments.delete(segment);
+			},
+
+			onCodePathSegmentStart(segment) {
+				currentCodePathSegments.add(segment);
+			},
+
+			// Registers for all statement nodes (excludes FunctionDeclaration).
+			BlockStatement: reportIfUnreachable,
+			BreakStatement: reportIfUnreachable,
+			ClassDeclaration: reportIfUnreachable,
+			ContinueStatement: reportIfUnreachable,
+			DebuggerStatement: reportIfUnreachable,
+			DoWhileStatement: reportIfUnreachable,
+			ExpressionStatement: reportIfUnreachable,
+			ForInStatement: reportIfUnreachable,
+			ForOfStatement: reportIfUnreachable,
+			ForStatement: reportIfUnreachable,
+			IfStatement: reportIfUnreachable,
+			ImportDeclaration: reportIfUnreachable,
+			LabeledStatement: reportIfUnreachable,
+			ReturnStatement: reportIfUnreachable,
+			SwitchStatement: reportIfUnreachable,
+			ThrowStatement: reportIfUnreachable,
+			TryStatement: reportIfUnreachable,
+
+			VariableDeclaration(node) {
+				if (
+					node.kind !== "var" ||
+					node.declarations.some(isInitialized)
+				) {
+					reportIfUnreachable(node);
+				}
+			},
+
+			WhileStatement: reportIfUnreachable,
+			WithStatement: reportIfUnreachable,
+			ExportNamedDeclaration: reportIfUnreachable,
+			ExportDefaultDeclaration: reportIfUnreachable,
+			ExportAllDeclaration: reportIfUnreachable,
+
+			"Program:exit"() {
+				reportIfUnreachable();
+			},
+
+			/*
+			 * Instance fields defined in a subclass are never created if the constructor of the subclass
+			 * doesn't call `super()`, so their definitions are unreachable code.
+			 */
+			"MethodDefinition[kind='constructor']"() {
+				constructorInfo = {
+					upper: constructorInfo,
+					hasSuperCall: false,
+				};
+			},
+			"MethodDefinition[kind='constructor']:exit"(node) {
+				const { hasSuperCall } = constructorInfo;
+
+				constructorInfo = constructorInfo.upper;
+
+				// skip typescript constructors without the body
+				if (!node.value.body) {
+					return;
+				}
+
+				const classDefinition = node.parent.parent;
+
+				if (classDefinition.superClass && !hasSuperCall) {
+					for (const element of classDefinition.body.body) {
+						if (
+							element.type === "PropertyDefinition" &&
+							!element.static
+						) {
+							reportIfUnreachable(element);
+						}
+					}
+				}
+			},
+			"CallExpression > Super.callee"() {
+				if (constructorInfo) {
+					constructorInfo.hasSuperCall = true;
+				}
+			},
+		};
+	},
+};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-unsafe-finally.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Rule to flag unsafe statements in finally block
+ * @author Onur Temizkan
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const SENTINEL_NODE_TYPE_RETURN_THROW =
+	/^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
+const SENTINEL_NODE_TYPE_BREAK =
+	/^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/u;
+const SENTINEL_NODE_TYPE_CONTINUE =
+	/^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/u;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow control flow statements in `finally` blocks",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-unsafe-finally",
+		},
+
+		schema: [],
+
+		messages: {
+			unsafeUsage: "Unsafe usage of {{nodeType}}.",
+		},
+	},
+	create(context) {
+		/**
+		 * Checks if the node is the finalizer of a TryStatement
+		 * @param {ASTNode} node node to check.
+		 * @returns {boolean} - true if the node is the finalizer of a TryStatement
+		 */
+		function isFinallyBlock(node) {
+			return (
+				node.parent.type === "TryStatement" &&
+				node.parent.finalizer === node
+			);
+		}
+
+		/**
+		 * Climbs up the tree if the node is not a sentinel node
+		 * @param {ASTNode} node node to check.
+		 * @param {string} label label of the break or continue statement
+		 * @returns {boolean} - return whether the node is a finally block or a sentinel node
+		 */
+		function isInFinallyBlock(node, label) {
+			let labelInside = false;
+			let sentinelNodeType;
+
+			if (node.type === "BreakStatement" && !node.label) {
+				sentinelNodeType = SENTINEL_NODE_TYPE_BREAK;
+			} else if (node.type === "ContinueStatement") {
+				sentinelNodeType = SENTINEL_NODE_TYPE_CONTINUE;
+			} else {
+				sentinelNodeType = SENTINEL_NODE_TYPE_RETURN_THROW;
+			}
+
+			for (
+				let currentNode = node;
+				currentNode && !sentinelNodeType.test(currentNode.type);
+				currentNode = currentNode.parent
+			) {
+				if (
+					currentNode.parent.label &&
+					label &&
+					currentNode.parent.label.name === label.name
+				) {
+					labelInside = true;
+				}
+				if (isFinallyBlock(currentNode)) {
+					if (label && labelInside) {
+						return false;
+					}
+					return true;
+				}
+			}
+			return false;
+		}
+
+		/**
+		 * Checks whether the possibly-unsafe statement is inside a finally block.
+		 * @param {ASTNode} node node to check.
+		 * @returns {void}
+		 */
+		function check(node) {
+			if (isInFinallyBlock(node, node.label)) {
+				context.report({
+					messageId: "unsafeUsage",
+					data: {
+						nodeType: node.type,
+					},
+					node,
+					line: node.loc.line,
+					column: node.loc.column,
+				});
+			}
+		}
+
+		return {
+			ReturnStatement: check,
+			ThrowStatement: check,
+			BreakStatement: check,
+			ContinueStatement: check,
+		};
+	},
+};