eslint-plugin-absolute 0.2.4 → 0.2.6

package/src/rules/sort-keys-fixable.ts

@@ -105,18 +105,68 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				? option.variablesBeforeFunctions
 				: false;
 
-		for (const statement of sourceCode.ast.body) {
+		/**
+		 * Compare two key strings based on the provided options.
+		 * This function mimics the behavior of the built-in rule.
+		 */
+		const compareKeys = (keyLeft: string, keyRight: string) => {
+			let left = keyLeft;
+			let right = keyRight;
+
+			if (!caseSensitive) {
+				left = left.toLowerCase();
+				right = right.toLowerCase();
+			}
+
+			if (natural) {
+				return left.localeCompare(right, undefined, {
+					numeric: true
+				});
+			}
+
+			return left.localeCompare(right);
+		};
+
+		const addImportBindings = (statement: TSESTree.ImportDeclaration) => {
+			if (statement.specifiers.length === 0) {
+				return;
+			}
+
+			for (const specifier of statement.specifiers) {
+				topLevelBindings.set(specifier.local.name, {
+					kind: "import"
+				});
+			}
+		};
+
+		const addVariableBinding = (
+			declaration: TSESTree.VariableDeclarator
+		) => {
+			if (declaration.id.type !== "Identifier" || !declaration.init) {
+				return;
+			}
+
 			if (
-				statement.type === "ImportDeclaration" &&
-				statement.specifiers.length > 0
+				declaration.init.type === "ArrowFunctionExpression" ||
+				declaration.init.type === "FunctionExpression"
 			) {
-				for (const specifier of statement.specifiers) {
-					topLevelBindings.set(specifier.local.name, {
-						kind: "import"
-					});
-				}
+				topLevelBindings.set(declaration.id.name, {
+					kind: "function",
+					node: declaration.init
+				});
+				return;
+			}
+
+			topLevelBindings.set(declaration.id.name, {
+				kind: "value",
+				node: declaration.init
+			});
+		};
 
-				continue;
+		const addTopLevelBindings = (statement: TSESTree.ProgramStatement) => {
+			if (statement.type === "ImportDeclaration") {
+				addImportBindings(statement);
+				return;
 			}
 
 			if (statement.type === "FunctionDeclaration" && statement.id) {
@@ -124,60 +174,144 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 					kind: "function",
 					node: statement
 				});
-
-				continue;
+				return;
 			}
 
 			if (
 				statement.type !== "VariableDeclaration" ||
 				statement.kind !== "const"
 			) {
-				continue;
+				return;
 			}
 
 			for (const declaration of statement.declarations) {
-				if (declaration.id.type !== "Identifier" || !declaration.init) {
-					continue;
-				}
+				addVariableBinding(declaration);
+			}
+		};
+
+		for (const statement of sourceCode.ast.body) {
+			addTopLevelBindings(statement);
+		}
+
+		const addBoundIdentifiers = (
+			node: TSESTree.Node | null,
+			stableLocals: Set<string>
+		) => {
+			if (!node) {
+				return;
+			}
+
+			switch (node.type) {
+				case "Identifier":
+					stableLocals.add(node.name);
+					return;
+				case "AssignmentPattern":
+					addBoundIdentifiers(node.left, stableLocals);
+					return;
+				case "RestElement":
+					addBoundIdentifiers(node.argument, stableLocals);
+					return;
+				case "ArrayPattern":
+					for (const element of node.elements.filter(Boolean)) {
+						addBoundIdentifiers(element, stableLocals);
+					}
+					break;
+				case "ObjectPattern":
+					for (const property of node.properties) {
+						const bindingNode =
+							property.type === "RestElement"
+								? property.argument
+								: property.value;
+						addBoundIdentifiers(bindingNode, stableLocals);
+					}
+					break;
+				default:
+					break;
+			}
+		};
 
+		const addFunctionParamBindings = (
+			functionNode:
+				| TSESTree.ArrowFunctionExpression
+				| TSESTree.FunctionDeclaration
+				| TSESTree.FunctionExpression,
+			stableLocals: Set<string>
+		) => {
+			for (const parameter of functionNode.params) {
+				addBoundIdentifiers(parameter, stableLocals);
+			}
+		};
+
+		const addAncestorConstBindings = (
+			ancestor: TSESTree.BlockStatement | TSESTree.Program,
+			node: TSESTree.Node,
+			stableLocals: Set<string>
+		) => {
+			const addDeclarationBindings = (statement: TSESTree.Statement) => {
 				if (
-					declaration.init.type === "ArrowFunctionExpression" ||
-					declaration.init.type === "FunctionExpression"
+					statement.type !== "VariableDeclaration" ||
+					statement.kind !== "const"
 				) {
-					topLevelBindings.set(declaration.id.name, {
-						kind: "function",
-						node: declaration.init
-					});
-					continue;
+					return;
 				}
 
-				topLevelBindings.set(declaration.id.name, {
-					kind: "value",
-					node: declaration.init
-				});
+				for (const declaration of statement.declarations) {
+					addBoundIdentifiers(declaration.id, stableLocals);
+				}
+			};
+
+			for (const statement of ancestor.body) {
+				if (statement.range[0] >= node.range[0]) {
+					return;
+				}
+
+				addDeclarationBindings(statement);
 			}
-		}
+		};
 
-		/**
-		 * Compare two key strings based on the provided options.
-		 * This function mimics the behavior of the built-in rule.
-		 */
-		const compareKeys = (keyLeft: string, keyRight: string) => {
-			let left = keyLeft;
-			let right = keyRight;
+		const addAncestorBindingsForNode = (
+			ancestor: TSESTree.Node,
+			node: TSESTree.Node,
+			stableLocals: Set<string>
+		) => {
+			if (
+				ancestor.type !== "Program" &&
+				ancestor.type !== "BlockStatement"
+			) {
+				return;
+			}
 
-			if (!caseSensitive) {
-				left = left.toLowerCase();
-				right = right.toLowerCase();
+			addAncestorConstBindings(ancestor, node, stableLocals);
+		};
+
+		const addFunctionBindingsForAncestor = (
+			ancestor: TSESTree.Node,
+			stableLocals: Set<string>
+		) => {
+			if (
+				ancestor.type !== "FunctionDeclaration" &&
+				ancestor.type !== "FunctionExpression" &&
+				ancestor.type !== "ArrowFunctionExpression"
+			) {
+				return;
 			}
 
-			if (natural) {
-				return left.localeCompare(right, undefined, {
-					numeric: true
-				});
+			addFunctionParamBindings(ancestor, stableLocals);
+		};
+
+		const getStableLocalsForNode = (node: TSESTree.Node) => {
+			const stableLocals = new Set<string>();
+			const ancestors = sourceCode.getAncestors(node);
+
+			for (const ancestor of ancestors) {
+				addFunctionBindingsForAncestor(ancestor, stableLocals);
 			}
 
-			return left.localeCompare(right);
+			for (const ancestor of ancestors) {
+				addAncestorBindingsForNode(ancestor, node, stableLocals);
+			}
+
+			return stableLocals;
 		};
 
 		const getStaticMemberName = (
@@ -225,12 +359,77 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			return false;
 		};
 
+		const isPureConstStatement = (
+			statement: TSESTree.VariableDeclaration,
+			stableLocals: Set<string>,
+			checkExpression: (expression: TSESTree.Expression) => boolean
+		) => {
+			if (statement.kind !== "const") {
+				return false;
+			}
+
+			for (const declaration of statement.declarations) {
+				if (declaration.id.type !== "Identifier" || !declaration.init) {
+					return false;
+				}
+
+				if (!checkExpression(declaration.init)) {
+					return false;
+				}
+
+				stableLocals.add(declaration.id.name);
+			}
+
+			return true;
+		};
+
+		const isPureFunctionStatement = (
+			statement: TSESTree.Statement,
+			stableLocals: Set<string>,
+			checkExpression: (expression: TSESTree.Expression) => boolean
+		) => {
+			if (statement.type === "ReturnStatement") {
+				return (
+					!statement.argument || checkExpression(statement.argument)
+				);
+			}
+
+			if (statement.type === "VariableDeclaration") {
+				return isPureConstStatement(
+					statement,
+					stableLocals,
+					checkExpression
+				);
+			}
+
+			return false;
+		};
+
+		const isPureFunctionBody = (
+			body: TSESTree.BlockStatement,
+			stableLocals: Set<string>,
+			checkExpression: (expression: TSESTree.Expression) => boolean
+		) => {
+			for (const statement of body.body) {
+				const statementIsPure = isPureFunctionStatement(
+					statement,
+					stableLocals,
+					checkExpression
+				);
+				if (!statementIsPure) {
+					return false;
+				}
+			}
+
+			return true;
+		};
+
 		const isPureTopLevelFunction = (
 			functionNode:
 				| TSESTree.ArrowFunctionExpression
 				| TSESTree.FunctionDeclaration
 				| TSESTree.FunctionExpression
-		): boolean => {
+		) => {
 			const cached = pureFunctionCache.get(functionNode);
 			if (cached !== undefined) {
 				return cached;
@@ -243,63 +442,38 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			pureFunctionInProgress.add(functionNode);
 
 			const stableLocals = new Set<string>();
-
-			for (const parameter of functionNode.params) {
-				if (parameter.type === "Identifier") {
-					stableLocals.add(parameter.name);
-				}
-			}
-
-			let isPure = true;
+			addFunctionParamBindings(functionNode, stableLocals);
 			const checkExpression = (expression: TSESTree.Expression) =>
 				isPureRuntimeExpression(expression, stableLocals);
+			const isPure =
+				functionNode.body.type === "BlockStatement"
+					? isPureFunctionBody(
+							functionNode.body,
+							stableLocals,
+							checkExpression
+						)
+					: checkExpression(functionNode.body);
 
-			if (functionNode.body.type === "BlockStatement") {
-				for (const statement of functionNode.body.body) {
-					if (statement.type === "ReturnStatement") {
-						if (
-							statement.argument &&
-							!checkExpression(statement.argument)
-						) {
-							isPure = false;
-						}
-						continue;
-					}
-
-					if (
-						statement.type === "VariableDeclaration" &&
-						statement.kind === "const"
-					) {
-						for (const declaration of statement.declarations) {
-							if (
-								declaration.id.type !== "Identifier" ||
-								!declaration.init ||
-								!checkExpression(declaration.init)
-							) {
-								isPure = false;
-								break;
-							}
-
-							stableLocals.add(declaration.id.name);
-						}
-
-						if (!isPure) {
-							break;
-						}
+			pureFunctionInProgress.delete(functionNode);
+			pureFunctionCache.set(functionNode, isPure);
+			return isPure;
+		};
 
-						continue;
-					}
+		const isPureIdentifierCall = (
+			callExpression: TSESTree.CallExpression
+		) => {
+			if (callExpression.callee.type !== "Identifier") {
+				return false;
+			}
 
-					isPure = false;
-					break;
-				}
-			} else {
-				isPure = checkExpression(functionNode.body);
+			if (PURE_GLOBAL_FUNCTIONS.has(callExpression.callee.name)) {
+				return true;
 			}
 
-			pureFunctionInProgress.delete(functionNode);
-			pureFunctionCache.set(functionNode, isPure);
-			return isPure;
+			const binding = topLevelBindings.get(callExpression.callee.name);
+			return binding?.kind === "function"
+				? isPureTopLevelFunction(binding.node)
+				: false;
 		};
 
 		const isPureRuntimeExpression: (
@@ -413,15 +587,7 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 					}
 
 					if (node.callee.type === "Identifier") {
-						if (PURE_GLOBAL_FUNCTIONS.has(node.callee.name)) {
-							return true;
-						}
-
-						const binding = topLevelBindings.get(node.callee.name);
-						return (
-							binding?.kind === "function" &&
-							isPureTopLevelFunction(binding.node)
-						);
+						return isPureIdentifierCall(node);
 					}
 
 					if (node.callee.type !== "MemberExpression") {
@@ -443,12 +609,9 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			}
 		};
 
-		const isSafeToReorderExpression: (
-			node: TSESTree.Node | null
-		) => boolean = (node) => isPureRuntimeExpression(node, new Set());
-
 		const isSafeJSXAttributeValue = (
-			value: TSESTree.JSXAttribute["value"]
+			value: TSESTree.JSXAttribute["value"],
+			scopeNode: TSESTree.Node
 		) => {
 			if (value === null) {
 				return true;
@@ -466,7 +629,10 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				return false;
 			}
 
-			return isSafeToReorderExpression(value.expression);
+			return isPureRuntimeExpression(
+				value.expression,
+				getStableLocalsForNode(scopeNode)
+			);
 		};
 
 		/**
@@ -761,7 +927,10 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				keys.some(
 					(key) =>
 						key.node.type === "Property" &&
-						!isSafeToReorderExpression(key.node.value)
+						!isPureRuntimeExpression(
+							key.node.value,
+							getStableLocalsForNode(key.node)
+						)
 				)
 			) {
 				autoFixable = false;
@@ -953,7 +1122,7 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				attrs.some(
 					(attr) =>
 						attr.type === "JSXAttribute" &&
-						!isSafeJSXAttributeValue(attr.value)
+						!isSafeJSXAttributeValue(attr.value, attr)
 				)
 			) {
 				context.report({