Refactor post-processing of irregular imports/resolveds (#1156)

Author: webpro

packages/knip/src/ProjectPrincipal.ts

@@ -260,25 +260,28 @@ export class ProjectPrincipal {
 
     const { imports, ...rest } = _getImportsAndExports(sourceFile, resolve, typeChecker, { ...options, skipExports });
 
-    const { internal, resolved, specifiers, unresolved, external } = imports;
+    const { internal, resolved: _resolved, specifiers: _specifiers, unresolved: _unresolved, external } = imports;
 
-    const unresolvedImports = new Set<UnresolvedImport>();
+    // Post-processing (1)
+    const specifiers = new Set<string>();
+    const resolved = new Set<string>();
+    const unresolved = new Set<UnresolvedImport>();
 
-    for (const [specifier, specifierFilePath] of specifiers) {
+    for (const [specifier, specifierFilePath] of _specifiers) {
       const packageName = getPackageNameFromModuleSpecifier(specifier);
       if (packageName && isInternalWorkspace(packageName)) {
         external.add(packageName);
         const principal = getPrincipalByFilePath(specifierFilePath);
-        if (principal && !isGitIgnored(specifierFilePath)) principal.addNonEntryPath(specifierFilePath);
+        if (principal && !isGitIgnored(specifierFilePath)) specifiers.add(specifierFilePath);
       }
     }
 
-    for (const filePath of resolved) {
+    for (const filePath of _resolved) {
       const isIgnored = isGitIgnored(filePath);
-      if (!isIgnored) this.addEntryPath(filePath, { skipExportsAnalysis: true });
+      if (!isIgnored) resolved.add(filePath);
     }
 
-    for (const unresolvedImport of unresolved) {
+    for (const unresolvedImport of _unresolved) {
       const { specifier } = unresolvedImport;
 
       // Ignore Deno style http import specifiers
@@ -295,14 +298,12 @@ export class ProjectPrincipal {
         if (!isIgnored) {
           const ext = extname(sanitizedSpecifier);
           const hasIgnoredExtension = FOREIGN_FILE_EXTENSIONS.has(ext);
-          if (!ext || (ext !== '.json' && !hasIgnoredExtension)) {
-            unresolvedImports.add(unresolvedImport);
-          }
+          if (!ext || (ext !== '.json' && !hasIgnoredExtension)) unresolved.add(unresolvedImport);
         }
       }
     }
 
-    return { imports: { internal, unresolved: unresolvedImports, external }, ...rest };
+    return { imports: { internal, external, specifiers, resolved, unresolved }, ...rest };
   }
 
   invalidateFile(filePath: string) {

packages/knip/src/graph/build.ts

@@ -374,7 +374,10 @@ export async function build({
 
       graph.set(filePath, node);
 
-      // A bit out of place, but good spot to add source files referenced from scripts recursively
+      // Post-processing (2)
+      for (const filePath of imports.resolved) principal.addEntryPath(filePath, { skipExportsAnalysis: true });
+      for (const filePath of imports.specifiers) principal.addNonEntryPath(filePath);
+
       if (scripts && scripts.size > 0) {
         const dependencies = deputy.getDependencies(workspace.name);
         const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
@@ -385,7 +388,7 @@ export async function build({
           input.containingFilePath ??= filePath;
           input.dir ??= dir;
           const specifierFilePath = getReferencedInternalFilePath(input, workspace);
-          if (specifierFilePath) analyzeSourceFile(specifierFilePath, principal);
+          if (specifierFilePath) principal.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
         }
       }
     }

packages/knip/src/types/module-graph.ts

@@ -61,6 +61,8 @@ export type FileNode = {
     internal: ImportMap;
     external: Set<string>;
     unresolved: Set<UnresolvedImport>;
+    resolved: Set<FilePath>;
+    specifiers: Set<FilePath>;
   };
   exports: ExportMap;
   duplicates: Iterable<Array<IssueSymbol>>;

packages/knip/src/util/module-graph.ts

@@ -38,6 +38,8 @@ const createFileNode = (): FileNode => ({
     internal: new Map(),
     external: new Set(),
     unresolved: new Set(),
+    resolved: new Set(),
+    specifiers: new Set(),
   },
   exports: new Map(),
   duplicates: new Set(),