eslint-plugin-absolute 0.2.3 → 0.2.5

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

@@ -34,7 +34,33 @@ type KeyInfo = {
 	isFunction: boolean;
 };
 
+type TopLevelBinding =
+	| {
+			kind: "function";
+			node:
+				| TSESTree.ArrowFunctionExpression
+				| TSESTree.FunctionDeclaration
+				| TSESTree.FunctionExpression;
+	  }
+	| {
+			kind: "import";
+	  }
+	| {
+			kind: "value";
+			node: TSESTree.Expression;
+	  };
+
 const SORT_BEFORE = -1;
+const PURE_CONSTRUCTORS = new Set(["Date"]);
+const PURE_GLOBAL_FUNCTIONS = new Set(["Boolean", "Number", "String"]);
+const PURE_MEMBER_METHODS = new Set([
+	"getDay",
+	"getHours",
+	"getMilliseconds",
+	"getMinutes",
+	"getSeconds",
+	"padStart"
+]);
 
 const hasDuplicateNames = (names: Array<string | null>) => {
 	const seen = new Set<string>();
@@ -50,91 +76,13 @@ const hasDuplicateNames = (names: Array<string | null>) => {
 	return false;
 };
 
-const isSafeStaticTemplate = (node: TSESTree.TemplateLiteral) =>
-	node.expressions.length === 0;
-
-const isSafeArrayElement: (node: TSESTree.Node | null) => boolean = (node) => {
-	if (!node || node.type === "SpreadElement") {
-		return false;
-	}
-
-	return isSafeToReorderExpression(node);
-};
-
-const isSafeObjectProperty: (
-	property: TSESTree.ObjectExpression["properties"][number]
-) => boolean = (property) => {
-	if (
-		property.type !== "Property" ||
-		property.computed ||
-		property.kind !== "init"
-	) {
-		return false;
-	}
-
-	if (property.key.type !== "Identifier" && property.key.type !== "Literal") {
-		return false;
-	}
-
-	if (property.method) {
-		return true;
-	}
-
-	return isSafeToReorderExpression(property.value);
-};
-
-const isSafeToReorderExpression: (node: TSESTree.Node | null) => boolean = (
-	node
-) => {
-	if (!node || node.type === "PrivateIdentifier") {
-		return false;
-	}
-
-	switch (node.type) {
-		case "Identifier":
-		case "Literal":
-		case "ThisExpression":
-		case "FunctionExpression":
-		case "ArrowFunctionExpression":
-		case "ClassExpression":
-			return true;
-		case "TemplateLiteral":
-			return isSafeStaticTemplate(node);
-		case "UnaryExpression":
-			return isSafeToReorderExpression(node.argument);
-		case "ArrayExpression":
-			return node.elements.every(isSafeArrayElement);
-		case "ObjectExpression":
-			return node.properties.every(isSafeObjectProperty);
-		default:
-			return false;
-	}
-};
-
-const isSafeJSXAttributeValue = (value: TSESTree.JSXAttribute["value"]) => {
-	if (value === null) {
-		return true;
-	}
-
-	if (value.type === "Literal") {
-		return true;
-	}
-
-	if (value.type !== "JSXExpressionContainer") {
-		return false;
-	}
-
-	if (value.expression.type === "JSXEmptyExpression") {
-		return false;
-	}
-
-	return isSafeToReorderExpression(value.expression);
-};
-
 export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 	create(context) {
 		const { sourceCode } = context;
 		const [option] = context.options;
+		const topLevelBindings = new Map<string, TopLevelBinding>();
+		const pureFunctionCache = new Map<TSESTree.Node, boolean>();
+		const pureFunctionInProgress = new Set<TSESTree.Node>();
 
 		const order: "asc" | "desc" =
 			option && option.order ? option.order : "asc";
@@ -157,6 +105,59 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				? option.variablesBeforeFunctions
 				: false;
 
+		for (const statement of sourceCode.ast.body) {
+			if (
+				statement.type === "ImportDeclaration" &&
+				statement.specifiers.length > 0
+			) {
+				for (const specifier of statement.specifiers) {
+					topLevelBindings.set(specifier.local.name, {
+						kind: "import"
+					});
+				}
+
+				continue;
+			}
+
+			if (statement.type === "FunctionDeclaration" && statement.id) {
+				topLevelBindings.set(statement.id.name, {
+					kind: "function",
+					node: statement
+				});
+
+				continue;
+			}
+
+			if (
+				statement.type !== "VariableDeclaration" ||
+				statement.kind !== "const"
+			) {
+				continue;
+			}
+
+			for (const declaration of statement.declarations) {
+				if (declaration.id.type !== "Identifier" || !declaration.init) {
+					continue;
+				}
+
+				if (
+					declaration.init.type === "ArrowFunctionExpression" ||
+					declaration.init.type === "FunctionExpression"
+				) {
+					topLevelBindings.set(declaration.id.name, {
+						kind: "function",
+						node: declaration.init
+					});
+					continue;
+				}
+
+				topLevelBindings.set(declaration.id.name, {
+					kind: "value",
+					node: declaration.init
+				});
+			}
+		}
+
 		/**
 		 * Compare two key strings based on the provided options.
 		 * This function mimics the behavior of the built-in rule.
@@ -179,6 +180,387 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			return left.localeCompare(right);
 		};
 
+		const addBoundIdentifiers = (
+			node: TSESTree.Node | null,
+			stableLocals: Set<string>
+		) => {
+			if (!node) {
+				return;
+			}
+
+			if (node.type === "Identifier") {
+				stableLocals.add(node.name);
+				return;
+			}
+
+			if (node.type === "AssignmentPattern") {
+				addBoundIdentifiers(node.left, stableLocals);
+				return;
+			}
+
+			if (node.type === "RestElement") {
+				addBoundIdentifiers(node.argument, stableLocals);
+				return;
+			}
+
+			if (node.type === "ArrayPattern") {
+				for (const element of node.elements) {
+					if (!element) {
+						continue;
+					}
+
+					addBoundIdentifiers(element, stableLocals);
+				}
+				return;
+			}
+
+			if (node.type === "ObjectPattern") {
+				for (const property of node.properties) {
+					if (property.type === "RestElement") {
+						addBoundIdentifiers(property.argument, stableLocals);
+						continue;
+					}
+
+					addBoundIdentifiers(property.value, stableLocals);
+				}
+			}
+		};
+
+		const getStableLocalsForNode = (node: TSESTree.Node) => {
+			const stableLocals = new Set<string>();
+			const ancestors = sourceCode.getAncestors(node);
+
+			for (const ancestor of ancestors) {
+				if (
+					ancestor.type === "FunctionDeclaration" ||
+					ancestor.type === "FunctionExpression" ||
+					ancestor.type === "ArrowFunctionExpression"
+				) {
+					for (const parameter of ancestor.params) {
+						addBoundIdentifiers(parameter, stableLocals);
+					}
+				}
+			}
+
+			for (const ancestor of ancestors) {
+				if (
+					ancestor.type !== "Program" &&
+					ancestor.type !== "BlockStatement"
+				) {
+					continue;
+				}
+
+				for (const statement of ancestor.body) {
+					if (
+						statement.range[0] >= node.range[0] ||
+						statement.type !== "VariableDeclaration" ||
+						statement.kind !== "const"
+					) {
+						break;
+					}
+
+					for (const declaration of statement.declarations) {
+						addBoundIdentifiers(declaration.id, stableLocals);
+					}
+				}
+			}
+
+			return stableLocals;
+		};
+
+		const getStaticMemberName = (
+			memberExpression: TSESTree.MemberExpression
+		) => {
+			if (
+				!memberExpression.computed &&
+				memberExpression.property.type === "Identifier"
+			) {
+				return memberExpression.property.name;
+			}
+
+			if (
+				memberExpression.computed &&
+				memberExpression.property.type === "Literal" &&
+				typeof memberExpression.property.value === "string"
+			) {
+				return memberExpression.property.value;
+			}
+
+			return null;
+		};
+
+		const isStableIdentifier = (
+			name: string,
+			stableLocals: ReadonlySet<string>
+		) => {
+			if (stableLocals.has(name)) {
+				return true;
+			}
+
+			const binding = topLevelBindings.get(name);
+			if (!binding) {
+				return false;
+			}
+
+			if (binding.kind === "import") {
+				return true;
+			}
+
+			if (binding.kind === "value") {
+				return isPureRuntimeExpression(binding.node, stableLocals);
+			}
+
+			return false;
+		};
+
+		const isPureTopLevelFunction = (
+			functionNode:
+				| TSESTree.ArrowFunctionExpression
+				| TSESTree.FunctionDeclaration
+				| TSESTree.FunctionExpression
+		): boolean => {
+			const cached = pureFunctionCache.get(functionNode);
+			if (cached !== undefined) {
+				return cached;
+			}
+
+			if (pureFunctionInProgress.has(functionNode)) {
+				return false;
+			}
+
+			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;
+			const checkExpression = (expression: TSESTree.Expression) =>
+				isPureRuntimeExpression(expression, stableLocals);
+
+			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;
+						}
+
+						continue;
+					}
+
+					isPure = false;
+					break;
+				}
+			} else {
+				isPure = checkExpression(functionNode.body);
+			}
+
+			pureFunctionInProgress.delete(functionNode);
+			pureFunctionCache.set(functionNode, isPure);
+			return isPure;
+		};
+
+		const isPureRuntimeExpression: (
+			node: TSESTree.Node | null,
+			stableLocals: ReadonlySet<string>
+		) => boolean = (node, stableLocals) => {
+			if (!node || node.type === "PrivateIdentifier") {
+				return false;
+			}
+
+			switch (node.type) {
+				case "Identifier":
+					return isStableIdentifier(node.name, stableLocals);
+				case "Literal":
+				case "FunctionExpression":
+				case "ArrowFunctionExpression":
+				case "ClassExpression":
+					return true;
+				case "ThisExpression":
+					return stableLocals.has("this");
+				case "TemplateLiteral":
+					return node.expressions.every((expression) =>
+						isPureRuntimeExpression(expression, stableLocals)
+					);
+				case "UnaryExpression":
+					return isPureRuntimeExpression(node.argument, stableLocals);
+				case "BinaryExpression":
+				case "LogicalExpression":
+					return (
+						isPureRuntimeExpression(node.left, stableLocals) &&
+						isPureRuntimeExpression(node.right, stableLocals)
+					);
+				case "ConditionalExpression":
+					return (
+						isPureRuntimeExpression(node.test, stableLocals) &&
+						isPureRuntimeExpression(
+							node.consequent,
+							stableLocals
+						) &&
+						isPureRuntimeExpression(node.alternate, stableLocals)
+					);
+				case "ArrayExpression":
+					return node.elements.every((element) => {
+						if (!element || element.type === "SpreadElement") {
+							return false;
+						}
+
+						return isPureRuntimeExpression(element, stableLocals);
+					});
+				case "ObjectExpression":
+					return node.properties.every((property) => {
+						if (
+							property.type !== "Property" ||
+							property.computed ||
+							property.kind !== "init"
+						) {
+							return false;
+						}
+
+						if (
+							property.key.type !== "Identifier" &&
+							property.key.type !== "Literal"
+						) {
+							return false;
+						}
+
+						if (property.method) {
+							return true;
+						}
+
+						return isPureRuntimeExpression(
+							property.value,
+							stableLocals
+						);
+					});
+				case "MemberExpression":
+					return (
+						isPureRuntimeExpression(node.object, stableLocals) &&
+						(!node.computed ||
+							isPureRuntimeExpression(
+								node.property,
+								stableLocals
+							))
+					);
+				case "NewExpression":
+					return (
+						node.callee.type === "Identifier" &&
+						PURE_CONSTRUCTORS.has(node.callee.name) &&
+						node.arguments.every((argument) => {
+							if (argument.type === "SpreadElement") {
+								return false;
+							}
+
+							return isPureRuntimeExpression(
+								argument,
+								stableLocals
+							);
+						})
+					);
+				case "CallExpression": {
+					const argsArePure = node.arguments.every((argument) => {
+						if (argument.type === "SpreadElement") {
+							return false;
+						}
+
+						return isPureRuntimeExpression(argument, stableLocals);
+					});
+
+					if (!argsArePure) {
+						return false;
+					}
+
+					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)
+						);
+					}
+
+					if (node.callee.type !== "MemberExpression") {
+						return false;
+					}
+
+					const memberName = getStaticMemberName(node.callee);
+					if (!memberName || !PURE_MEMBER_METHODS.has(memberName)) {
+						return false;
+					}
+
+					return isPureRuntimeExpression(
+						node.callee.object,
+						stableLocals
+					);
+				}
+				default:
+					return false;
+			}
+		};
+
+		const isSafeToReorderExpression: (
+			node: TSESTree.Node | null
+		) => boolean = (node) => isPureRuntimeExpression(node, new Set());
+
+		const isSafeJSXAttributeValue = (
+			value: TSESTree.JSXAttribute["value"],
+			scopeNode: TSESTree.Node
+		) => {
+			if (value === null) {
+				return true;
+			}
+
+			if (value.type === "Literal") {
+				return true;
+			}
+
+			if (value.type !== "JSXExpressionContainer") {
+				return false;
+			}
+
+			if (value.expression.type === "JSXEmptyExpression") {
+				return false;
+			}
+
+			return isPureRuntimeExpression(
+				value.expression,
+				getStableLocalsForNode(scopeNode)
+			);
+		};
+
 		/**
 		 * Determines if a property is a function property.
 		 */
@@ -471,7 +853,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;
@@ -663,7 +1048,7 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 				attrs.some(
 					(attr) =>
 						attr.type === "JSXAttribute" &&
-						!isSafeJSXAttributeValue(attr.value)
+						!isSafeJSXAttributeValue(attr.value, attr)
 				)
 			) {
 				context.report({