Test/csharp extraction (#125)

* Updated beef steak

* Made using resolver public in invocation resolver

* Added support for nested classes in using filtering

* Added constructors to usingresolver symbols

* Test for useless imports

* Moved test to the right place

* Tests on instanceof

* More tests on useless imports

* More detailed test on extractor

* Added nullable types to invocation resolution

* Added generic name test and refactored Program.cs test for invocations

* Additionnal expectations for extensions

* Put my man HeadCrab back in

* Added forgotten OuterInnerClass

* Changed generic name matching

* Fixed tests

* More thorough symbol resolution in invocationResolver

Author: LeBoufty

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

@@ -10,9 +10,14 @@ describe("CSharpExtensionResolver", () => {
   const extensions = extensionResolver.getExtensions();
 
   test("should resolve extension methods in the project", () => {
-    expect(Object.keys(extensions).length).toBe(1);
+    expect(Object.keys(extensions).length).toBe(2);
     expect(extensions[""]).toBeDefined();
     expect(extensions[""].length).toBe(2);
     expect(extensions[""][0].name).toBeDefined();
+
+    expect(extensions["MyApp.BeefBurger"]).toBeDefined();
+    expect(extensions["MyApp.BeefBurger"].length).toBe(1);
+    expect(extensions["MyApp.BeefBurger"][0].name).toBeDefined();
+    expect(extensions["MyApp.BeefBurger"][0].name).toBe("Melt");
   });
 });

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

@@ -31,19 +31,27 @@ describe("CSharpExtractor", () => {
   test("should extract symbols correctly", () => {
     expect(
       extractor.extractSymbolFromFile(programpath, "Program")?.length,
-    ).toBe(9);
-    expect(
-      extractor.extractSymbolFromFile(
-        twonamespacesonefilepath,
-        "ChickenBurger.Salad",
-      )?.length,
-    ).toBe(1);
+    ).toBe(10);
+    const salad = extractor.extractSymbolFromFile(
+      twonamespacesonefilepath,
+      "ChickenBurger.Salad",
+    );
+    expect(salad.length).toBe(1);
+    const saladfile = salad[0];
+    expect(saladfile.name).toBe("Salad");
+    expect(saladfile.namespace).toBe("ChickenBurger");
+    expect(saladfile.subproject.name).toBe("TestFiles");
+    expect(saladfile.symbol).toMatchObject({
+      name: "Salad",
+      type: "class",
+      namespace: "ChickenBurger",
+    });
     expect(
       extractor.extractSymbolFromFile(
         twonamespacesonefilepath,
         "MyApp.BeefBurger.Steak",
       )?.length,
-    ).toBe(1);
+    ).toBe(2);
     expect(
       extractor.extractSymbolFromFile(seminamespacedpath, "HeadCrab")?.length,
     ).toBe(2);

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

@@ -27,56 +27,25 @@ describe("InvocationResolver", () => {
     const usedFiles = invResolver.getInvocationsFromFile(
       path.join(csharpFilesFolder, "Program.cs"),
     );
-    expect(usedFiles).toMatchObject({
-      resolvedSymbols: [
-        {
-          name: "Bun",
-          type: "class",
-          namespace: "MyApp.BeefBurger",
-        },
-        {
-          name: "Bun",
-          type: "class",
-          namespace: "ChickenBurger",
-        },
-        {
-          name: "MyClass",
-          type: "class",
-          namespace: "MyNamespace",
-        },
-        {
-          name: "Gordon",
-          type: "class",
-          namespace: "HalfNamespace",
-        },
-        {
-          name: "Freeman",
-          type: "class",
-          namespace: "",
-        },
-        {
-          name: "OuterInnerClass",
-          type: "class",
-          namespace: "OuterNamespace",
-        },
-        {
-          name: "InnerClass",
-          type: "class",
-          namespace: "OuterNamespace.InnerNamespace",
-        },
-        {
-          name: "OrderStatus",
-          type: "enum",
-          namespace: "MyApp.Models",
-        },
-        {
-          name: "HeadCrab",
-          type: "class",
-          namespace: "",
-        },
-      ],
-      unresolved: ["System.Math"],
-    });
+    const resolved = usedFiles.resolvedSymbols.map((s) =>
+      s.namespace !== "" ? s.namespace + "." + s.name : s.name,
+    );
+    const unresolved = usedFiles.unresolved;
+    expect(resolved).toContain("MyApp.BeefBurger.Bun");
+    expect(resolved).toContain("ChickenBurger.Bun");
+    expect(resolved).toContain("ChickenBurger.Salad");
+    expect(resolved).toContain("MyNamespace.MyClass");
+    expect(resolved).toContain("HalfNamespace.Gordon");
+    expect(resolved).toContain("Freeman");
+    expect(resolved).toContain("OuterNamespace.InnerNamespace.InnerClass");
+    expect(resolved).toContain("MyApp.Models.OrderStatus");
+    expect(resolved).toContain("HeadCrab"); // Used through extension Bite()
+    expect(resolved).toContain("OuterNamespace.OuterInnerClass");
+    expect(resolved).not.toContain("MyApp.BeefBurger.Salad");
+    expect(unresolved).toContain("System.Math");
+    expect(unresolved).not.toContain("string");
+    expect(unresolved).not.toContain("System");
+    expect(unresolved).not.toContain("Salad<string>");
   });
 
   test("isUsedInFile", () => {
@@ -145,4 +114,56 @@ describe("InvocationResolver", () => {
       unresolved: [],
     });
   });
+
+  test("Finds useless using directives", () => {
+    const filepath = path.join(csharpFilesFolder, "2Namespaces1File.cs");
+    const usingDirectives =
+      invResolver.usingResolver.parseUsingDirectives(filepath);
+    const invocations = invResolver.getInvocationsFromFile(filepath);
+    expect(usingDirectives.length).toBe(2);
+    expect(
+      usingDirectives.filter((d) => invResolver.isUsingUseful(invocations, d))
+        .length,
+    ).toBe(1);
+
+    const programpath = path.join(csharpFilesFolder, "Program.cs");
+    const programUsingDirectives =
+      invResolver.usingResolver.parseUsingDirectives(programpath);
+    const programInvocations = invResolver.getInvocationsFromFile(programpath);
+    expect(programUsingDirectives.length).toBe(6);
+    expect(
+      programUsingDirectives.filter((d) =>
+        invResolver.isUsingUseful(programInvocations, d),
+      ).length,
+    ).toBe(6);
+
+    const usagepath = path.join(csharpFilesFolder, "Usage.cs");
+    const usageUsingDirectives =
+      invResolver.usingResolver.parseUsingDirectives(usagepath);
+    const usageInvocations = invResolver.getInvocationsFromFile(usagepath);
+    expect(usageUsingDirectives.length).toBe(6);
+    expect(
+      usageUsingDirectives.filter((d) =>
+        invResolver.isUsingUseful(usageInvocations, d),
+      ).length,
+    ).toBe(4);
+
+    const globalusingpath = path.join(
+      csharpFilesFolder,
+      "Subfolder/GlobalUsings.cs",
+    );
+    const globalusingDirectives =
+      invResolver.usingResolver.parseUsingDirectives(globalusingpath);
+    const globalusingInvocations =
+      invResolver.getInvocationsFromFile(globalusingpath);
+    expect(globalusingDirectives.length).toBe(2);
+    expect(
+      globalusingDirectives.filter((d) =>
+        invResolver.isUsingUseful(globalusingInvocations, d),
+      ).length,
+    ).toBe(1); // Every external import is considered useful no matter what
+    // Even if there is no invocation.
+    // It's also not dangerous to remove a global using directive
+    // because they are regrouped in GlobalUsings.cs.
+  });
 });

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

@@ -41,50 +41,63 @@ const variablesQuery = new Parser.Query(
 const calledClassesQuery = new Parser.Query(
   csharpParser.getLanguage(),
   `
+  (object_creation_expression
+  type: (identifier) @cls)
+  (object_creation_expression
+  type: (qualified_name) @cls)
   ((object_creation_expression
-  type: (identifier) @cls))
-  ((object_creation_expression
-  type: (qualified_name) @cls))
+  type: (generic_name) @cls))
   (variable_declaration
   type: (identifier) @cls)
   (variable_declaration
   type: (qualified_name) @cls)
+  (variable_declaration
+  type: (generic_name) @cls)
   (parameter
   type: (identifier) @cls)
   (parameter
   type: (qualified_name) @cls)
+  (parameter
+  type: (generic_name) @cls)
   (type_argument_list
   (identifier) @cls)
   (type_argument_list
   (qualified_name) @cls)
+  (type_argument_list
+  (generic_name) @cls)
   (base_list
   (identifier) @cls)
   (base_list
   (qualified_name) @cls)
+  (base_list
+  (generic_name) @cls)
   (property_declaration
   type: (qualified_name) @cls)
   (property_declaration
   type: (identifier) @cls)
   (property_declaration
-  type: (nullable_type
-  type: (identifier) @cls))
-  (property_declaration
-  type: (nullable_type
-  type: (qualified_name) @cls))
+  type: (generic_name) @cls)
   (typeof_expression
   type: (_) @cls)
   (method_declaration
   returns: (qualified_name) @cls)
   (method_declaration
   returns: (identifier) @cls)
+  (method_declaration
+  returns: (generic_name) @cls)
   (array_type
   type: (identifier) @cls)
   (array_type
   type: (qualified_name) @cls)
-  (generic_name) @cls
+  (array_type
+  type: (generic_name) @cls)
+  (nullable_type
+  type: (identifier) @cls)
+  (nullable_type
+  type: (qualified_name) @cls)
+  (nullable_type
+  type: (generic_name) @cls)
   `,
-  // Might have to change the "(generic_name) @cls" line
-  // to be smarter, it may or may not add 1s of runtime.
 );
 
 /**
@@ -138,7 +151,7 @@ export interface Invocations {
 export class CSharpInvocationResolver {
   parser: Parser = csharpParser;
   public nsMapper: CSharpNamespaceMapper;
-  private usingResolver: CSharpUsingResolver;
+  public usingResolver: CSharpUsingResolver;
   private extensions: ExtensionMethodMap = {};
   private resolvedImports: ResolvedImports;
   private cache: Map<string, Invocations> = new Map<string, Invocations>();
@@ -179,17 +192,33 @@ export class CSharpInvocationResolver {
     // Remove any generic type information from the classname
     // Classes in the type argument list are managed on their own.
     const cleanClassname = classname.split("<")[0];
+    let cutClassname = cleanClassname;
     // Try to find the class in the resolved imports
-    const ucls = this.usingResolver.findClassInImports(
-      this.resolvedImports,
-      cleanClassname,
-      filepath,
-    );
+    let ucls = null;
+    while (!ucls) {
+      ucls = this.usingResolver.findClassInImports(
+        this.resolvedImports,
+        cleanClassname,
+        filepath,
+      );
+      if (!cutClassname.includes(".")) {
+        break;
+      }
+      cutClassname = cutClassname.split(".").slice(0, -1).join(".");
+    }
     if (ucls) {
       return ucls;
     }
     // Try to find the class in the namespace tree
-    const cls = this.nsMapper.findClassInTree(namespaceTree, cleanClassname);
+    let cls = null;
+    cutClassname = cleanClassname;
+    while (!cls) {
+      cls = this.nsMapper.findClassInTree(namespaceTree, cutClassname);
+      if (!cutClassname.includes(".")) {
+        break;
+      }
+      cutClassname = cutClassname.split(".").slice(0, -1).join(".");
+    }
     if (cls) {
       return cls;
     }
@@ -488,7 +517,10 @@ export class CSharpInvocationResolver {
         (usedNamespace.namespace &&
           inv.namespace ===
             this.nsMapper.getFullNSName(usedNamespace.namespace)) ||
-        (usedNamespace.symbol && inv.name === usedNamespace.symbol.name),
+        (usedNamespace.symbol && inv.name === usedNamespace.symbol.name) ||
+        (usedNamespace.symbol &&
+          inv.parent &&
+          inv.parent.name === usedNamespace.symbol.name),
     );
   }
 }

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

@@ -20,8 +20,8 @@ describe("CSharpMetricsAnalyzer", () => {
     const metrics = analyzeFile("2Namespaces1File.cs");
     expect(metrics).toMatchObject({
       cyclomaticComplexity: 0, // No control flow statements in this file
-      linesCount: 13, // Total lines in the file
-      codeLinesCount: 12, // Excluding blank lines and comments
+      linesCount: 42, // Total lines in the file
+      codeLinesCount: 38, // Excluding blank lines and comments
       characterCount: expect.any(Number), // Total characters in the file
       codeCharacterCount: expect.any(Number), // Characters excluding comments and whitespace
     });
@@ -75,8 +75,8 @@ describe("CSharpMetricsAnalyzer", () => {
     const metrics = analyzeFile("Program.cs");
     expect(metrics).toMatchObject({
       cyclomaticComplexity: 0, // No control flow statements in the main method
-      linesCount: 34,
-      codeLinesCount: 26,
+      linesCount: 35,
+      codeLinesCount: 27,
       characterCount: expect.any(Number),
       codeCharacterCount: expect.any(Number),
     });

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

@@ -33,6 +33,8 @@ export interface SymbolNode {
   filepath: string;
   /** The syntax node corresponding to the symbol */
   node: Parser.SyntaxNode;
+  /** The parent of the symbol if it is nested */
+  parent?: SymbolNode;
 }
 
 const DEBUG_NAMESPACE = "namespace";

packages/cli/src/languagePlugins/csharp/testFiles/csharpFiles/2Namespaces1File.cs

@@ -1,12 +1,41 @@
+using HalfNamespace;
+using MyApp.Models; // Useless using directive
+
 namespace MyApp.BeefBurger
 {
-    public class Steak { }
-    public class Cheese { }
+    public class Steak
+    {
+        private Gordon gordon;
+
+        public Steak(Gordon gordon)
+        {
+            this.gordon = gordon;
+        }
+
+        public void Cook()
+        {
+            Console.WriteLine("Gordon, we need to cook.");
+        }
+    }
+    public static class Cheese
+    {
+        public static void Melt(this Steak steak)
+        {
+            Console.WriteLine("Cheese melted.");
+        }
+    }
     public class Bun { }
 }
 namespace ChickenBurger
 {
     public class Chicken { }
-    public class Salad { }
+    public class Salad<T>
+    {
+        public T Item { get; set; }
+        public void Add(T item)
+        {
+            Item = item;
+        }
+    }
     public class Bun { }
 }