Class resolution through imports to solve ambiguities

Author: LeBoufty

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

@@ -6,6 +6,7 @@ import {
   SymbolNode,
 } from "../namespaceMapper";
 import { csharpParser } from "../../../helpers/treeSitter/parsers";
+import { CSharpUsingResolver, ResolvedImports } from "../usingResolver";
 
 export interface Invocations {
   resolvedSymbols: SymbolNode[];
@@ -15,9 +16,16 @@ export interface Invocations {
 export class CSharpInvocationResolver {
   parser: Parser = csharpParser;
   private nsMapper: CSharpNamespaceMapper;
+  private usingResolver: CSharpUsingResolver;
+  private resolvedImports: ResolvedImports;
 
   constructor(nsMapper: CSharpNamespaceMapper) {
     this.nsMapper = nsMapper;
+    this.usingResolver = new CSharpUsingResolver(nsMapper);
+    this.resolvedImports = {
+      internal: [],
+      external: [],
+    };
   }
 
   // Retrieves variable names from the given syntax node.
@@ -65,6 +73,15 @@ export class CSharpInvocationResolver {
     // Process each captured class name
     catches.forEach((ctc) => {
       const classname = ctc.node.text;
+      // Try to find the class in the resolved imports
+      const ucls = this.usingResolver.findClassInImports(
+        this.resolvedImports,
+        classname,
+      );
+      if (ucls) {
+        invocations.resolvedSymbols.push(ucls);
+        return;
+      }
       // Try to find the class in the namespace tree
       const cls = this.nsMapper.findClassInTree(namespaceTree, classname);
       if (cls) {
@@ -108,6 +125,15 @@ export class CSharpInvocationResolver {
       if (variablenames.includes(classname)) {
         return;
       }
+      // Try to find the class in the resolved imports
+      const ucls = this.usingResolver.findClassInImports(
+        this.resolvedImports,
+        classname,
+      );
+      if (ucls) {
+        invocations.resolvedSymbols.push(ucls);
+        return;
+      }
       // Try to find the class in the namespace tree
       const cls = this.nsMapper.findClassInTree(namespaceTree, classname);
       if (cls) {
@@ -122,6 +148,7 @@ export class CSharpInvocationResolver {
 
   // Gets the classes used in a file.
   getInvocationsFromFile(filepath: string): Invocations {
+    this.resolvedImports = this.usingResolver.resolveUsingDirectives(filepath);
     const file = this.nsMapper.getFile(filepath) as File;
     const invocations: Invocations = {
       resolvedSymbols: [],

packages/cli/src/languagePlugins/csharp/testFiles/csharpFiles/Program.cs

@@ -2,14 +2,15 @@
 using HalfNamespace;
 using OuterNamespace;
 using OuterNamespace.InnerNamespace;
+using BeefBurger;
 
 namespace Tests
 {
     class Program
     {
         static void Main(string[] args)
         {
-            BeefBurger.Bun beefBun = new BeefBurger.Bun();
+            Bun beefBun = new Bun();
             ChickenBurger.Bun chickenBun = new ChickenBurger.Bun();
             MyClass myClass = new MyClass();
             myClass.MyMethod();

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

@@ -90,4 +90,29 @@ describe("UsingResolver", () => {
       ],
     });
   });
+
+  test("Class resolution", () => {
+    const imports = resolver.resolveUsingDirectives("Usage.cs");
+    const user = resolver.findClassInImports(imports, "User");
+    expect(user).toMatchObject({
+      name: "User",
+      type: "class",
+      namespace: "MyApp.Models",
+      filepath: "Models.cs",
+    });
+    const gordon = resolver.findClassInImports(imports, "Gordon");
+    expect(gordon).toMatchObject({
+      name: "Gordon",
+      type: "class",
+      namespace: "HalfNamespace",
+      filepath: "SemiNamespaced.cs",
+    });
+    const guy = resolver.findClassInImports(imports, "Guy");
+    expect(guy).toMatchObject({
+      name: "User",
+      type: "class",
+      namespace: "MyApp.Models",
+      filepath: "Models.cs",
+    });
+  });
 });

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

@@ -130,4 +130,45 @@ export class CSharpUsingResolver {
     });
     return { internal, external };
   }
+
+  public findClassInImports(
+    imports: ResolvedImports,
+    className: string,
+  ): SymbolNode | null {
+    // Handle qualified class names with aliases
+    const parts = className.split(".");
+    for (let i = 0; i < parts.length; i++) {
+      const aliasMatch = imports.internal.find(
+        (symbol) => symbol.alias === parts[i],
+      );
+      if (aliasMatch && aliasMatch.symbol) {
+        parts[i] = aliasMatch.symbol.name;
+      }
+    }
+    const reconstructedClassName = parts.join(".");
+    // Check if the class is directly imported
+    const found = imports.internal.find(
+      (symbol) =>
+        "symbol" in symbol &&
+        (symbol.symbol?.name === reconstructedClassName ||
+          symbol.alias === reconstructedClassName),
+    );
+    if (found) {
+      return found.symbol ?? null;
+    }
+    // Check if the class is imported through a namespace
+    for (const symbol of imports.internal) {
+      if ("namespace" in symbol && symbol.namespace) {
+        const nsFound = this.nsMapper.findClassInTree(
+          symbol.namespace,
+          reconstructedClassName,
+        );
+        if (nsFound) {
+          return nsFound;
+        }
+      }
+    }
+
+    return null;
+  }
 }