@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/constructor-super.js

@@ -1,453 +0,0 @@
-/**
- * @fileoverview A rule to verify `super()` callings in constructor.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a given node is a constructor.
- * @param {ASTNode} node A node to check. This node type is one of
- *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and
- *   `ArrowFunctionExpression`.
- * @returns {boolean} `true` if the node is a constructor.
- */
-function isConstructorFunction(node) {
-	return (
-		node.type === "FunctionExpression" &&
-		node.parent.type === "MethodDefinition" &&
-		node.parent.kind === "constructor"
-	);
-}
-
-/**
- * Checks whether a given node can be a constructor or not.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node can be a constructor.
- */
-function isPossibleConstructor(node) {
-	if (!node) {
-		return false;
-	}
-
-	switch (node.type) {
-		case "ClassExpression":
-		case "FunctionExpression":
-		case "ThisExpression":
-		case "MemberExpression":
-		case "CallExpression":
-		case "NewExpression":
-		case "ChainExpression":
-		case "YieldExpression":
-		case "TaggedTemplateExpression":
-		case "MetaProperty":
-			return true;
-
-		case "Identifier":
-			return node.name !== "undefined";
-
-		case "AssignmentExpression":
-			if (["=", "&&="].includes(node.operator)) {
-				return isPossibleConstructor(node.right);
-			}
-
-			if (["||=", "??="].includes(node.operator)) {
-				return (
-					isPossibleConstructor(node.left) ||
-					isPossibleConstructor(node.right)
-				);
-			}
-
-			/**
-			 * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
-			 * An assignment expression with a mathematical operator can either evaluate to a primitive value,
-			 * or throw, depending on the operands. Thus, it cannot evaluate to a constructor function.
-			 */
-			return false;
-
-		case "LogicalExpression":
-			/*
-			 * If the && operator short-circuits, the left side was falsy and therefore not a constructor, and if
-			 * it doesn't short-circuit, it takes the value from the right side, so the right side must always be a
-			 * possible constructor. A future improvement could verify that the left side could be truthy by
-			 * excluding falsy literals.
-			 */
-			if (node.operator === "&&") {
-				return isPossibleConstructor(node.right);
-			}
-
-			return (
-				isPossibleConstructor(node.left) ||
-				isPossibleConstructor(node.right)
-			);
-
-		case "ConditionalExpression":
-			return (
-				isPossibleConstructor(node.alternate) ||
-				isPossibleConstructor(node.consequent)
-			);
-
-		case "SequenceExpression": {
-			const lastExpression = node.expressions.at(-1);
-
-			return isPossibleConstructor(lastExpression);
-		}
-
-		default:
-			return false;
-	}
-}
-
-/**
- * A class to store information about a code path segment.
- */
-class SegmentInfo {
-	/**
-	 * Indicates if super() is called in all code paths.
-	 * @type {boolean}
-	 */
-	calledInEveryPaths = false;
-
-	/**
-	 * Indicates if super() is called in any code paths.
-	 * @type {boolean}
-	 */
-	calledInSomePaths = false;
-
-	/**
-	 * The nodes which have been validated and don't need to be reconsidered.
-	 * @type {ASTNode[]}
-	 */
-	validNodes = [];
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description: "Require `super()` calls in constructors",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/constructor-super",
-		},
-
-		schema: [],
-
-		messages: {
-			missingSome: "Lacked a call of 'super()' in some code paths.",
-			missingAll: "Expected to call 'super()'.",
-
-			duplicate: "Unexpected duplicate 'super()'.",
-			badSuper:
-				"Unexpected 'super()' because 'super' is not a constructor.",
-		},
-	},
-
-	create(context) {
-		/*
-		 * {{hasExtends: boolean, scope: Scope, codePath: CodePath}[]}
-		 * Information for each constructor.
-		 * - upper:      Information of the upper constructor.
-		 * - hasExtends: A flag which shows whether own class has a valid `extends`
-		 *               part.
-		 * - scope:      The scope of own class.
-		 * - codePath:   The code path object of the constructor.
-		 */
-		let funcInfo = null;
-
-		/**
-		 * @type {Record<string, SegmentInfo>}
-		 */
-		const segInfoMap = Object.create(null);
-
-		/**
-		 * Gets the flag which shows `super()` is called in some paths.
-		 * @param {CodePathSegment} segment A code path segment to get.
-		 * @returns {boolean} The flag which shows `super()` is called in some paths
-		 */
-		function isCalledInSomePath(segment) {
-			return (
-				segment.reachable && segInfoMap[segment.id].calledInSomePaths
-			);
-		}
-
-		/**
-		 * Determines if a segment has been seen in the traversal.
-		 * @param {CodePathSegment} segment A code path segment to check.
-		 * @returns {boolean} `true` if the segment has been seen.
-		 */
-		function hasSegmentBeenSeen(segment) {
-			return !!segInfoMap[segment.id];
-		}
-
-		/**
-		 * Gets the flag which shows `super()` is called in all paths.
-		 * @param {CodePathSegment} segment A code path segment to get.
-		 * @returns {boolean} The flag which shows `super()` is called in all paths.
-		 */
-		function isCalledInEveryPath(segment) {
-			return (
-				segment.reachable && segInfoMap[segment.id].calledInEveryPaths
-			);
-		}
-
-		return {
-			/**
-			 * Stacks a constructor information.
-			 * @param {CodePath} codePath A code path which was started.
-			 * @param {ASTNode} node The current node.
-			 * @returns {void}
-			 */
-			onCodePathStart(codePath, node) {
-				if (isConstructorFunction(node)) {
-					// Class > ClassBody > MethodDefinition > FunctionExpression
-					const classNode = node.parent.parent.parent;
-					const superClass = classNode.superClass;
-
-					funcInfo = {
-						upper: funcInfo,
-						isConstructor: true,
-						hasExtends: Boolean(superClass),
-						superIsConstructor: isPossibleConstructor(superClass),
-						codePath,
-						currentSegments: new Set(),
-					};
-				} else {
-					funcInfo = {
-						upper: funcInfo,
-						isConstructor: false,
-						hasExtends: false,
-						superIsConstructor: false,
-						codePath,
-						currentSegments: new Set(),
-					};
-				}
-			},
-
-			/**
-			 * Pops a constructor information.
-			 * And reports if `super()` lacked.
-			 * @param {CodePath} codePath A code path which was ended.
-			 * @param {ASTNode} node The current node.
-			 * @returns {void}
-			 */
-			onCodePathEnd(codePath, node) {
-				const hasExtends = funcInfo.hasExtends;
-
-				// Pop.
-				funcInfo = funcInfo.upper;
-
-				if (!hasExtends) {
-					return;
-				}
-
-				// Reports if `super()` lacked.
-				const returnedSegments = codePath.returnedSegments;
-				const calledInEveryPaths =
-					returnedSegments.every(isCalledInEveryPath);
-				const calledInSomePaths =
-					returnedSegments.some(isCalledInSomePath);
-
-				if (!calledInEveryPaths) {
-					context.report({
-						messageId: calledInSomePaths
-							? "missingSome"
-							: "missingAll",
-						node: node.parent,
-					});
-				}
-			},
-
-			/**
-			 * Initialize information of a given code path segment.
-			 * @param {CodePathSegment} segment A code path segment to initialize.
-			 * @param {CodePathSegment} node Node that starts the segment.
-			 * @returns {void}
-			 */
-			onCodePathSegmentStart(segment, node) {
-				funcInfo.currentSegments.add(segment);
-
-				if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
-					return;
-				}
-
-				// Initialize info.
-				const info = (segInfoMap[segment.id] = new SegmentInfo());
-
-				const seenPrevSegments =
-					segment.prevSegments.filter(hasSegmentBeenSeen);
-
-				// When there are previous segments, aggregates these.
-				if (seenPrevSegments.length > 0) {
-					info.calledInSomePaths =
-						seenPrevSegments.some(isCalledInSomePath);
-					info.calledInEveryPaths =
-						seenPrevSegments.every(isCalledInEveryPath);
-				}
-
-				/*
-				 * ForStatement > *.update segments are a special case as they are created in advance,
-				 * without seen previous segments. Since they logically don't affect `calledInEveryPaths`
-				 * calculations, and they can never be a lone previous segment of another one, we'll set
-				 * their `calledInEveryPaths` to `true` to effectively ignore them in those calculations.
-				 * .
-				 */
-				if (
-					node.parent &&
-					node.parent.type === "ForStatement" &&
-					node.parent.update === node
-				) {
-					info.calledInEveryPaths = true;
-				}
-			},
-
-			onUnreachableCodePathSegmentStart(segment) {
-				funcInfo.currentSegments.add(segment);
-			},
-
-			onUnreachableCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			onCodePathSegmentEnd(segment) {
-				funcInfo.currentSegments.delete(segment);
-			},
-
-			/**
-			 * Update information of the code path segment when a code path was
-			 * looped.
-			 * @param {CodePathSegment} fromSegment The code path segment of the
-			 *      end of a loop.
-			 * @param {CodePathSegment} toSegment A code path segment of the head
-			 *      of a loop.
-			 * @returns {void}
-			 */
-			onCodePathSegmentLoop(fromSegment, toSegment) {
-				if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
-					return;
-				}
-
-				funcInfo.codePath.traverseSegments(
-					{ first: toSegment, last: fromSegment },
-					(segment, controller) => {
-						const info = segInfoMap[segment.id];
-
-						// skip segments after the loop
-						if (!info) {
-							controller.skip();
-							return;
-						}
-
-						const seenPrevSegments =
-							segment.prevSegments.filter(hasSegmentBeenSeen);
-						const calledInSomePreviousPaths =
-							seenPrevSegments.some(isCalledInSomePath);
-						const calledInEveryPreviousPaths =
-							seenPrevSegments.every(isCalledInEveryPath);
-
-						info.calledInSomePaths ||= calledInSomePreviousPaths;
-						info.calledInEveryPaths ||= calledInEveryPreviousPaths;
-
-						// If flags become true anew, reports the valid nodes.
-						if (calledInSomePreviousPaths) {
-							const nodes = info.validNodes;
-
-							info.validNodes = [];
-
-							for (let i = 0; i < nodes.length; ++i) {
-								const node = nodes[i];
-
-								context.report({
-									messageId: "duplicate",
-									node,
-								});
-							}
-						}
-					},
-				);
-			},
-
-			/**
-			 * Checks for a call of `super()`.
-			 * @param {ASTNode} node A CallExpression node to check.
-			 * @returns {void}
-			 */
-			"CallExpression:exit"(node) {
-				if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
-					return;
-				}
-
-				// Skips except `super()`.
-				if (node.callee.type !== "Super") {
-					return;
-				}
-
-				// Reports if needed.
-				const segments = funcInfo.currentSegments;
-				let duplicate = false;
-				let info = null;
-
-				for (const segment of segments) {
-					if (segment.reachable) {
-						info = segInfoMap[segment.id];
-
-						duplicate = duplicate || info.calledInSomePaths;
-						info.calledInSomePaths = info.calledInEveryPaths = true;
-					}
-				}
-
-				if (info) {
-					if (duplicate) {
-						context.report({
-							messageId: "duplicate",
-							node,
-						});
-					} else if (!funcInfo.superIsConstructor) {
-						context.report({
-							messageId: "badSuper",
-							node,
-						});
-					} else {
-						info.validNodes.push(node);
-					}
-				}
-			},
-
-			/**
-			 * Set the mark to the returned path as `super()` was called.
-			 * @param {ASTNode} node A ReturnStatement node to check.
-			 * @returns {void}
-			 */
-			ReturnStatement(node) {
-				if (!(funcInfo.isConstructor && funcInfo.hasExtends)) {
-					return;
-				}
-
-				// Skips if no argument.
-				if (!node.argument) {
-					return;
-				}
-
-				// Returning argument is a substitute of 'super()'.
-				const segments = funcInfo.currentSegments;
-
-				for (const segment of segments) {
-					if (segment.reachable) {
-						const info = segInfoMap[segment.id];
-
-						info.calledInSomePaths = info.calledInEveryPaths = true;
-					}
-				}
-			},
-		};
-	},
-};