node_modules/eslint/lib/rules/constructor-super.js

/**
 * @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;
					}
				}
			},
		};
	},
};