@alexlit/lint-kit 166.1.0 → 167.1.0

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

@@ -1,190 +0,0 @@
-/**
- * @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

@@ -1,300 +0,0 @@
-/**
- * @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

@@ -1,119 +0,0 @@
-/**
- * @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,
-		};
-	},
-};