Remove internal using directives if no symbols from them are used (#120)

Author: LeBoufty

packages/cli/src/languagePlugins/csharp/invocationResolver/index.ts

@@ -8,7 +8,9 @@ import {
 import { csharpParser } from "../../../helpers/treeSitter/parsers.js";
 import {
   CSharpUsingResolver,
+  ExternalSymbol,
   ResolvedImports,
+  UsingDirective,
 } from "../usingResolver/index.js";
 import { CSharpProjectMapper } from "../projectMapper/index.js";
 import {
@@ -464,4 +466,25 @@ export class CSharpInvocationResolver {
     const invocations = this.getInvocationsFromFile(filepath);
     return invocations.resolvedSymbols.some((inv) => inv.name === symbol.name);
   }
+
+  /**
+   * Checks if a using directive is useful in a file.
+   * @param invocations - The invocations in the file.
+   * @param using - The using directive to check for.
+   * @returns True if the using directive is useful, false otherwise.
+   */
+  public isUsingUseful(
+    invocations: Invocations,
+    usingD: UsingDirective,
+  ): boolean {
+    const usedNamespace = this.usingResolver.resolveUsingDirective(usingD);
+    if (usedNamespace instanceof ExternalSymbol) return true;
+    return invocations.resolvedSymbols.some(
+      (inv) =>
+        (usedNamespace.namespace &&
+          inv.namespace ===
+            this.nsMapper.getFullNSName(usedNamespace.namespace)) ||
+        (usedNamespace.symbol && inv.name === usedNamespace.symbol.name),
+    );
+  }
 }

packages/cli/src/symbolExtractor/csharp/index.ts

@@ -17,6 +17,7 @@ import {
   InternalSymbol,
   ExternalSymbol,
 } from "../../languagePlugins/csharp/usingResolver/index.js";
+import { CSharpInvocationResolver } from "../../languagePlugins/csharp/invocationResolver/index.js";
 
 /**
  * Extracts C# symbols from the given files.
@@ -86,20 +87,25 @@ export function extractCSharpSymbols(
       }
     }
   }
-  // For each extracted file, check if the using directives are still valid
+  // For each extracted file, check if the using directives are still valid and useful
   const nsMapper = new CSharpNamespaceMapper(parsedFiles);
   const pjMapper = new CSharpProjectMapper(csprojFiles);
   const usingResolver = new CSharpUsingResolver(nsMapper, pjMapper);
+  const invocationResolver = new CSharpInvocationResolver(nsMapper, pjMapper);
   for (const extractedFile of extractedFiles) {
     const imports = extractedFile.imports;
+    const invocations = invocationResolver.getInvocationsFromFile(
+      extractedFile.name,
+    );
     for (const importDirective of imports) {
       const resolvedInNewFile =
         usingResolver.resolveUsingDirective(importDirective);
       const resolvedInOldFile =
         extractor.usingResolver.resolveUsingDirective(importDirective);
       if (
-        resolvedInNewFile instanceof ExternalSymbol &&
-        resolvedInOldFile instanceof InternalSymbol
+        (resolvedInNewFile instanceof ExternalSymbol &&
+          resolvedInOldFile instanceof InternalSymbol) ||
+        !invocationResolver.isUsingUseful(invocations, importDirective)
       ) {
         extractedFile.imports = extractedFile.imports.filter(
           (imp) => imp !== importDirective,