eslint-plugin-absolute 0.2.5 → 0.2.7

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

@@ -52,6 +52,23 @@ type TopLevelBinding =
 
 const SORT_BEFORE = -1;
 const PURE_CONSTRUCTORS = new Set(["Date"]);
+const PURE_GLOBAL_IDENTIFIERS = new Set([
+	"Array",
+	"BigInt",
+	"Boolean",
+	"Date",
+	"Function",
+	"Map",
+	"Number",
+	"Object",
+	"Promise",
+	"RegExp",
+	"Set",
+	"String",
+	"Symbol",
+	"URL",
+	"undefined"
+]);
 const PURE_GLOBAL_FUNCTIONS = new Set(["Boolean", "Number", "String"]);
 const PURE_MEMBER_METHODS = new Set([
 	"getDay",
@@ -105,59 +122,6 @@ 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.
@@ -180,50 +144,176 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			return left.localeCompare(right);
 		};
 
-		const addBoundIdentifiers = (
-			node: TSESTree.Node | null,
-			stableLocals: Set<string>
+		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 (!node) {
+			if (declaration.id.type !== "Identifier" || !declaration.init) {
+				return;
+			}
+
+			if (
+				declaration.init.type === "ArrowFunctionExpression" ||
+				declaration.init.type === "FunctionExpression"
+			) {
+				topLevelBindings.set(declaration.id.name, {
+					kind: "function",
+					node: declaration.init
+				});
 				return;
 			}
 
-			if (node.type === "Identifier") {
-				stableLocals.add(node.name);
+			topLevelBindings.set(declaration.id.name, {
+				kind: "value",
+				node: declaration.init
+			});
+		};
+
+		const addTopLevelBindings = (statement: TSESTree.ProgramStatement) => {
+			if (statement.type === "ImportDeclaration") {
+				addImportBindings(statement);
 				return;
 			}
 
-			if (node.type === "AssignmentPattern") {
-				addBoundIdentifiers(node.left, stableLocals);
+			if (statement.type === "FunctionDeclaration" && statement.id) {
+				topLevelBindings.set(statement.id.name, {
+					kind: "function",
+					node: statement
+				});
 				return;
 			}
 
-			if (node.type === "RestElement") {
-				addBoundIdentifiers(node.argument, stableLocals);
+			if (
+				statement.type !== "VariableDeclaration" ||
+				statement.kind !== "const"
+			) {
 				return;
 			}
 
-			if (node.type === "ArrayPattern") {
-				for (const element of node.elements) {
-					if (!element) {
-						continue;
-					}
+			for (const declaration of statement.declarations) {
+				addVariableBinding(declaration);
+			}
+		};
 
-					addBoundIdentifiers(element, stableLocals);
-				}
+		for (const statement of sourceCode.ast.body) {
+			addTopLevelBindings(statement);
+		}
+
+		const addBoundIdentifiers = (
+			node: TSESTree.Node | null,
+			stableLocals: Set<string>
+		) => {
+			if (!node) {
 				return;
 			}
 
-			if (node.type === "ObjectPattern") {
-				for (const property of node.properties) {
-					if (property.type === "RestElement") {
-						addBoundIdentifiers(property.argument, stableLocals);
-						continue;
+			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 (
+					statement.type !== "VariableDeclaration" ||
+					statement.kind !== "const"
+				) {
+					return;
+				}
+
+				for (const declaration of statement.declarations) {
+					addBoundIdentifiers(declaration.id, stableLocals);
+				}
+			};
 
-					addBoundIdentifiers(property.value, stableLocals);
+			for (const statement of ancestor.body) {
+				if (statement.range[0] >= node.range[0]) {
+					return;
 				}
+
+				addDeclarationBindings(statement);
+			}
+		};
+
+		const addAncestorBindingsForNode = (
+			ancestor: TSESTree.Node,
+			node: TSESTree.Node,
+			stableLocals: Set<string>
+		) => {
+			if (
+				ancestor.type !== "Program" &&
+				ancestor.type !== "BlockStatement"
+			) {
+				return;
+			}
+
+			addAncestorConstBindings(ancestor, node, stableLocals);
+		};
+
+		const addFunctionBindingsForAncestor = (
+			ancestor: TSESTree.Node,
+			stableLocals: Set<string>
+		) => {
+			if (
+				ancestor.type !== "FunctionDeclaration" &&
+				ancestor.type !== "FunctionExpression" &&
+				ancestor.type !== "ArrowFunctionExpression"
+			) {
+				return;
 			}
+
+			addFunctionParamBindings(ancestor, stableLocals);
 		};
 
 		const getStableLocalsForNode = (node: TSESTree.Node) => {
@@ -231,38 +321,11 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			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);
-					}
-				}
+				addFunctionBindingsForAncestor(ancestor, 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);
-					}
-				}
+				addAncestorBindingsForNode(ancestor, node, stableLocals);
 			}
 
 			return stableLocals;
@@ -293,6 +356,10 @@ export const sortKeysFixable: TSESLint.RuleModule<MessageIds, Options> = {
 			name: string,
 			stableLocals: ReadonlySet<string>
 		) => {
+			if (PURE_GLOBAL_IDENTIFIERS.has(name)) {
+				return true;
+			}
+
 			if (stableLocals.has(name)) {
 				return true;
 			}
@@ -313,12 +380,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;
@@ -331,63 +463,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: (
@@ -501,15 +608,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") {
@@ -531,10 +630,6 @@ 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"],
 			scopeNode: TSESTree.Node