Fix/eliminate obsolete usings (#118)

* Made usingResolver in extractor public

* Made usingResolver symbols into classes

* Made resolveUsingDirective public

* Removed obsolete usings

* Added caching

* Moved using validation to somewhere it actually does something

Author: LeBoufty

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

@@ -25,7 +25,7 @@ export class CSharpExtractor {
   private manifest: DependencyManifest;
   public projectMapper: CSharpProjectMapper;
   private nsMapper: CSharpNamespaceMapper;
-  private usingResolver: CSharpUsingResolver;
+  public usingResolver: CSharpUsingResolver;
 
   constructor(
     files: Map<string, { path: string; content: string }>,
@@ -91,17 +91,19 @@ export class CSharpExtractor {
     symbol: SymbolNode,
     visited: Set<SymbolNode> = new Set<SymbolNode>(),
   ): SymbolNode[] {
-    const allDependencies: SymbolNode[] = [];
+    const allDependencies: Set<SymbolNode> = new Set<SymbolNode>();
     if (visited.has(symbol)) {
-      return allDependencies;
+      return Array.from(allDependencies);
     }
     visited.add(symbol);
     const dependencies = this.findDependencies(symbol);
     for (const dependency of dependencies) {
-      allDependencies.push(dependency);
-      allDependencies.push(...this.findAllDependencies(dependency, visited));
+      allDependencies.add(dependency);
+      for (const dep of this.findAllDependencies(dependency, visited)) {
+        allDependencies.add(dep);
+      }
     }
-    return allDependencies;
+    return Array.from(allDependencies);
   }
 
   /**

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

@@ -52,7 +52,7 @@ export interface UsingDirective {
 /**
  * Interface representing an internal symbol resolved from a 'using' directive
  */
-export interface InternalSymbol {
+export class InternalSymbol {
   /** The type of 'using' directive */
   usingtype: UsingType;
   /** The filepath it is imported in */
@@ -68,7 +68,7 @@ export interface InternalSymbol {
 /**
  * Interface representing an external symbol resolved from a 'using' directive
  */
-export interface ExternalSymbol {
+export class ExternalSymbol {
   /** The type of 'using' directive */
   usingtype: UsingType;
   /** The filepath it is imported in */
@@ -101,6 +101,10 @@ export class CSharpUsingResolver {
     string,
     ResolvedImports
   >();
+  private cachedDirectives: Map<string, UsingDirective[]> = new Map<
+    string,
+    UsingDirective[]
+  >();
   public projectmapper: CSharpProjectMapper;
   private cachedExternalDeps: Set<string> = new Set<string>();
 
@@ -118,6 +122,9 @@ export class CSharpUsingResolver {
    * @returns An array of UsingDirective objects.
    */
   public parseUsingDirectives(filepath: string): UsingDirective[] {
+    if (this.cachedDirectives.has(filepath)) {
+      return this.cachedDirectives.get(filepath) as UsingDirective[];
+    }
     const file = this.nsMapper.getFile(filepath);
     if (!file) {
       return [];
@@ -141,6 +148,8 @@ export class CSharpUsingResolver {
       const alias = aliasNode ? aliasNode.text : undefined;
       return { node, type, filepath, id, alias };
     });
+    // Cache the using directives for the file
+    this.cachedDirectives.set(filepath, this.usingDirectives);
     return this.usingDirectives;
   }
 
@@ -168,7 +177,7 @@ export class CSharpUsingResolver {
    * @param directive - The 'using' directive to resolve.
    * @returns An InternalSymbol or ExternalSymbol object.
    */
-  private resolveUsingDirective(
+  public resolveUsingDirective(
     directive: UsingDirective,
   ): InternalSymbol | ExternalSymbol {
     const { type, filepath, id, alias } = directive;

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

@@ -8,6 +8,15 @@ import {
 } from "../../languagePlugins/csharp/extractor/index.js";
 import { DependencyManifest } from "@nanoapi.io/shared";
 import { DotNetProject } from "../../languagePlugins/csharp/projectMapper/index.js";
+import Parser from "tree-sitter";
+import { csharpParser } from "../../helpers/treeSitter/parsers.js";
+import { CSharpNamespaceMapper } from "../../languagePlugins/csharp/namespaceMapper/index.js";
+import { CSharpProjectMapper } from "../../languagePlugins/csharp/projectMapper/index.js";
+import {
+  CSharpUsingResolver,
+  InternalSymbol,
+  ExternalSymbol,
+} from "../../languagePlugins/csharp/usingResolver/index.js";
 
 /**
  * Extracts C# symbols from the given files.
@@ -27,6 +36,11 @@ export function extractCSharpSymbols(
   console.time(`Extracted ${symbolsToExtract.size} symbol(s)`);
   const extractor = new CSharpExtractor(files, dependencyManifest);
   const extractedFiles: ExtractedFile[] = [];
+  const parsedFiles = new Map<
+    string,
+    { path: string; rootNode: Parser.SyntaxNode }
+  >();
+  const csprojFiles = new Map<string, { path: string; content: string }>();
   // Extract symbols from the files
   for (const symbolSet of symbolsToExtract.values()) {
     for (const symbol of symbolSet.symbols) {
@@ -35,10 +49,65 @@ export function extractCSharpSymbols(
         symbol,
       );
       if (extractedFile) {
+        // Add the extracted file to the list of extracted files
         extractedFiles.push(...extractedFile);
+        // Add the extracted file to the parsed files map
+        // This is used to create a representation of the exported project
+        // It will help us to find which namespaces cannot be used in using directives anymore
+        for (const file of extractedFile) {
+          const filePath = file.name;
+          if (!parsedFiles.has(filePath)) {
+            parsedFiles.set(filePath, {
+              path: filePath,
+              rootNode: csharpParser.parse(extractor.getContent(file)).rootNode,
+            });
+          }
+          // Add the csproj file to the csproj files map
+          const subproject = file.subproject;
+          if (!csprojFiles.has(subproject.csprojPath)) {
+            csprojFiles.set(subproject.csprojPath, {
+              path: subproject.csprojPath,
+              content: subproject.csprojContent,
+            });
+            const globalUsingsPath = path.join(
+              subproject.rootFolder,
+              "GlobalUsings.cs",
+            );
+            const globalUsingsContent =
+              extractor.generateGlobalUsings(subproject);
+            if (!parsedFiles.has(globalUsingsPath)) {
+              parsedFiles.set(globalUsingsPath, {
+                path: globalUsingsPath,
+                rootNode: csharpParser.parse(globalUsingsContent).rootNode,
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  // For each extracted file, check if the using directives are still valid
+  const nsMapper = new CSharpNamespaceMapper(parsedFiles);
+  const pjMapper = new CSharpProjectMapper(csprojFiles);
+  const usingResolver = new CSharpUsingResolver(nsMapper, pjMapper);
+  for (const extractedFile of extractedFiles) {
+    const imports = extractedFile.imports;
+    for (const importDirective of imports) {
+      const resolvedInNewFile =
+        usingResolver.resolveUsingDirective(importDirective);
+      const resolvedInOldFile =
+        extractor.usingResolver.resolveUsingDirective(importDirective);
+      if (
+        resolvedInNewFile instanceof ExternalSymbol &&
+        resolvedInOldFile instanceof InternalSymbol
+      ) {
+        extractedFile.imports = extractedFile.imports.filter(
+          (imp) => imp !== importDirective,
+        );
       }
     }
   }
+  // Actually extract the files
   const subprojects: DotNetProject[] = [];
   const extractedFilesMap: ExtractedFilesMap = new Map();
   for (const extractedFile of extractedFiles) {
@@ -62,9 +131,11 @@ export function extractCSharpSymbols(
       `${name}.cs`,
     );
     if (!extractedFilesMap.has(key)) {
+      const filecontent = extractor.getContent(extractedFile);
+      // Add the extracted file to the output map
       extractedFilesMap.set(key, {
         path: key,
-        content: extractor.getContent(extractedFile),
+        content: filecontent,
       });
     }
   }
@@ -73,6 +144,7 @@ export function extractCSharpSymbols(
     const projectPath = path.join(subproject.name, `${subproject.name}.csproj`);
     const globalUsingPath = path.join(subproject.name, "GlobalUsings.cs");
     if (!extractedFilesMap.has(projectPath)) {
+      // Add the project files to the output map
       extractedFilesMap.set(projectPath, {
         path: projectPath,
         content: subproject.csprojContent,