eslint-plugin-unslop 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.2.0",
+  version: "0.2.1",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -1163,10 +1163,18 @@ function reportTopLevelOrdering(program, context) {
   const helpers = collectHelpers(body);
   const refs = collectReferences(context.sourceCode.scopeManager.globalScope);
   const cyclicNames = findCyclicHelperNames(body, helpers, refs);
-  const fixRange = buildTopLevelFixRange({ body, helpers, refs, cyclicNames, context });
+  const eagerHelperNames = findEagerHelperNames(body, helpers, refs);
+  const fixRange = buildTopLevelFixRange({
+    body,
+    helpers,
+    refs,
+    cyclicNames,
+    eagerHelperNames,
+    context
+  });
   for (const helper of helpers) {
     if (cyclicNames.has(helper.name)) continue;
-    if (hasEagerReference(body, helper, refs)) continue;
+    if (eagerHelperNames.has(helper.name)) continue;
     const consumer = findFirstConsumerEntry(body, helper, refs)?.statement;
     if (!consumer) continue;
     context.report({
@@ -1182,19 +1190,26 @@ function reportTopLevelOrdering(program, context) {
   }
 }
 function buildTopLevelFixRange(input) {
-  const { body, helpers, refs, cyclicNames, context } = input;
+  const { body, helpers, refs, cyclicNames, eagerHelperNames, context } = input;
   if (body.length < 2) return void 0;
-  const edges = collectTopLevelEdges(body, helpers, refs, cyclicNames);
+  const edges = collectTopLevelEdges({
+    body,
+    helpers,
+    refs,
+    cyclicNames,
+    eagerHelperNames
+  });
   if (edges.length === 0) return void 0;
   const order = stableTopologicalOrder(body.length, edges);
   if (!order || isIdentityOrder(order)) return void 0;
   const orderedBody = order.map((index) => body[index]);
   return createSafeReorderFix(context.sourceCode, body, orderedBody);
 }
-function collectTopLevelEdges(body, helpers, refs, cyclicNames) {
+function collectTopLevelEdges(input) {
+  const { body, helpers, refs, cyclicNames, eagerHelperNames } = input;
   const edges = [];
   for (const helper of helpers) {
-    if (cyclicNames.has(helper.name) || hasEagerReference(body, helper, refs)) continue;
+    if (cyclicNames.has(helper.name) || eagerHelperNames.has(helper.name)) continue;
     const consumer = findFirstConsumerEntry(body, helper, refs);
     if (!consumer) continue;
     edges.push([consumer.index, helper.index]);
@@ -1322,32 +1337,78 @@ function collectReferences(scope) {
   }
   return refs;
 }
-function hasEagerReference(body, helper, refs) {
-  for (let i = helper.index + 1; i < body.length; i += 1) {
-    const stmt = body[i];
-    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) continue;
-    if (statementHasEagerUse(stmt, helper.name, refs)) return true;
+function findEagerHelperNames(body, helpers, refs) {
+  const helperNames = new Set(helpers.map((helper) => helper.name));
+  const deps = collectHelperRuntimeDependencies(body, helpers, refs, helperNames);
+  const roots = collectEagerRootNames(body, refs, helperNames);
+  return collectReachableNames(roots, deps);
+}
+function collectHelperRuntimeDependencies(body, helpers, refs, helperNames) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const helper of helpers) {
+    const statement = body[helper.index];
+    if (!statement) continue;
+    const names = collectRuntimeNamesInStatement(statement, refs, helperNames);
+    names.delete(helper.name);
+    deps.set(helper.name, names);
   }
-  return false;
+  return deps;
 }
-function statementHasEagerUse(statement, name, refs) {
-  const range = statement.range;
-  if (!range) return false;
+function collectEagerRootNames(body, refs, helperNames) {
+  const roots = /* @__PURE__ */ new Set();
   for (const ref of refs) {
-    if (ref.identifier.name !== name || isTypeReference(ref)) continue;
-    if (isEagerRefInRange(ref, range)) return true;
+    if (!isRuntimeHelperReadReference(ref, helperNames)) continue;
+    if (!isEagerRefInTopLevelStatement(ref, body)) continue;
+    roots.add(ref.identifier.name);
   }
-  return false;
+  return roots;
 }
-function isEagerRefInRange(ref, range) {
-  const idRange = ref.identifier.range;
-  if (!idRange) return false;
-  const inside = idRange[0] >= range[0] && idRange[1] <= range[1];
-  return inside && (ref.from.type === "module" || ref.from.type === "global");
+function isEagerRefInTopLevelStatement(ref, body) {
+  if (ref.from.type !== "module" && ref.from.type !== "global") return false;
+  const statement = findTopLevelStatementForRef(body, ref);
+  if (!statement) return false;
+  return statement.type !== "ExportNamedDeclaration" || !!statement.declaration;
+}
+function findTopLevelStatementForRef(body, ref) {
+  return body.find((statement) => isReferenceInsideStatement(ref, statement));
+}
+function collectRuntimeNamesInStatement(statement, refs, helperNames) {
+  const names = /* @__PURE__ */ new Set();
+  if (!statement.range) return names;
+  for (const ref of refs) {
+    if (!isRuntimeHelperReadReference(ref, helperNames)) continue;
+    if (!isReferenceInsideStatement(ref, statement)) continue;
+    names.add(ref.identifier.name);
+  }
+  return names;
+}
+function isReferenceInsideStatement(ref, statement) {
+  const range = ref.identifier.range;
+  if (!range || !statement.range) return false;
+  return range[0] >= statement.range[0] && range[1] <= statement.range[1];
+}
+function collectReachableNames(roots, deps) {
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [...roots];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || reachable.has(current)) continue;
+    reachable.add(current);
+    for (const dep of deps.get(current) ?? []) queue.push(dep);
+  }
+  return reachable;
+}
+function isRuntimeHelperReadReference(ref, helperNames) {
+  if (isTypeReference(ref)) return false;
+  if (!isReadReference(ref)) return false;
+  return helperNames.has(ref.identifier.name);
 }
 function isTypeReference(ref) {
   return "isTypeReference" in ref && ref.isTypeReference === true;
 }
+function isReadReference(ref) {
+  return typeof ref.isRead === "function" ? ref.isRead() : true;
+}
 function getSymbolName(statement) {
   if (statement.type === "ExportDefaultDeclaration") return "default export";
   if (statement.type === "ExportNamedDeclaration") return getNamedExportName(statement);