Feature/java invocation resolver (#151)

* Fixed wildcard imports breaking queries

* Invocation resolver

* Absolute foolproof safety

Author: LeBoufty

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

@@ -0,0 +1,33 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { getJavaFilesMap } from "../testFiles/index.ts";
+import { JavaInvocationResolver } from "./index.ts";
+import { JavaPackageMapper } from "../packageMapper/index.ts";
+import { JavaImportResolver } from "../importResolver/index.ts";
+import { APP, WORMKILLER } from "../testFiles/constants.ts";
+
+describe("Java Invocation Resolver", () => {
+  const files = getJavaFilesMap();
+  const mapper = new JavaPackageMapper(files);
+  const impResolver = new JavaImportResolver(mapper);
+  const resolver = new JavaInvocationResolver(impResolver);
+  const invocations = resolver.invocations;
+
+  test("resolves Wormkiller.java", () => {
+    const killerinv = invocations.get(WORMKILLER)!;
+    expect(killerinv.unresolved.has("Sandworm")).toBe(true);
+    expect(killerinv.unresolved.has("Pebble.Sandworm")).toBe(true);
+    const resolved = Array.from(killerinv.resolved.keys());
+    expect(resolved).toContain("Steak");
+    expect(resolved).toContain("Pebble");
+  });
+
+  test("resolves App.java", () => {
+    const appinv = invocations.get(APP)!;
+    console.log(impResolver.imports.get(APP)!);
+    expect(appinv.unresolved.has("System.out")).toBe(false);
+    expect(appinv.unresolved.has("System")).toBe(true);
+    const resolved = Array.from(appinv.resolved.keys());
+    expect(resolved).toContain("restaurantCount");
+  });
+});

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

@@ -0,0 +1,53 @@
+import type { JavaImportResolver } from "../importResolver/index.ts";
+import type { JavaImports } from "../importResolver/types.ts";
+import type { JavaPackageMapper } from "../packageMapper/index.ts";
+import { ConcreteNode } from "../packageMapper/types.ts";
+import type { JavaFile } from "../packageResolver/types.ts";
+import { JAVA_INVOCATION_QUERY, JAVA_VARIABLES_QUERY } from "./queries.ts";
+import type { Invocations } from "./types.ts";
+
+export class JavaInvocationResolver {
+  mapper: JavaPackageMapper;
+  imports: Map<string, JavaImports>;
+  invocations: Map<string, Invocations>;
+
+  constructor(resolver: JavaImportResolver) {
+    this.mapper = resolver.mapper;
+    this.imports = resolver.imports;
+    this.invocations = new Map();
+    for (const [key, f] of this.mapper.files) {
+      this.invocations.set(key, this.getInvocations(f));
+    }
+  }
+
+  getInvocations(file: JavaFile): Invocations {
+    const variables = new Set(
+      JAVA_VARIABLES_QUERY.captures(file.symbol.node).map((c) => c.node.text),
+    );
+    const captures = JAVA_INVOCATION_QUERY.captures(file.symbol.node).map((c) =>
+      c.node.text
+    );
+    const resolvedImports = this.imports.get(file.path)!.resolved;
+    const resolved = new Map<string, ConcreteNode>();
+    const unresolved = new Set<string>();
+    for (const c of captures) {
+      // Check variables
+      if (variables.has(c)) {
+        continue;
+      }
+      // Check imports
+      if (resolvedImports.has(c)) {
+        resolved.set(c, resolvedImports.get(c)!);
+      } else {
+        // Check project
+        const cnode = this.mapper.tree.getNode(c);
+        if (cnode && cnode instanceof ConcreteNode) {
+          resolved.set(c, cnode);
+        } else {
+          unresolved.add(c);
+        }
+      }
+    }
+    return { resolved, unresolved };
+  }
+}

packages/cli/src/languagePlugins/java/invocationResolver/queries.ts

@@ -0,0 +1,21 @@
+import Parser from "npm:tree-sitter";
+import { javaParser } from "../../../helpers/treeSitter/parsers.ts";
+
+export const JAVA_INVOCATION_QUERY = new Parser.Query(
+  javaParser.getLanguage(),
+  `
+  [
+  (scoped_type_identifier)
+  (type_identifier)
+  (identifier)
+  ] @any
+  `,
+);
+
+export const JAVA_VARIABLES_QUERY = new Parser.Query(
+  javaParser.getLanguage(),
+  `
+  (variable_declarator name: (_) @var)
+  (formal_parameter name: (_) @var)
+  `,
+);

packages/cli/src/languagePlugins/java/invocationResolver/types.ts

@@ -0,0 +1,6 @@
+import type { ConcreteNode } from "../packageMapper/types.ts";
+
+export interface Invocations {
+  resolved: Map<string, ConcreteNode>;
+  unresolved: Set<string>;
+}

packages/cli/src/languagePlugins/java/packageResolver/index.ts

@@ -14,7 +14,9 @@ export class JavaPackageResolver {
     const packagename = captures.find((c) => c.name === "package")?.node.text ??
       "";
     const imports = captures.filter((c) => c.name === "import").map((c) =>
-      c.node.text
+      // Unholy string manipulation because wildcard imports break tree-sitter queries.
+      c.node.text.split(" ").findLast((s) => s.length > 0 && s !== ";")!
+        .replace(";", "")
     );
     const declaration = captures.find((c) =>
       !["package", "import"].includes(c.name)

packages/cli/src/languagePlugins/java/packageResolver/queries.ts

@@ -5,7 +5,7 @@ export const JAVA_PROGRAM_QUERY = new Parser.Query(
   javaParser.getLanguage(),
   `(program [
   (package_declaration (_) @package)
-  (import_declaration (_) @import)
+  (import_declaration) @import
   (class_declaration) @class
   (interface_declaration) @interface
   (enum_declaration) @enum

packages/cli/src/languagePlugins/java/testFiles/napi-tests/src/main/java/io/nanoapi/testfiles/App.java

@@ -1,10 +1,14 @@
 package io.nanoapi.testfiles;
 
+import static io.nanoapi.testfiles.food.Burger.*;
+
 /**
  * Hello world!
  */
 public class App {
+
     public static void main(String[] args) {
+        restaurantCount++;
         System.out.println("Hello World!");
     }
 }