Feature/php export resolver (#163)

* Added Zed settings for LSP

* Export resolver

* Added tests

* length test more precise

* fixed php test files

* Update index.test.ts

Author: LeBoufty

.zed/settings.json

@@ -0,0 +1,26 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+  "lsp": {
+    "deno": {
+      "settings": {
+        "deno": {
+          "enable": true
+        }
+      }
+    }
+  },
+  "languages": {
+    "TSX": {
+      "language_servers": [
+        "deno",
+        "!typescript-language-server",
+        "!vtsls",
+        "!eslint"
+      ],
+      "formatter": "language_server"
+    }
+  }
+}

src/languagePlugins/php/exportResolver/index.test.ts

@@ -0,0 +1,44 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { getPHPFilesMap } from "../testFiles/index.ts";
+import { LEARN_PHP, NESTED } from "../testFiles/constants.ts";
+import { PHPExportResolver } from "./index.ts";
+import { PHP_FUNCTION, PHP_INTERFACE, PHP_VARIABLE } from "./types.ts";
+
+describe("PHP Export resolver", () => {
+  const resolver = new PHPExportResolver();
+  const files = getPHPFilesMap();
+
+  test("resolves learnphp.php", () => {
+    const namespaces = resolver.resolveFile(files.get(LEARN_PHP)!);
+    expect(namespaces.get("My\\Namespace")).toBeDefined();
+    const mynamespace = namespaces.get("My\\Namespace")!;
+    expect(mynamespace.name).toBe("My\\Namespace");
+    const symbols = mynamespace.symbols;
+    expect(symbols.length).toBe(66);
+  });
+
+  test("resolves nested.php", () => {
+    const namespaces = resolver.resolveFile(files.get(NESTED)!);
+    expect(namespaces.get("")).toBeUndefined();
+    expect(namespaces.get("All")).toBeDefined();
+    expect(namespaces.get("All\\My")).toBeDefined();
+    expect(namespaces.get("All\\My\\Fellas")).toBeDefined();
+    expect(namespaces.get("All")!.symbols.length).toBe(1);
+    const a = namespaces.get("All")!.symbols[0];
+    expect(a.filepath).toBe(NESTED);
+    expect(a.idNode).toBeDefined();
+    expect(a.name).toBe("a");
+    expect(a.namespace).toBe("All");
+    expect(a.node).toBeDefined();
+    expect(a.type).toBe(PHP_VARIABLE);
+    expect(namespaces.get("All\\My")!.symbols.length).toBe(1);
+    const m = namespaces.get("All\\My")!.symbols[0];
+    expect(m.name).toBe("m");
+    expect(m.type).toBe(PHP_FUNCTION);
+    expect(namespaces.get("All\\My\\Fellas")!.symbols.length).toBe(1);
+    const f = namespaces.get("All\\My\\Fellas")!.symbols[0];
+    expect(f.name).toBe("f");
+    expect(f.type).toBe(PHP_INTERFACE);
+  });
+});

src/languagePlugins/php/exportResolver/index.ts

@@ -0,0 +1,72 @@
+import type Parser from "tree-sitter";
+import {
+  type ExportedNamespace,
+  type ExportedSymbol,
+  PHP_VARIABLE,
+} from "./types.ts";
+import { INTERESTING_NODES, PHP_IDNODE_QUERY } from "./queries.ts";
+
+export class PHPExportResolver {
+  #currentNamespace: string = "";
+  #currentFile: string = "";
+
+  resolveFile(
+    file: { path: string; rootNode: Parser.SyntaxNode },
+  ): Map<string, ExportedNamespace> {
+    const namespaces: Map<string, ExportedNamespace> = new Map();
+    this.#currentNamespace =
+      file.rootNode.children.find((c) =>
+        c.type === "namespace_definition" && !c.childForFieldName("body")
+      )?.childForFieldName("name")?.text ?? "";
+    this.#currentFile = file.path;
+    const allSymbols = this.#resolveNode(file.rootNode, this.#currentNamespace);
+    for (const symbol of allSymbols) {
+      if (!namespaces.has(symbol.namespace)) {
+        namespaces.set(symbol.namespace, {
+          name: symbol.namespace,
+          symbols: [],
+        });
+      }
+      namespaces.get(symbol.namespace)!.symbols.push(symbol);
+    }
+    return namespaces;
+  }
+
+  #resolveNode(node: Parser.SyntaxNode, nsname: string): ExportedSymbol[] {
+    const exports: ExportedSymbol[] = [];
+    for (const child of node.children) {
+      if (INTERESTING_NODES.has(child.type)) {
+        const idNode = PHP_IDNODE_QUERY.captures(child).at(0);
+        if (!idNode) {
+          continue; // Root out false positives for variables and constants
+        }
+        const symType = INTERESTING_NODES.get(child.type)!;
+        if (
+          symType === PHP_VARIABLE &&
+          exports.find((e) => e.name === idNode.node.text)
+        ) {
+          continue; // No duplicate variables
+        }
+        exports.push({
+          name: idNode.node.text,
+          type: symType,
+          filepath: this.#currentFile,
+          namespace: nsname,
+          node: child,
+          idNode: idNode.node,
+        });
+      }
+    }
+    for (
+      const ns of node.children.filter((c) =>
+        c.type === "namespace_definition" && c.childForFieldName("body")
+      )
+    ) {
+      const fullnsname = (nsname !== "" ? nsname + "\\" : "") +
+        ns.childForFieldName("name")!.text;
+      const nsnode = ns.childForFieldName("body")!;
+      exports.push(...this.#resolveNode(nsnode, fullnsname));
+    }
+    return exports;
+  }
+}

src/languagePlugins/php/exportResolver/queries.ts

@@ -0,0 +1,62 @@
+import Parser from "tree-sitter";
+import { phpParser } from "../../../helpers/treeSitter/parsers.ts";
+import {
+  PHP_CLASS,
+  PHP_CONSTANT,
+  PHP_FUNCTION,
+  PHP_INTERFACE,
+  PHP_TRAIT,
+  PHP_VARIABLE,
+  type SymbolType,
+} from "./types.ts";
+
+export const INTERESTING_NODES = new Map<string, SymbolType>([
+  ["const_declaration", PHP_CONSTANT],
+  ["function_definition", PHP_FUNCTION],
+  ["class_declaration", PHP_CLASS],
+  ["interface_declaration", PHP_INTERFACE],
+  ["expression_statement", PHP_VARIABLE],
+  ["function_call_expression", PHP_CONSTANT],
+  ["trait_declaration", PHP_TRAIT],
+]);
+
+export const PHP_IDNODE_QUERY = new Parser.Query(
+  phpParser.getLanguage(),
+  `
+  [
+  (expression_statement
+  (assignment_expression
+  left: (variable_name
+  (name) @name)))
+
+  (const_declaration
+  (const_element
+  (name) @name ))
+
+  (expression_statement
+  (reference_assignment_expression
+  left: (variable_name
+  (name) @name)))
+
+  (function_definition
+  name: (name) @name)
+
+  (class_declaration
+  name: (name) @name)
+
+  (trait_declaration
+  name: (name) @name)
+
+  (interface_declaration
+  name: (name) @name)
+
+  (namespace_definition
+  name: (_) @name)
+
+  (function_call_expression
+  arguments: (arguments
+  . (argument (string (string_content) @name))
+  ))
+  ]
+  `,
+);

src/languagePlugins/php/exportResolver/types.ts

@@ -0,0 +1,29 @@
+import type Parser from "tree-sitter";
+
+export const PHP_VARIABLE = "variable";
+export const PHP_CONSTANT = "constant";
+export const PHP_FUNCTION = "function";
+export const PHP_CLASS = "class";
+export const PHP_INTERFACE = "interface";
+export const PHP_TRAIT = "trait";
+export type SymbolType =
+  | typeof PHP_VARIABLE
+  | typeof PHP_CONSTANT
+  | typeof PHP_FUNCTION
+  | typeof PHP_CLASS
+  | typeof PHP_INTERFACE
+  | typeof PHP_TRAIT;
+
+export interface ExportedNamespace {
+  name: string;
+  symbols: ExportedSymbol[];
+}
+
+export interface ExportedSymbol {
+  name: string;
+  type: SymbolType;
+  filepath: string;
+  namespace: string;
+  node: Parser.SyntaxNode;
+  idNode: Parser.SyntaxNode;
+}

src/languagePlugins/php/testFiles/constants.ts

@@ -0,0 +1,5 @@
+import { phpFilesFolder } from "./index.ts";
+import { join } from "@std/path";
+
+export const LEARN_PHP = join(phpFilesFolder, "learnphp.php");
+export const NESTED = join(phpFilesFolder, "nested.php");

src/languagePlugins/php/testFiles/index.ts

@@ -0,0 +1,75 @@
+import * as fs from "node:fs";
+import { extname, join } from "@std/path";
+import type Parser from "tree-sitter";
+import { phpLanguage, phpParser } from "../../../helpers/treeSitter/parsers.ts";
+
+if (!import.meta.dirname) {
+  throw new Error("import.meta.dirname is not defined");
+}
+export const phpFilesFolder = join(
+  import.meta.dirname,
+  "phpFiles",
+);
+const phpFilesMap = new Map<
+  string,
+  { path: string; rootNode: Parser.SyntaxNode }
+>();
+
+/**
+ * Recursively finds all C files in the given directory and its subdirectories.
+ * @param dir - The directory to search in.
+ */
+function findPHPFiles(dir: string) {
+  const files = fs.readdirSync(dir);
+  files.forEach((file) => {
+    const fullPath = join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      if (
+        !fullPath.includes(".extracted/") &&
+        !fullPath.includes("bin/") &&
+        !fullPath.includes("obj/")
+      ) {
+        findPHPFiles(fullPath);
+      }
+    } else if (
+      extname(fullPath) === ".php"
+    ) {
+      const content = fs.readFileSync(fullPath, "utf8");
+      const tree = phpParser.parse(content);
+      phpFilesMap.set(fullPath, { path: fullPath, rootNode: tree.rootNode });
+    }
+  });
+}
+
+export function getPHPFilesMap(): Map<
+  string,
+  { path: string; rootNode: Parser.SyntaxNode }
+> {
+  findPHPFiles(phpFilesFolder);
+  return phpFilesMap;
+}
+
+export function getPHPFilesContentMap(): Map<
+  string,
+  { path: string; content: string }
+> {
+  findPHPFiles(phpFilesFolder);
+  const contentMap = new Map<string, { path: string; content: string }>();
+  for (const [filePath, file] of phpFilesMap) {
+    contentMap.set(filePath, {
+      path: file.path,
+      content: file.rootNode.text,
+    });
+  }
+  return contentMap;
+}
+
+export const dummyLocalConfig = {
+  language: phpLanguage,
+  project: {
+    include: [],
+    exclude: [],
+  },
+  outDir: "./dist",
+};